00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef _MbSampleMeshBuilder_H
00024 #define _MbSampleMeshBuilder_H
00025
00026 #include <mesh/volumes/MbVolumeMeshTetrahedron.h>
00027 #include <mesh/volumes/MbVolumeMeshHexahedron.h>
00028 #include <mesh/volumes/MbVolumeMeshRegular.h>
00029 #include <mesh/volumes/MbVolumeMeshRectilinear.h>
00030 #include <mesh/volumes/MbVolumeMeshCurvilinear.h>
00031 #include <mesh/volumes/MbHexahedronMeshIjk.h>
00032 #include <mesh/volumes/MbVertexHexahedronMeshIjk.h>
00033 #include <mesh/surfaces/MbSurfaceMeshPolygon.h>
00034 #include <mesh/surfaces/MbSurfaceMeshRegular.h>
00035 #include <mesh/surfaces/MbSurfaceMeshRectilinear.h>
00036 #include <mesh/surfaces/MbSurfaceMeshCurvilinear.h>
00037 #include <mesh/surfaces/MbSurfaceMeshQuadrangle.h>
00038 #include <mesh/lines/MbLineMeshUnstructured.h>
00039 #include <mesh/lines/MbLineMeshCurvilinear.h>
00040 #include <mesh/lines/MbLineMeshRegular.h>
00041 #include <MeshVizXLM/mesh/data/MiDataSet.h>
00042 #include <MeshVizXLM/mesh/geometry/MiVolumeGeometryRectilinear.h>
00043 #include <data/MbVec3SetI.h>
00044 #include <data/MbScalarSetI.h>
00045 #include <data/MbVec3SetIj.h>
00046 #include <data/MbScalarSetIj.h>
00047 #include <data/MbVec3SetIjk.h>
00048 #include <data/MbScalarSetIjk.h>
00049 #include <MbSampleMeshFunctor.h>
00050
00051 #include <Inventor/STL/string>
00052 #include <Inventor/STL/vector>
00053 #include <Inventor/STL/map>
00054
00055
00060 template < typename _Vec3T=MbVec3d, typename _ScalarT=double >
00061 class MbSampleMeshBuilder
00062 {
00063 public:
00065 MbSampleMeshBuilder();
00066
00068 virtual ~MbSampleMeshBuilder() { clear(); }
00069
00073 MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>& getMeshTetrahedron();
00074
00083 MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>& getMeshTetrahedron(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max, double rotations[3] = NULL, const MbVec3<size_t> roi[2] = NULL);
00084
00093 MbVolumeMeshHexahedron<_Vec3T,_ScalarT,_Vec3T>& getMeshHexahedron(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max, double rotations[3] = NULL, const MbVec3<size_t> roi[2] = NULL);
00094
00098 MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T>& getVolumeMeshRegular(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00099 template <MiMeshIjk::StorageLayout _LAYOUT>
00100 MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>& getVolumeMeshRegular(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00101
00105 MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>& getVolumeMeshRectilinear(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00106 template <MiMeshIjk::StorageLayout _LAYOUT>
00107 MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>& getVolumeMeshRectilinear(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00108
00112 MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>& getVolumeMeshCurvilinear(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00113 template <MiMeshIjk::StorageLayout _LAYOUT>
00114 MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T,_LAYOUT>& getVolumeMeshCurvilinear(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max);
00115
00119 MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T>& getHexahedronMeshIjk(const MbVec3<size_t>& dim,const _Vec3T& min,const _Vec3T& max,double rotations[3] = NULL);
00120
00130 template <MiMeshIjk::StorageLayout layout>
00131 MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,layout>& getHexahedronMeshIjk(const MbVec3<size_t>& dim,const _Vec3T& min,
00132 const _Vec3T& max,MbVec3<size_t> nbFaults,
00133 double rotations[3] = NULL, bool optimized = true);
00134
00144 template <MiMeshIjk::StorageLayout layout>
00145 MbVertexHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,layout>& getVertexHexahedronMeshIjk(const MbVec3<size_t>& dim,const _Vec3T& min,
00146 const _Vec3T& max,MbVec3<size_t> nbFaults,
00147 double rotations[3] = NULL, bool optimized = true);
00148
00152 MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>& getSurfaceMeshQuadrangle(size_t numCellI, size_t numCellJ,const _Vec3T& origin,const _Vec3T& stepVecI,const _Vec3T& stepVecJ);
00153 MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>& getSurfaceMeshQuadrangle(size_t numCellI, size_t numCellJ, std::vector<_Vec3T>& coords);
00154
00158 MbSurfaceMeshRegular<_ScalarT,_ScalarT,_Vec3T>& getSurfaceMeshRegular(size_t numCellI, size_t numCellJ,const _Vec3T& min,const _Vec3T& max);
00159
00163 MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>& getSurfaceMeshRectilinear(size_t numCellI, size_t numCellJ, _ScalarT minX, _ScalarT minY, _ScalarT maxX, _ScalarT maxY);
00164 MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>& getSurfaceMeshRectilinear(size_t numCellI, size_t numCellJ, std::vector<_ScalarT>& coordsX, std::vector<_ScalarT>& coordsY);
00165
00169 MbSurfaceMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>& getSurfaceMeshCurvilinear(size_t numCellI, size_t numCellJ,const _Vec3T& origin,const _Vec3T& stepVecI,const _Vec3T& stepVecJ);
00170
00174 MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>& getLineMeshUnstructured(size_t numCells, const _Vec3T& origin, const _Vec3T& max);
00175
00183 template <typename GeomFuncT>
00184 MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>& getLineMeshUnstructured(size_t numCells, const _Vec3T& origin, const _Vec3T& max, const GeomFuncT& geomFunctor);
00185
00189 MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>& getLineMeshCurvilinear(size_t numCells, const _Vec3T& origin, const _Vec3T& max);
00190
00198 template <typename GeomFuncT >
00199 MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>& getLineMeshCurvilinear(size_t numCells, const _Vec3T& origin, const _Vec3T& max, const GeomFuncT& geomFunctor);
00200
00207 MbLineMeshRegular<_Vec3T, _ScalarT, _Vec3T>& getLineMeshRegular(size_t numCells, const _Vec3T& origin, const _Vec3T& max);
00208
00212 void addScalarFctor( const MbScalarFunctor<_ScalarT>* fctor, std::string name="" );
00213
00217 void clearScalarFctors();
00218
00220
00223 void addDeadCellFctor( const MbDeadCellFctorIjk* fctor );
00224 void addDeadCellFctor( const MbDeadCellFctorIj* fctor );
00225 void addDeadCellFctor( const MbDeadCellFctorI* fctor );
00227
00231 void disableDataSets(bool disable = true);
00232
00233 private:
00234 void clear();
00235 template <typename _CoordT>
00236 void addScalarSets(MbDataSetStorageI<_ScalarT, _Vec3T>& mesh, const _CoordT& coords, size_t numPoints);
00237 void addScalarSets(MbMesh<_Vec3T, _ScalarT, _Vec3T>& mesh, size_t numPoints);
00238 template < MiMeshIjk::StorageLayout _LAYOUT >
00239 void addScalarSets(MbMeshIjk<_ScalarT,_Vec3T,_LAYOUT>& mesh, const MbVec3SetIjk<_Vec3T,_LAYOUT>& geometry);
00240 void addScalarSets(MbMeshIj<_ScalarT,_Vec3T>& mesh, const MbVec3SetIj<_Vec3T>& geometry);
00241
00242 void splitHexaIn6Tetra(size_t hexaNodes[8], std::vector<size_t>& tetraNodes) const;
00243
00244 template <MiMeshIjk::StorageLayout celllayout, MiMeshIjk::StorageLayout coordlayout>
00245 MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,celllayout>& getHexahedronMeshIjk(const MbVec3<size_t>& dim,const _Vec3T& min,
00246 const _Vec3T& max,MbVec3<size_t> nbFaults,
00247 double rotations[3] = NULL);
00248
00249 MiMesh* m_mesh;
00250 MiMeshIjk* m_vmesh;
00251 std::vector< const MbScalarFunctor<_ScalarT>* > m_scalarFctors;
00252 std::vector< std::string > m_scalarFctNames;
00253 const MbDeadCellFctorIjk* m_deadCellFctIjk;
00254 const MbDeadCellFctorIj* m_deadCellFctIj;
00255 const MbDeadCellFctorI* m_deadCellFctI;
00256 std::vector< MiDataSet* > m_scalarSets;
00257 std::vector< MiDataSet* > m_vec3Sets;
00258 bool m_disableDataSets;
00259 bool m_onlyPerCellBinding;
00260
00261 MbSphereFctor<_ScalarT> sphereFctor;
00262 MbXFctor<_ScalarT> xFctor;
00263 };
00264
00265
00266 template < typename _Vec3T, typename _ScalarT >
00267 MbSampleMeshBuilder<_Vec3T,_ScalarT>::MbSampleMeshBuilder() :
00268 m_mesh(NULL), m_vmesh(NULL), m_deadCellFctIjk(NULL), m_deadCellFctIj(NULL), m_deadCellFctI(NULL), m_disableDataSets(false), m_onlyPerCellBinding(false)
00269 {
00270 disableDataSets(m_disableDataSets);
00271 }
00272
00273
00274 template < typename _Vec3T, typename _ScalarT >
00275 void MbSampleMeshBuilder<_Vec3T,_ScalarT>::disableDataSets(bool disable)
00276 {
00277 m_disableDataSets = disable;
00278 if (disable)
00279 {
00280 clearScalarFctors();
00281 }
00282 else
00283 {
00284 m_scalarFctors.push_back(&xFctor);
00285 m_scalarFctNames.push_back("$MyScalarSet");
00286 m_scalarFctors.push_back(&sphereFctor);
00287 m_scalarFctNames.push_back("$Sphere");
00288 }
00289 }
00290
00291
00292 template < typename _Vec3T, typename _ScalarT >
00293 inline MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>&
00294 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getMeshTetrahedron()
00295 {
00296 clear();
00297 _ScalarT cellId[6];
00298 bool deadCellList[6];
00299 for(size_t i=0;i<6;i++)
00300 {
00301 cellId[i] = (_ScalarT) i;
00302 if(m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
00303 }
00304
00305 _Vec3T coords[8] = {
00306 _Vec3T(0,0,0),
00307 _Vec3T(10,0,0),
00308 _Vec3T(10,10,0),
00309 _Vec3T(0,10,0),
00310 _Vec3T(0,0,10),
00311 _Vec3T(10,0,10),
00312 _Vec3T(10,10,10),
00313 _Vec3T(0,10,10)
00314 };
00315 int indices[24] = {
00316
00317 0,4,6,5,
00318 0,6,2,1,
00319 0,1,5,6,
00320
00321 0,6,4,7,
00322 0,2,6,3,
00323 0,7,3,6
00324 };
00325
00326 MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>* mesh;
00327 mesh = new MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>(coords,coords+8, indices,indices+24);
00328 m_mesh = mesh;
00329 if(m_deadCellFctI) mesh->setDeadCells(deadCellList,deadCellList+6);
00330
00331 if (!m_disableDataSets)
00332 {
00333 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId,cellId+6);
00334 m_scalarSets.push_back(CellIdSet);
00335 CellIdSet->setName("$CellId");
00336 CellIdSet->setBinding(MiScalardSetI::PER_CELL);
00337
00338 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords,coords+8);
00339 m_vec3Sets.push_back(vecSet);
00340 vecSet->setName("$MyGeometry");
00341
00342 mesh->addScalarSet(CellIdSet);
00343 mesh->addVec3Set(vecSet);
00344 }
00345 addScalarSets(*mesh,8);
00346
00347 return *mesh;
00348 }
00349
00350
00351 template < typename _Vec3T, typename _ScalarT >
00352 inline MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>&
00353 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getMeshTetrahedron(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max, double rotations[3], const MbVec3<size_t> roi[2])
00354 {
00355 clear();
00356 _Vec3T step = (max-min).div(_Vec3T(dim));
00357
00358 size_t numCoords = (dim[0]+1)*(dim[1]+1)*(dim[2]+1);
00359 _Vec3T* coords = new _Vec3T[numCoords];
00360 MbIjkToI<> nodeAdaptor(dim[0]+1,dim[1]+1,dim[2]+1);
00361 for(size_t k=0; k<dim[2]+1; k++) {
00362 for(size_t j=0; j<dim[1]+1; j++) {
00363 for(size_t i=0; i<dim[0]+1; i++)
00364 {
00365 _Vec3T v(min[0]+step[0]*_ScalarT(i),min[1]+step[1]*_ScalarT(j),min[2]+step[2]*_ScalarT(k));
00366 coords[nodeAdaptor.getI(i,j,k)] = v;
00367 }
00368 }
00369 }
00370
00371 MbVec3<size_t> sroi(0), eroi(dim);
00372 if (roi)
00373 {
00374 sroi = roi[0];
00375 eroi = roi[1];
00376 }
00377 size_t numCells = (eroi[0]-sroi[0])*(eroi[1]-sroi[1])*(eroi[2]-sroi[2]) * 6;
00378 size_t nodes[8];
00379 std::vector<size_t> nodeIndexes;
00380 nodeIndexes.reserve(numCells*4);
00381 for(size_t i=sroi[0]; i<eroi[0]; i++)
00382 for(size_t j=sroi[1]; j<eroi[1]; j++)
00383 for(size_t k=sroi[2]; k<eroi[2]; k++)
00384 {
00385 nodes[0] = nodeAdaptor.getI(i,j,k);
00386 nodes[1] = nodeAdaptor.getI(i+1,j,k);
00387 nodes[2]= nodeAdaptor.getI(i+1,j+1,k);
00388 nodes[3]= nodeAdaptor.getI(i,j+1,k);
00389 nodes[4]= nodeAdaptor.getI(i,j,k+1);
00390 nodes[5]= nodeAdaptor.getI(i+1,j,k+1);
00391 nodes[6]= nodeAdaptor.getI(i+1,j+1,k+1);
00392 nodes[7]= nodeAdaptor.getI(i,j+1,k+1);
00393 splitHexaIn6Tetra(nodes,nodeIndexes);
00394 }
00395
00396 MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>* mesh;
00397 mesh = new MbVolumeMeshTetrahedron<_Vec3T,_ScalarT,_Vec3T>(coords,coords+numCoords,
00398 nodeIndexes.begin(),nodeIndexes.end());
00399 m_mesh = mesh;
00400
00401 _Vec3T center = (max+min)/2.0;
00402 if (rotations != NULL)
00403 for (size_t a=0; a < 3; ++a)
00404 mesh->getGeometry().rotate(rotations[a],a,¢er);
00405
00406 if(m_deadCellFctI)
00407 {
00408 bool* deadCellList = new bool[numCells];
00409 for(size_t i=0; i<numCells; i++)
00410 deadCellList[i] = (*m_deadCellFctI)(i);
00411 mesh->setDeadCells(deadCellList,deadCellList+numCells);
00412 delete deadCellList;
00413 }
00414
00415 if (!m_disableDataSets)
00416 {
00417 MbVec3SetI<_Vec3T>* vec = new MbVec3SetI<_Vec3T>(coords,coords+numCoords);
00418 m_vec3Sets.push_back(vec);
00419 vec->setName("$MyGeometry");
00420 mesh->addVec3Set(vec);
00421 _ScalarT* cellId = new _ScalarT[numCells];
00422 for(size_t i=0; i<numCells; i++)
00423 cellId[i] = (_ScalarT) i;
00424 MbScalarSetI<_ScalarT>* scalar = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
00425 m_scalarSets.push_back(scalar);
00426 scalar->setName("$CellId");
00427 scalar->setBinding(MbDataSet::PER_CELL);
00428 mesh->addScalarSet(scalar);
00429 delete cellId;
00430 }
00431 addScalarSets(*mesh,numCoords);
00432
00433 delete coords;
00434 return *mesh;
00435 }
00436
00437
00438 template < typename _Vec3T, typename _ScalarT >
00439 void
00440 MbSampleMeshBuilder<_Vec3T,_ScalarT>::splitHexaIn6Tetra(size_t hexaNodes[8], std::vector<size_t>& tetraNodes) const
00441 {
00442
00443
00444 tetraNodes.push_back(hexaNodes[0]);
00445 tetraNodes.push_back(hexaNodes[4]);
00446 tetraNodes.push_back(hexaNodes[6]);
00447 tetraNodes.push_back(hexaNodes[5]);
00448
00449 tetraNodes.push_back(hexaNodes[0]);
00450 tetraNodes.push_back(hexaNodes[6]);
00451 tetraNodes.push_back(hexaNodes[2]);
00452 tetraNodes.push_back(hexaNodes[1]);
00453
00454 tetraNodes.push_back(hexaNodes[0]);
00455 tetraNodes.push_back(hexaNodes[1]);
00456 tetraNodes.push_back(hexaNodes[5]);
00457 tetraNodes.push_back(hexaNodes[6]);
00458
00459
00460 tetraNodes.push_back(hexaNodes[0]);
00461 tetraNodes.push_back(hexaNodes[6]);
00462 tetraNodes.push_back(hexaNodes[4]);
00463 tetraNodes.push_back(hexaNodes[7]);
00464
00465 tetraNodes.push_back(hexaNodes[0]);
00466 tetraNodes.push_back(hexaNodes[2]);
00467 tetraNodes.push_back(hexaNodes[6]);
00468 tetraNodes.push_back(hexaNodes[3]);
00469
00470 tetraNodes.push_back(hexaNodes[0]);
00471 tetraNodes.push_back(hexaNodes[7]);
00472 tetraNodes.push_back(hexaNodes[3]);
00473 tetraNodes.push_back(hexaNodes[6]);
00474 }
00475
00476
00477 template < typename _Vec3T, typename _ScalarT >
00478 inline MbVolumeMeshHexahedron<_Vec3T,_ScalarT,_Vec3T>&
00479 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getMeshHexahedron(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max, double rotations[3], const MbVec3<size_t> roi[2])
00480 {
00481 clear();
00482 _Vec3T step = (max-min).div(_Vec3T(dim));
00483
00484 size_t numCoords = (dim[0]+1)*(dim[1]+1)*(dim[2]+1);
00485 _Vec3T* coords = new _Vec3T[numCoords];
00486 MbIjkToI<> nodeAdaptor(dim[0]+1,dim[1]+1,dim[2]+1);
00487 for(size_t k=0; k<dim[2]+1; k++)
00488 for(size_t j=0; j<dim[1]+1; j++)
00489 for(size_t i=0; i<dim[0]+1; i++)
00490 {
00491 _Vec3T v(min[0]+step[0]*_ScalarT(i),min[1]+step[1]*_ScalarT(j),min[2]+step[2]*_ScalarT(k));
00492 coords[nodeAdaptor.getI(i,j,k)] = v;
00493 }
00494
00495 MbVec3<size_t> sroi(0), eroi(dim);
00496 if (roi)
00497 {
00498 sroi = roi[0];
00499 eroi = roi[1];
00500 }
00501
00502 size_t numCells = (eroi[0]-sroi[0])*(eroi[1]-sroi[1])*(eroi[2]-sroi[2]);
00503 size_t nodes[8];
00504 std::vector<size_t> nodeIndexes;
00505 nodeIndexes.reserve(numCells*8);
00506 for(size_t k=sroi[2]; k<eroi[2]; k++)
00507 for(size_t j=sroi[1]; j<eroi[1]; j++)
00508 for(size_t i=sroi[0]; i<eroi[0]; i++) {
00509 nodes[0] = nodeAdaptor.getI(i,j,k);
00510 nodes[1] = nodeAdaptor.getI(i+1,j,k);
00511 nodes[2]= nodeAdaptor.getI(i+1,j+1,k);
00512 nodes[3]= nodeAdaptor.getI(i,j+1,k);
00513 nodes[4]= nodeAdaptor.getI(i,j,k+1);
00514 nodes[5]= nodeAdaptor.getI(i+1,j,k+1);
00515 nodes[6]= nodeAdaptor.getI(i+1,j+1,k+1);
00516 nodes[7]= nodeAdaptor.getI(i,j+1,k+1);
00517 nodeIndexes.insert(nodeIndexes.end(),nodes,nodes+8);
00518 }
00519
00520 MbVolumeMeshHexahedron<_Vec3T,_ScalarT,_Vec3T>* mesh;
00521 mesh = new MbVolumeMeshHexahedron<_Vec3T,_ScalarT,_Vec3T>(coords,coords+numCoords,
00522 nodeIndexes.begin(),nodeIndexes.end());
00523 m_mesh = mesh;
00524
00525 _Vec3T center = (max+min)/2.0;
00526 if (rotations != NULL)
00527 for (size_t a=0; a < 3; ++a)
00528 mesh->getGeometry().rotate(rotations[a],a,¢er);
00529
00530 if(m_deadCellFctI)
00531 {
00532 bool* deadCellList = new bool[numCells];
00533 for(size_t i=0; i<numCells; i++)
00534 deadCellList[i] = (*m_deadCellFctI)(i);
00535 mesh->setDeadCells(deadCellList,deadCellList+numCells);
00536 delete deadCellList;
00537 }
00538
00539 if (!m_disableDataSets)
00540 {
00541 MbVec3SetI<_Vec3T>* vec = new MbVec3SetI<_Vec3T>(coords,coords+numCoords);
00542 m_vec3Sets.push_back(vec);
00543 vec->setName("$MyGeometry");
00544 mesh->addVec3Set(vec);
00545 _ScalarT* cellId = new _ScalarT[numCells];
00546 for(size_t i=0; i<numCells; i++)
00547 cellId[i] = (_ScalarT) i;
00548 MbScalarSetI<_ScalarT>* scalar = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
00549 m_scalarSets.push_back(scalar);
00550 scalar->setName("$CellId");
00551 scalar->setBinding(MbDataSet::PER_CELL);
00552 mesh->addScalarSet(scalar);
00553 delete cellId;
00554 }
00555 addScalarSets(*mesh,numCoords);
00556
00557 delete coords;
00558 return *mesh;
00559 }
00560
00561
00562 template < typename _Vec3T, typename _ScalarT >
00563 inline MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T>&
00564 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshRegular(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00565 {
00566 return this->getVolumeMeshRegular<MiMeshIjk::LAYOUT_KJI>(dim,min,max);
00567 }
00568
00569
00570 template < typename _Vec3T, typename _ScalarT >
00571 template <MiMeshIjk::StorageLayout _LAYOUT>
00572 inline MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>&
00573 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshRegular(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00574 {
00575 clear();
00576
00577 MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>* mesh;
00578 mesh = new MbVolumeMeshRegular<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>(dim[0],dim[1],dim[2],min[0],min[1],min[2],max[0],max[1],max[2]);
00579 m_mesh = mesh;
00580
00581 _Vec3T step = (max-min).div(_Vec3T(dim));
00582
00583 MbVec3SetIjk<_Vec3T,_LAYOUT>* vecs = new MbVec3SetIjk<_Vec3T,_LAYOUT>(dim[0]+1,dim[1]+1,dim[2]+1);
00584 m_vec3Sets.push_back(vecs);
00585 for(size_t i=0; i<dim[0]+1; i++)
00586 for(size_t j=0; j<dim[1]+1; j++)
00587 for(size_t k=0; k<dim[2]+1; k++) {
00588 vecs->set(i,j,k,_Vec3T(min[0]+step[0]*_ScalarT(i), min[1]+step[1]*_ScalarT(j), min[2]+step[2]*_ScalarT(k)));
00589 }
00590 vecs->setName("$MyGeometry");
00591 mesh->addVec3SetIjk(vecs);
00592
00593 MbScalarSetIjk<_ScalarT,_LAYOUT>* scalar2 = new MbScalarSetIjk<_ScalarT,_LAYOUT>(dim[0],dim[1],dim[2]);
00594 m_scalarSets.push_back(scalar2);
00595 size_t n=0;
00596 for(size_t k=0; k<dim[2]; k++)
00597 for(size_t j=0; j<dim[1]; j++)
00598 for(size_t i=0; i<dim[0]; i++) {
00599 scalar2->set(i,j,k,_ScalarT(n++));
00600 if(m_deadCellFctIjk) mesh->setDeadCell(i,j,k,(*m_deadCellFctIjk)(i,j,k));
00601 }
00602 scalar2->setName("$CellId");
00603 scalar2->setBinding(MbDataSet::PER_CELL);
00604 mesh->addScalarSetIjk(scalar2);
00605
00606 addScalarSets(*mesh,*vecs);
00607
00608 return *mesh;
00609 }
00610
00611
00612 template < typename _Vec3T, typename _ScalarT >
00613 inline MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>&
00614 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshRectilinear(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00615 {
00616 return this->getVolumeMeshRectilinear<MiMeshIjk::LAYOUT_KJI>(dim,min,max);
00617 }
00618
00619
00620 template < typename _Vec3T, typename _ScalarT >
00621 template <MiMeshIjk::StorageLayout _LAYOUT>
00622 inline MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>&
00623 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshRectilinear(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00624 {
00625 clear();
00626 std::vector<_ScalarT>x;
00627 x.reserve(dim[0]);
00628 _ScalarT dx = abs(max[0] - min[0])/(dim[0]);
00629 _ScalarT v = min[0];
00630 for (size_t i=0; i<dim[0]+1; i++)
00631 {
00632 x.push_back(v);
00633 v+=dx;
00634 }
00635 std::vector<_ScalarT>y;
00636 y.reserve(dim[1]);
00637 _ScalarT dy = abs(max[1] - min[1])/(dim[1]);
00638 v = min[1];
00639 for (size_t i=0; i<dim[1]+1; i++)
00640 {
00641 y.push_back(v);
00642 v+=dy;
00643 }
00644 std::vector<_ScalarT>z;
00645 z.reserve(dim[2]);
00646 _ScalarT dz = abs(max[2] - min[2])/(dim[2]);
00647 v = min[2];
00648 for (size_t i=0; i<dim[2]+1; i++)
00649 {
00650 z.push_back(v);
00651 v+=dz;
00652 }
00653
00654
00655 MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>* mesh;
00656 mesh = new MbVolumeMeshRectilinear<_ScalarT,_ScalarT,_Vec3T,_LAYOUT>(dim[0],dim[1],dim[2],x.begin(),x.end(),y.begin(),y.end(),z.begin(),z.end());
00657 m_mesh = mesh;
00658
00659 const MiVolumeGeometryRectilinear& geometry = mesh->getGeometry();
00660 MbVec3SetIjk<_Vec3T,_LAYOUT>* vecs = new MbVec3SetIjk<_Vec3T,_LAYOUT>(dim[0]+1,dim[1]+1,dim[2]+1);
00661 m_vec3Sets.push_back(vecs);
00662 for(size_t i=0; i<dim[0]+1; i++)
00663 for(size_t j=0; j<dim[1]+1; j++)
00664 for(size_t k=0; k<dim[2]+1; k++) {
00665 vecs->set(i,j,k,_Vec3T((_ScalarT)geometry.getX(i),(_ScalarT)geometry.getY(j),(_ScalarT)geometry.getZ(k)));
00666 }
00667 vecs->setName("$MyGeometry");
00668 mesh->addVec3SetIjk(vecs);
00669
00670
00671 MbScalarSetIjk<_ScalarT,_LAYOUT>* scalar2 = new MbScalarSetIjk<_ScalarT,_LAYOUT>(dim[0],dim[1],dim[2]);
00672 m_scalarSets.push_back(scalar2);
00673 size_t n=0;
00674 for(size_t k=0; k<dim[2]; k++)
00675 for(size_t j=0; j<dim[1]; j++)
00676 for(size_t i=0; i<dim[0]; i++) {
00677 scalar2->set(i,j,k,_ScalarT(n++));
00678 if(m_deadCellFctIjk) mesh->setDeadCell(i,j,k,(*m_deadCellFctIjk)(i,j,k));
00679 }
00680 scalar2->setName("$CellId");
00681 scalar2->setBinding(MbDataSet::PER_CELL);
00682 mesh->addScalarSetIjk(scalar2);
00683
00684 addScalarSets(*mesh,*vecs);
00685
00686 return *mesh;
00687 }
00688
00689
00690 template < typename _Vec3T, typename _ScalarT >
00691 inline MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>&
00692 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshCurvilinear(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00693 {
00694 return getVolumeMeshCurvilinear<MiMeshIjk::LAYOUT_KJI>(dim,min,max);
00695 }
00696
00697
00698 template < typename _Vec3T, typename _ScalarT >
00699 template <MiMeshIjk::StorageLayout _LAYOUT>
00700 inline MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T,_LAYOUT>&
00701 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVolumeMeshCurvilinear(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max)
00702 {
00703 clear();
00705 MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T,_LAYOUT>* mesh;
00706 mesh = new MbVolumeMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T,_LAYOUT>(dim[0],dim[1],dim[2]);
00707 m_mesh = mesh;
00708 const MiGeometryIjk& geometry = mesh->getGeometry();
00709
00710 _Vec3T step = (max-min).div(_Vec3T(dim));
00711
00712 for(size_t i=0; i<dim[0]+1; i++)
00713 for(size_t j=0; j<dim[1]+1; j++)
00714 for(size_t k=0; k<dim[2]+1; k++)
00715 mesh->setCoord(i,j,k,_Vec3T(min[0]+step[0]*_ScalarT(i), min[1]+step[1]*_ScalarT(j), min[2]+step[2]*_ScalarT(k)));
00716
00717 for(size_t k=0; k<dim[2]; k++)
00718 for(size_t j=0; j<dim[1]; j++)
00719 for(size_t i=0; i<dim[0]; i++)
00720 if(m_deadCellFctIjk) mesh->setDeadCell(i,j,k,(*m_deadCellFctIjk)(i,j,k));
00721
00722 if (!m_disableDataSets || m_scalarFctors.size() > 0)
00723 {
00724 MbVec3SetIjk<_Vec3T,_LAYOUT>* vecs = new MbVec3SetIjk<_Vec3T,_LAYOUT>(dim[0]+1,dim[1]+1,dim[2]+1);
00725 m_vec3Sets.push_back(vecs);
00726 for(size_t i=0; i<dim[0]+1; i++)
00727 for(size_t j=0; j<dim[1]+1; j++)
00728 for(size_t k=0; k<dim[2]+1; k++)
00729 vecs->set(i,j,k,_Vec3T(geometry.getCoord(i,j,k)));
00730
00731 vecs->setName("$MyGeometry");
00732
00733 if (!m_disableDataSets)
00734 {
00735 mesh->addVec3SetIjk(vecs);
00736
00737
00738 MbScalarSetIjk<_ScalarT,_LAYOUT>* scalar2 = new MbScalarSetIjk<_ScalarT,_LAYOUT>(dim[0],dim[1],dim[2]);
00739 m_scalarSets.push_back(scalar2);
00740 size_t n=0;
00741 for(size_t k=0; k<dim[2]; k++)
00742 for(size_t j=0; j<dim[1]; j++)
00743 for(size_t i=0; i<dim[0]; i++)
00744 scalar2->set(i,j,k,_ScalarT(n++));
00745
00746 scalar2->setName("$CellId");
00747 scalar2->setBinding(MbDataSet::PER_CELL);
00748 mesh->addScalarSetIjk(scalar2);
00749 }
00750
00751 addScalarSets(*mesh,*vecs);
00752 }
00753
00754 return *mesh;
00755 }
00756
00757
00758 template < typename _Vec3T, typename _ScalarT >
00759 inline MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T>&
00760 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getHexahedronMeshIjk(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max, double rotations[3])
00761 {
00762 MbVec3<size_t> nbFaults(0);
00763 return this->getHexahedronMeshIjk<MiMeshIjk::LAYOUT_KJI>(dim,min,max,nbFaults,rotations);
00764 }
00765
00766
00767 template < typename _Vec3T, typename _ScalarT >
00768 template <MiMeshIjk::StorageLayout LAYOUT>
00769 inline MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,LAYOUT>&
00770 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getHexahedronMeshIjk(const MbVec3<size_t>& dim, const _Vec3T& min,
00771 const _Vec3T& max, MbVec3<size_t> nbFaults,
00772 double rotations[3], bool optimized)
00773 {
00774 if (optimized)
00775 return getHexahedronMeshIjk<LAYOUT,LAYOUT>(dim,min,max,nbFaults,rotations);
00776 else
00777 return getHexahedronMeshIjk<LAYOUT,MiMeshIjk::LAYOUT_KJI>(dim,min,max,nbFaults,rotations);
00778 }
00779
00780
00781 template < typename _Vec3T, typename _ScalarT >
00782 template <MiMeshIjk::StorageLayout CELLLAYOUT,MiMeshIjk::StorageLayout COORDLAYOUT>
00783 inline MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,CELLLAYOUT>&
00784 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getHexahedronMeshIjk(const MbVec3<size_t>& dim, const _Vec3T& min, const _Vec3T& max, MbVec3<size_t> nbFaults, double rotations[3])
00785 {
00786 clear();
00787 _Vec3T bbox = max-min;
00788 _Vec3T step = bbox.div(_Vec3T(dim));
00789
00790 MbVec3<size_t> num = dim+1;
00791 MbVec3<size_t> faultSteps = num.div(nbFaults+1)+1;
00792 _Vec3T faultShifts = 0.5 * step;
00793
00794 std::map<size_t,size_t> faultCoords;
00795 MbIjkToI<COORDLAYOUT> nodeAdaptor(num[0],num[1],num[2]);
00796
00797 size_t numCoords = num[0]*num[1]*num[2];
00798 std::vector<_Vec3T> coords(numCoords);
00799 _Vec3T v, fv;
00800 size_t id = 0;
00801 bool hasFault = false;
00802 for(size_t k=0; k<num[2]; ++k)
00803 for(size_t j=0; j<num[1]; ++j)
00804 for(size_t i=0; i<num[0]; ++i) {
00805 id = nodeAdaptor.getI(i,j,k);
00806 v.setValue(min[0]+step[0]*_ScalarT(i),min[1]+step[1]*_ScalarT(j),min[2]+step[2]*_ScalarT(k));
00807 coords[id] = v;
00808 fv = v;
00809 if ((i > 0 && i%faultSteps[0]==0) || (j > 0 && j%faultSteps[1]==0))
00810 {
00811 fv[2] += faultShifts[2];
00812 hasFault = true;
00813 }
00814 if ((k > 0 && k%faultSteps[2]==0) )
00815 {
00816 fv[0] += faultShifts[0];
00817 hasFault = true;
00818 }
00819 if( hasFault)
00820 {
00821 faultCoords[id] = coords.size();
00822 coords.push_back(fv);
00823 hasFault = false;
00824 }
00825 }
00826
00827 MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,CELLLAYOUT>* mesh;
00828 mesh = new MbHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,CELLLAYOUT>(dim[0],dim[1],dim[2],
00829 coords.begin(),coords.end());
00830 m_mesh = mesh;
00831
00832 _Vec3T center = (max+min)/2.0;
00833 if (rotations != NULL)
00834 for (size_t a=0; a < 3; ++a)
00835 mesh->getGeometry().rotate(rotations[a],a,¢er);
00836
00837 bool fi, fj, fk;
00838 size_t nodes[8];
00839 for(size_t k=0; k<dim[2]; k++)
00840 for(size_t j=0; j<dim[1]; j++)
00841 for(size_t i=0; i<dim[0]; i++) {
00842 fi = (i>0 && i%faultSteps[0]==0);
00843 fj = (j>0 && j%faultSteps[1]==0);
00844 fk = (k>0 && k%faultSteps[2]==0);
00845 nodes[0] = nodeAdaptor.getI(i,j,k);
00846 if (fi || fj || fk) nodes[0] = faultCoords.find(nodes[0])->second;
00847 nodes[1] = nodeAdaptor.getI(i+1,j,k);
00848 if (fj || fk) nodes[1] = faultCoords.find(nodes[1])->second;
00849 nodes[2]= nodeAdaptor.getI(i+1,j+1,k);
00850 if (fk) nodes[2] = faultCoords.find(nodes[2])->second;
00851 nodes[3]= nodeAdaptor.getI(i,j+1,k);
00852 if (fi || fk) nodes[3] = faultCoords.find(nodes[3])->second;
00853 nodes[4]= nodeAdaptor.getI(i,j,k+1);
00854 if (fi || fj) nodes[4] = faultCoords.find(nodes[4])->second;
00855 nodes[5]= nodeAdaptor.getI(i+1,j,k+1);
00856 if (fj) nodes[5] = faultCoords.find(nodes[5])->second;
00857 nodes[6]= nodeAdaptor.getI(i+1,j+1,k+1);
00858 nodes[7]= nodeAdaptor.getI(i,j+1,k+1);
00859 if (fi) nodes[7] = faultCoords.find(nodes[7])->second;
00860 mesh->setCellNodeIndices(i,j,k,nodes,nodes+8);
00861 }
00862
00863 faultCoords.clear();
00864
00865 if (!m_disableDataSets || m_scalarFctors.size() > 0)
00866 {
00867 if (m_onlyPerCellBinding)
00868 {
00869 size_t n,dummy;
00870 const MiHexahedronTopologyExplicitIjk& topo = mesh->getTopology();
00871 MbVec3SetIjk<_Vec3T,CELLLAYOUT>* vec = new MbVec3SetIjk<_Vec3T,CELLLAYOUT>(dim[0],dim[1],dim[2],"$MyGeometry",MbDataSet::PER_CELL);
00872 for(size_t k=0; k<dim[2]; k++)
00873 for(size_t j=0; j<dim[1]; j++)
00874 for(size_t i=0; i<dim[0]; i++)
00875 {
00876 topo.getCellNodeIndices(i,j,k,n,dummy,dummy,dummy,dummy,dummy,dummy,dummy);
00877 vec->set(i,j,k,coords[n]);
00878 }
00879 if (!m_disableDataSets)
00880 mesh->addVec3SetIjk(vec);
00881 addScalarSets(*mesh,*vec);
00882 }
00883 else
00884 {
00885 MbVec3SetI<_Vec3T>* vec = new MbVec3SetI<_Vec3T>(coords.begin(),coords.end(),"$MyGeometry",MbDataSet::PER_NODE);
00886 m_vec3Sets.push_back(vec);
00887 if (!m_disableDataSets)
00888 mesh->addVec3Set(vec);
00889 addScalarSets(*mesh,coords.size());
00890 }
00891
00892 if (!m_disableDataSets)
00893 {
00894 MbIjkToI<COORDLAYOUT> cellAdaptor(dim[0],dim[1],dim[2]);
00895 MbScalarSetIjk<_ScalarT,CELLLAYOUT>* scalar = new MbScalarSetIjk<_ScalarT,CELLLAYOUT>(dim[0],dim[1],dim[2],"$CellId",MbDataSet::PER_CELL);
00896 m_scalarSets.push_back(scalar);
00897 for(size_t k=0; k<dim[2]; k++)
00898 for(size_t j=0; j<dim[1]; j++)
00899 for(size_t i=0; i<dim[0]; i++)
00900 scalar->set(i,j,k,_ScalarT(cellAdaptor.getI(i,j,k)));
00901 mesh->addScalarSetIjk(scalar);
00902 }
00903 }
00904
00905 if (m_deadCellFctIjk)
00906 for(size_t k=0; k<dim[2]; k++)
00907 for(size_t j=0; j<dim[1]; j++)
00908 for(size_t i=0; i<dim[0]; i++)
00909 mesh->setDeadCell(i,j,k,(*m_deadCellFctIjk)(i,j,k));
00910
00911 return *mesh;
00912 }
00913
00914
00915 template < typename _Vec3T, typename _ScalarT >
00916 template <MiMeshIjk::StorageLayout LAYOUT>
00917 inline MbVertexHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,LAYOUT>&
00918 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getVertexHexahedronMeshIjk(const MbVec3<size_t>& dim, const _Vec3T& min,
00919 const _Vec3T& max, MbVec3<size_t> nbFaults,
00920 double rotations[3], bool optimized)
00921 {
00922 m_onlyPerCellBinding = true;
00923 MbVertexHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,LAYOUT>* mesh = new MbVertexHexahedronMeshIjk<_Vec3T,_ScalarT,_Vec3T,LAYOUT>(this->getHexahedronMeshIjk<LAYOUT>(dim,min,max,nbFaults,rotations,optimized));
00924 m_vmesh = mesh;
00925 m_onlyPerCellBinding = false;
00926 return *mesh;
00927 }
00928
00929
00930 template < typename _Vec3T, typename _ScalarT >
00931 inline MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>&
00932 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshQuadrangle(size_t numCellI, size_t numCellJ, const _Vec3T& origin, const _Vec3T& stepVecI, const _Vec3T& stepVecJ)
00933 {
00934 clear();
00935 size_t numCells = numCellI*numCellJ;
00936 size_t numN = (numCellI+1)*(numCellJ+1);
00937
00938 _ScalarT* cellId = new _ScalarT[numCells];
00939 bool* deadCellList = new bool[numCells];
00940 for(size_t i=0;i<numCells;i++){
00941 cellId[i] = (_ScalarT) i;
00942 if(m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
00943 }
00944
00945 _Vec3T* coords = new _Vec3T[numN];
00946 for(size_t n=0;n<numN;n++){
00947 size_t i = n%(numCellI+1);
00948 size_t j = n/(numCellI+1);
00949 coords[n] = origin + (_ScalarT)i*stepVecI + (_ScalarT)j*stepVecJ;
00950 }
00951
00952 size_t* indices = new size_t[numCells*4];
00953 size_t id=0;
00954 for(size_t c=0;c<numCells;c++){
00955
00956 size_t i,j,tmp;
00957 i = c % numCellI;
00958 j = c / numCellI;
00959 tmp=j*(numCellI+1) + i;
00960 indices[id++] = tmp;
00961 indices[id++] = tmp +1;
00962 indices[id++] = tmp + numCellI + 2;
00963 indices[id++] = tmp + numCellI + 1;
00964 }
00965
00966 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
00967 m_scalarSets.push_back(CellIdSet);
00968 CellIdSet->setName("$CellId");
00969 CellIdSet->setBinding(MiDataSetI<double>::PER_CELL);
00970 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords,coords+numN);
00971 m_vec3Sets.push_back(vecSet);
00972 vecSet->setName("$MyGeometry");
00973
00974 MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>* mesh;
00975 mesh = new MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>(coords,coords+numN, indices,indices+(numCells*4));
00976 m_mesh = mesh;
00977 if(m_deadCellFctI) mesh->setDeadCells(deadCellList,deadCellList+numCells);
00978 mesh->addScalarSet(CellIdSet);
00979 mesh->addVec3Set(vecSet);
00980
00981 addScalarSets(*mesh,numN);
00982
00983 delete indices;
00984 delete coords;
00985 delete cellId;
00986 delete deadCellList;
00987
00988 return *mesh;
00989 }
00990
00991
00992 template < typename _Vec3T, typename _ScalarT >
00993 inline MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>&
00994 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshQuadrangle(size_t numCellI, size_t numCellJ, std::vector<_Vec3T>& coords)
00995 {
00996 clear();
00997 size_t numCells = numCellI*numCellJ;
00998 size_t numN = (numCellI+1)*(numCellJ+1);
00999
01000 _ScalarT* cellId = new _ScalarT[numCells];
01001 bool* deadCellList = new bool[numCells];
01002 for(size_t i=0;i<numCells;i++){
01003 cellId[i] = (_ScalarT) i;
01004 if(m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
01005 }
01006
01007 size_t* indices = new size_t[numCells*4];
01008 size_t id=0;
01009 for(size_t c=0;c<numCells;c++){
01010
01011 size_t i,j,tmp;
01012 i = c % numCellI;
01013 j = c / numCellI;
01014 tmp=j*(numCellI+1) + i;
01015 indices[id++] = tmp;
01016 indices[id++] = tmp +1;
01017 indices[id++] = tmp + numCellI + 2;
01018 indices[id++] = tmp + numCellI + 1;
01019 }
01020
01021 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
01022 m_scalarSets.push_back(CellIdSet);
01023 CellIdSet->setName("$CellId");
01024 CellIdSet->setBinding(MiDataSetI<double>::PER_CELL);
01025 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords.begin(),coords.end());
01026 m_vec3Sets.push_back(vecSet);
01027 vecSet->setName("$MyGeometry");
01028
01029 MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>* mesh;
01030 mesh = new MbSurfaceMeshQuadrangle<_Vec3T,_ScalarT,_Vec3T>(coords.begin(),coords.end(), indices,indices+(numCells*4));
01031 m_mesh = mesh;
01032 if(m_deadCellFctI) mesh->setDeadCells(deadCellList,deadCellList+numCells);
01033 mesh->addScalarSet(CellIdSet);
01034 mesh->addVec3Set(vecSet);
01035
01036 addScalarSets(*mesh,numN);
01037
01038 delete indices;
01039 delete cellId;
01040 delete deadCellList;
01041
01042 return *mesh;
01043 }
01044
01045
01046
01047 template < typename _Vec3T, typename _ScalarT >
01048 inline MbSurfaceMeshRegular<_ScalarT,_ScalarT,_Vec3T>&
01049 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshRegular(size_t numCellI, size_t numCellJ, const _Vec3T& min, const _Vec3T& max)
01050 {
01051 clear();
01052
01053 MbSurfaceMeshRegular<_ScalarT,_ScalarT,_Vec3T>* mesh;
01054 mesh = new MbSurfaceMeshRegular<_ScalarT,_ScalarT,_Vec3T>(numCellI,numCellJ,min[0],min[1],min[2],max[0],max[1],max[2]);
01055 m_mesh = mesh;
01056
01057 _Vec3T boundingBox = max - min;
01058 int uselessDimension = 0;
01059 for(int n=0; n<3; ++n)
01060
01061 if(boundingBox[uselessDimension] > boundingBox[n]) uselessDimension = n;
01062
01063 _Vec3T unitVectors[2];
01064 int d=0;
01065 for(int i=0; i<3; ++i)
01066 if(i!=uselessDimension)
01067 unitVectors[d++][i] = 1.0;
01068 _Vec3T stepVectorI = boundingBox.mult(unitVectors[0]/(_ScalarT)numCellI);
01069 _Vec3T stepVectorJ = boundingBox.mult(unitVectors[1]/(_ScalarT)numCellJ);
01070
01071 size_t numNodesI = numCellI == 0 ? 0 : numCellI + 1;
01072 size_t numNodesJ = numCellJ == 0 ? 0 : numCellJ + 1;
01073 MbVec3SetIj<_Vec3T>* vecs = new MbVec3SetIj<_Vec3T>(numNodesI, numNodesJ);
01074 m_vec3Sets.push_back(vecs);
01075 for (size_t i = 0; i<numNodesI; i++)
01076 for (size_t j = 0; j<numNodesJ; j++)
01077 vecs->set(i,j,min + (_ScalarT)i*stepVectorI + (_ScalarT)j*stepVectorJ);
01078 vecs->setName("$MyGeometry");
01079 mesh->addVec3Set(vecs);
01080
01081
01082 MbScalarSetIj<_ScalarT>* scalar2 = new MbScalarSetIj<_ScalarT>(numCellI,numCellJ);
01083 m_scalarSets.push_back(scalar2);
01084 size_t n=0;
01085 for(size_t j=0; j<numCellJ; j++)
01086 for(size_t i=0; i<numCellI; i++){
01087 scalar2->set(i,j,_ScalarT(n++));
01088 if(m_deadCellFctIj) mesh->setDeadCell(i,j,(*m_deadCellFctIj)(i,j));
01089 }
01090 scalar2->setName("$CellId");
01091 scalar2->setBinding(MbDataSet::PER_CELL);
01092 mesh->addScalarSet(scalar2);
01093
01094 addScalarSets(*mesh,*vecs);
01095
01096 return *mesh;
01097 }
01098
01099
01100 template < typename _Vec3T, typename _ScalarT >
01101 inline MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>&
01102 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshRectilinear(size_t numCellI, size_t numCellJ, _ScalarT minX, _ScalarT minY, _ScalarT maxX, _ScalarT maxY)
01103 {
01104 clear();
01105 std::vector<_ScalarT>x;
01106 x.reserve(numCellI);
01107 _ScalarT dx = std::abs(maxX - minX)/numCellI;
01108 _ScalarT v = minX;
01109 size_t numNodesI = numCellI == 0 ? 0 : numCellI + 1;
01110 for (size_t i = 0; i<numNodesI; i++)
01111 {
01112 x.push_back(v);
01113 v+=dx;
01114 }
01115 std::vector<_ScalarT>y;
01116 y.reserve(numCellJ);
01117 _ScalarT dy = std::abs(maxY - minY)/numCellJ;
01118 v = minY;
01119 size_t numNodesJ = numCellJ == 0 ? 0 : numCellJ + 1;
01120 for (size_t i = 0; i<numNodesJ; i++)
01121 {
01122 y.push_back(v);
01123 v+=dy;
01124 }
01125
01126
01127 MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>* mesh;
01128 mesh = new MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>(x.begin(),x.end(),y.begin(),y.end());
01129 m_mesh = mesh;
01130
01131 const MiSurfaceGeometryRectilinear& geometry = mesh->getGeometry();
01132 MbVec3SetIj<_Vec3T>* vecs = new MbVec3SetIj<_Vec3T>(numNodesI, numNodesJ);
01133 m_vec3Sets.push_back(vecs);
01134 for (size_t i = 0; i<numNodesI; i++)
01135 for (size_t j = 0; j<numNodesJ; j++)
01136 vecs->set(i,j,_Vec3T((_ScalarT)geometry.getX(i),(_ScalarT)geometry.getY(j),0));
01137 vecs->setName("$MyGeometry");
01138 mesh->addVec3Set(vecs);
01139
01140
01141 MbScalarSetIj<_ScalarT>* scalar2 = new MbScalarSetIj<_ScalarT>(numCellI,numCellJ);
01142 m_scalarSets.push_back(scalar2);
01143 size_t n=0;
01144 for(size_t j=0; j<numCellJ; j++)
01145 for(size_t i=0; i<numCellI; i++){
01146 scalar2->set(i,j,_ScalarT(n++));
01147 if(m_deadCellFctIj) mesh->setDeadCell(i,j,(*m_deadCellFctIj)(i,j));
01148 }
01149 scalar2->setName("$CellId");
01150 scalar2->setBinding(MbDataSet::PER_CELL);
01151 mesh->addScalarSet(scalar2);
01152
01153 addScalarSets(*mesh,*vecs);
01154
01155 return *mesh;
01156 }
01157
01158
01159 template < typename _Vec3T, typename _ScalarT >
01160 inline MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>&
01161 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshRectilinear(size_t numCellI, size_t numCellJ, std::vector<_ScalarT>& coordsX, std::vector<_ScalarT>& coordsY)
01162 {
01163 clear();
01164
01165
01166 MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>* mesh;
01167 mesh = new MbSurfaceMeshRectilinear<_ScalarT,_ScalarT,_Vec3T>(coordsX.begin(),coordsX.end(),coordsY.begin(),coordsY.end());
01168 m_mesh = mesh;
01169
01170 const MiSurfaceGeometryRectilinear& geometry = mesh->getGeometry();
01171 MbVec3SetIj<_Vec3T>* vecs = new MbVec3SetIj<_Vec3T>(numCellI+1,numCellJ+1);
01172 m_vec3Sets.push_back(vecs);
01173 for(size_t i=0; i<numCellI+1; i++)
01174 for(size_t j=0; j<numCellJ+1; j++)
01175 vecs->set(i,j,_Vec3T((_ScalarT)geometry.getX(i),(_ScalarT)geometry.getY(j),0));
01176 vecs->setName("$MyGeometry");
01177 mesh->addVec3Set(vecs);
01178
01179
01180 MbScalarSetIj<_ScalarT>* scalar2 = new MbScalarSetIj<_ScalarT>(numCellI,numCellJ);
01181 m_scalarSets.push_back(scalar2);
01182 size_t n=0;
01183 for(size_t j=0; j<numCellJ; j++)
01184 for(size_t i=0; i<numCellI; i++){
01185 scalar2->set(i,j,_ScalarT(n++));
01186 if(m_deadCellFctIj) mesh->setDeadCell(i,j,(*m_deadCellFctIj)(i,j));
01187 }
01188 scalar2->setName("$CellId");
01189 scalar2->setBinding(MbDataSet::PER_CELL);
01190 mesh->addScalarSet(scalar2);
01191
01192 addScalarSets(*mesh,*vecs);
01193
01194 return *mesh;
01195 }
01196
01197
01198 template < typename _Vec3T, typename _ScalarT >
01199 inline MbSurfaceMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>&
01200 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getSurfaceMeshCurvilinear(size_t numCellI, size_t numCellJ, const _Vec3T& origin, const _Vec3T& stepVecI, const _Vec3T& stepVecJ)
01201 {
01202 clear();
01203
01204 MbSurfaceMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>* mesh;
01205 mesh = new MbSurfaceMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>(numCellI,numCellJ);
01206 m_mesh = mesh;
01207 size_t numNodesI, numNodesJ;
01208 mesh->getGeometry().getSize(numNodesI,numNodesJ);
01209 for (size_t i = 0; i<numNodesI; i++)
01210 for (size_t j = 0; j<numNodesJ; j++)
01211 mesh->setCoord(i,j,origin + (_ScalarT)i*stepVecI + (_ScalarT)j*stepVecJ);
01212
01213 const MiGeometryIj& geometry = mesh->getGeometry();
01214 MbVec3SetIj<_Vec3T>* vecs = new MbVec3SetIj<_Vec3T>(numNodesI, numNodesJ);
01215 m_vec3Sets.push_back(vecs);
01216 for (size_t i = 0; i<numNodesI; i++)
01217 for (size_t j = 0; j<numNodesJ; j++)
01218 vecs->set(i,j,(_Vec3T) geometry.getCoord(i,j));
01219 vecs->setName("$MyGeometry");
01220 mesh->addVec3Set(vecs);
01221
01222
01223 MbScalarSetIj<_ScalarT>* scalar2 = new MbScalarSetIj<_ScalarT>(numCellI,numCellJ);
01224 m_scalarSets.push_back(scalar2);
01225 size_t n=0;
01226 for(size_t j=0; j<numCellJ; j++)
01227 for(size_t i=0; i<numCellI; i++){
01228 scalar2->set(i,j,_ScalarT(n++));
01229 if(m_deadCellFctIj) mesh->setDeadCell(i,j,(*m_deadCellFctIj)(i,j));
01230 }
01231 scalar2->setName("$CellId");
01232 scalar2->setBinding(MbDataSet::PER_CELL);
01233 mesh->addScalarSet(scalar2);
01234
01235 addScalarSets(*mesh,*vecs);
01236
01237 return *mesh;
01238 }
01239
01240
01241 template < typename _Vec3T, typename _ScalarT >
01242 inline MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>&
01243 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getLineMeshUnstructured(size_t numCells, const _Vec3T& origin, const _Vec3T& end)
01244 {
01245 MbSinGeomFunctor geomFunctor;
01246 return getLineMeshUnstructured(numCells,origin,end,geomFunctor);
01247 }
01248
01249
01250 template < typename _Vec3T, typename _ScalarT >
01251 template < typename GeomFuncT>
01252 inline MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>&
01253 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getLineMeshUnstructured(size_t numCells, const _Vec3T& origin, const _Vec3T& end, const GeomFuncT& geomFunctor)
01254 {
01255 clear();
01256 size_t numN = numCells+1;
01257
01258 _Vec3T step = (end - origin) / (_ScalarT)numCells;
01259
01260 _ScalarT* cellId = new _ScalarT[numCells];
01261 bool* deadCellList = new bool[numCells];
01262 for(size_t i = 0; i < numCells; ++i)
01263 {
01264 cellId[i] = (_ScalarT) i;
01265 if(m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
01266 }
01267
01268 _Vec3T* coords = new _Vec3T[numN];
01269 coords[0] = origin;
01270 for(size_t n = 1; n < numN; ++n)
01271 {
01272 coords[n][0] = coords[n-1][0] + step[0];
01273 coords[n][1] = coords[n-1][1] + step[1];
01274 coords[n][2] = coords[n-1][2] + step[2];
01275 coords[n][2] = std::min(geomFunctor(coords[n]),end[2]);
01276 }
01277
01278 size_t* indices = new size_t[numCells*2];
01279 size_t id=0;
01280 size_t index = 0;
01281 for(size_t c =0 ; c < numCells; ++c)
01282 {
01283 indices[id++] = index;
01284 indices[id++] = ++index;
01285 }
01286
01287 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
01288 m_scalarSets.push_back(CellIdSet);
01289 CellIdSet->setName("$CellId");
01290 CellIdSet->setBinding(MiDataSetI<double>::PER_CELL);
01291 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords,coords+numN);
01292 m_vec3Sets.push_back(vecSet);
01293 vecSet->setName("$MyGeometry");
01294
01295 MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>* mesh;
01296 mesh = new MbLineMeshUnstructured<_Vec3T,_ScalarT,_Vec3T>(coords,coords+numN, indices,indices+(numCells*2));
01297 m_mesh = mesh;
01298 if(m_deadCellFctI) mesh->setDeadCells(deadCellList,deadCellList+numCells);
01299 mesh->addScalarSet(CellIdSet);
01300 mesh->addVec3Set(vecSet);
01301
01302 addScalarSets(*mesh,numN);
01303
01304 delete indices;
01305 delete coords;
01306 delete cellId;
01307 delete deadCellList;
01308
01309 return *mesh;
01310 }
01311
01312
01313 template < typename _Vec3T, typename _ScalarT >
01314 inline MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>&
01315 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getLineMeshCurvilinear(size_t numCells, const _Vec3T& origin, const _Vec3T& end)
01316 {
01317 MbSinGeomFunctor geomFunctor;
01318 return getLineMeshCurvilinear(numCells,origin,end,geomFunctor);
01319 }
01320
01321
01322 template < typename _Vec3T, typename _ScalarT >
01323 template < typename GeomFuncT>
01324 inline MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>&
01325 MbSampleMeshBuilder<_Vec3T,_ScalarT>::getLineMeshCurvilinear(size_t numCells, const _Vec3T& origin, const _Vec3T& end, const GeomFuncT& geomFunctor)
01326 {
01327 clear();
01328 size_t numN = numCells+1;
01329
01330 _Vec3T step = (end - origin) / (_ScalarT)numCells;
01331
01332 _ScalarT* cellId = new _ScalarT[numCells];
01333 bool* deadCellList = new bool[numCells];
01334 for(size_t i = 0; i < numCells; ++i)
01335 {
01336 cellId[i] = (_ScalarT) i;
01337 if(m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
01338 }
01339
01340 _Vec3T* coords = new _Vec3T[numN];
01341 coords[0] = origin;
01342 for(size_t n = 1; n < numN; ++n)
01343 {
01344 coords[n][0] = coords[n-1][0] + step[0];
01345 coords[n][1] = coords[n-1][1] + step[1];
01346 coords[n][2] = coords[n - 1][2] + step[2];
01347 coords[n][2] = std::min(geomFunctor(coords[n]), end[2]);
01348 }
01349
01350 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId,cellId+numCells);
01351 m_scalarSets.push_back(CellIdSet);
01352 CellIdSet->setName("$CellId");
01353 CellIdSet->setBinding(MiDataSetI<double>::PER_CELL);
01354 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords,coords+numN);
01355 m_vec3Sets.push_back(vecSet);
01356 vecSet->setName("$MyGeometry");
01357
01358 MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>* mesh;
01359 mesh = new MbLineMeshCurvilinear<_Vec3T,_ScalarT,_Vec3T>(coords,coords+numN);
01360 m_mesh = mesh;
01361 if(m_deadCellFctI) mesh->setDeadCells(deadCellList,deadCellList+numCells);
01362 mesh->addScalarSet(CellIdSet);
01363 mesh->addVec3Set(vecSet);
01364
01365 addScalarSets(*mesh,numN);
01366
01367 delete coords;
01368 delete cellId;
01369 delete deadCellList;
01370
01371 return *mesh;
01372 }
01373
01374
01375 template < typename _Vec3T, typename _ScalarT >
01376 inline MbLineMeshRegular<_Vec3T, _ScalarT, _Vec3T>&
01377 MbSampleMeshBuilder<_Vec3T, _ScalarT>::getLineMeshRegular(size_t numCells, const _Vec3T& origin, const _Vec3T& end)
01378 {
01379 clear();
01380 size_t numN = numCells + 1;
01381
01382 _Vec3T step = (end - origin) / (_ScalarT)numCells;
01383
01384 _ScalarT* cellId = new _ScalarT[numCells];
01385 bool* deadCellList = new bool[numCells];
01386 for (size_t i = 0; i < numCells; ++i)
01387 {
01388 cellId[i] = (_ScalarT)i;
01389 if (m_deadCellFctI) deadCellList[i] = (*m_deadCellFctI)(i);
01390 }
01391
01392 MbLinearZFunctor geomFunctor;
01393 _Vec3T* coords = new _Vec3T[numN];
01394 coords[0] = origin;
01395 for (size_t n = 1; n < numN; ++n)
01396 {
01397 coords[n][0] = coords[n - 1][0] + step[0];
01398 coords[n][1] = coords[n - 1][1] + step[1];
01399 coords[n][2] = coords[n - 1][2] + step[2];
01400 coords[n][2] = std::min(geomFunctor(coords[n]), end[2]);
01401 }
01402
01403 MbScalarSetI<_ScalarT>* CellIdSet = new MbScalarSetI<_ScalarT>(cellId, cellId + numCells);
01404 m_scalarSets.push_back(CellIdSet);
01405 CellIdSet->setName("$CellId");
01406 CellIdSet->setBinding(MiDataSetI<double>::PER_CELL);
01407 MbVec3SetI<_Vec3T >* vecSet = new MbVec3SetI<_Vec3T>(coords, coords + numN);
01408 m_vec3Sets.push_back(vecSet);
01409 vecSet->setName("$MyGeometry");
01410
01411 MbLineMeshRegular<_Vec3T, _ScalarT, _Vec3T>* mesh;
01412 mesh = new MbLineMeshRegular<_Vec3T, _ScalarT, _Vec3T>(numCells, origin, end);
01413 m_mesh = mesh;
01414 if (m_deadCellFctI) mesh->getTopology().assignDeadFlags(deadCellList, deadCellList + numCells);
01415 mesh->addScalarSet(CellIdSet);
01416 mesh->addVec3Set(vecSet);
01417
01418 addScalarSets(*mesh, coords, numN);
01419
01420 delete coords;
01421 delete cellId;
01422 delete deadCellList;
01423
01424 return *mesh;
01425 }
01426
01427 template < typename _Vec3T, typename _ScalarT >
01428 inline void
01429 MbSampleMeshBuilder<_Vec3T,_ScalarT>::clearScalarFctors()
01430 {
01431 m_scalarFctors.clear();
01432 m_scalarFctNames.clear();
01433 }
01434
01435 template < typename _Vec3T, typename _ScalarT >
01436 inline void
01437 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addScalarFctor(const MbScalarFunctor<_ScalarT>* fctor, std::string name )
01438 {
01439 std::vector< std::string >::iterator it = std::find(m_scalarFctNames.begin(),m_scalarFctNames.end(),name);
01440 if (it != m_scalarFctNames.end())
01441 {
01442
01443 size_t index = it-m_scalarFctNames.begin();
01444 m_scalarFctors[index] = fctor;
01445 }
01446 else
01447 {
01448 m_scalarFctors.push_back(fctor);
01449 m_scalarFctNames.push_back(name);
01450 }
01451 }
01452
01453 template < typename _Vec3T, typename _ScalarT >
01454 inline void
01455 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addDeadCellFctor( const MbDeadCellFctorIjk* fctor )
01456 {
01457 m_deadCellFctIjk = fctor;
01458 }
01459
01460 template < typename _Vec3T, typename _ScalarT >
01461 inline void
01462 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addDeadCellFctor( const MbDeadCellFctorIj* fctor )
01463 {
01464 m_deadCellFctIj = fctor;
01465 }
01466
01467 template < typename _Vec3T, typename _ScalarT >
01468 inline void
01469 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addDeadCellFctor( const MbDeadCellFctorI* fctor )
01470 {
01471 m_deadCellFctI = fctor;
01472 }
01473
01474 template < typename _Vec3T, typename _ScalarT >
01475 template < typename _CoordT >
01476 inline void
01477 MbSampleMeshBuilder<_Vec3T, _ScalarT>::addScalarSets(MbDataSetStorageI<_ScalarT, _Vec3T>& storage, const _CoordT& geometry, size_t numPoints)
01478 {
01479 size_t numFcts = m_scalarFctors.size();
01480 _ScalarT* dataset = new _ScalarT[numPoints];
01481 MbScalarSetI<_ScalarT>* scalarSet;
01482 for(size_t f=0; f<numFcts ; ++f)
01483 {
01484 for(size_t n=0; n<numPoints; ++n)
01485 dataset[n] = (*m_scalarFctors[f])((_ScalarT)geometry[n][0], (_ScalarT)geometry[n][1], (_ScalarT)geometry[n][2]);
01486
01487 scalarSet = new MbScalarSetI<_ScalarT>(dataset,dataset+numPoints,m_scalarFctNames[f]);
01488 m_scalarSets.push_back(scalarSet);
01489 storage.addScalarSet(scalarSet);
01490 }
01491 delete dataset;
01492 }
01493
01494 template < typename _Vec3T, typename _ScalarT >
01495 inline void
01496 MbSampleMeshBuilder<_Vec3T, _ScalarT>::addScalarSets(MbMesh<_Vec3T, _ScalarT, _Vec3T>& mesh, size_t numPoints)
01497 {
01498 addScalarSets(mesh, mesh.getGeometry(), numPoints);
01499 }
01500
01501 template < typename _Vec3T, typename _ScalarT >
01502 template < MiMeshIjk::StorageLayout _LAYOUT >
01503 inline void
01504 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addScalarSets(MbMeshIjk<_ScalarT,_Vec3T,_LAYOUT>& mesh, const MbVec3SetIjk<_Vec3T,_LAYOUT>& geometry)
01505 {
01506 size_t numFcts = m_scalarFctors.size();
01507 size_t dimI,dimJ,dimK;
01508 geometry.getSize(dimI,dimJ,dimK);
01509 MbScalarSetIjk<_ScalarT,_LAYOUT>* scalarSet;
01510 for(size_t f=0; f<numFcts ; ++f)
01511 {
01512 scalarSet = new MbScalarSetIjk<_ScalarT,_LAYOUT>(dimI,dimJ,dimK,m_scalarFctNames[f],geometry.getBinding());
01513 for(size_t k=0; k<dimK; k++)
01514 for(size_t j=0; j<dimJ; j++)
01515 for(size_t i=0; i<dimI; i++) {
01516 MbVec3d point = geometry.get(i,j,k);
01517 scalarSet->set(i,j,k,(*m_scalarFctors[f])((_ScalarT)point[0],(_ScalarT)point[1],(_ScalarT)point[2]));
01518 }
01519 m_scalarSets.push_back(scalarSet);
01520 mesh.addScalarSetIjk(scalarSet);
01521 }
01522 }
01523
01524 template < typename _Vec3T, typename _ScalarT >
01525 inline void
01526 MbSampleMeshBuilder<_Vec3T,_ScalarT>::addScalarSets(MbMeshIj<_ScalarT,_Vec3T>& mesh, const MbVec3SetIj<_Vec3T>& geometry)
01527 {
01528 size_t numFcts = m_scalarFctors.size();
01529 size_t dimI,dimJ;
01530 geometry.getSize(dimI,dimJ);
01531 MbScalarSetIj<_ScalarT>* scalarSet;
01532 for(size_t f=0; f<numFcts ; ++f)
01533 {
01534 scalarSet = new MbScalarSetIj<_ScalarT>(dimI,dimJ,m_scalarFctNames[f],geometry.getBinding());
01535 for(size_t j=0; j<dimJ; j++)
01536 for(size_t i=0; i<dimI; i++) {
01537 MbVec3d point = geometry.get(i,j);
01538 scalarSet->set(i,j,(*m_scalarFctors[f])((_ScalarT)point[0],(_ScalarT)point[1],(_ScalarT)point[2]));
01539 }
01540 m_scalarSets.push_back(scalarSet);
01541 mesh.addScalarSet(scalarSet);
01542 }
01543 }
01544
01545 template < typename _Vec3T, typename _ScalarT >
01546 inline void
01547 MbSampleMeshBuilder<_Vec3T,_ScalarT>::clear()
01548 {
01549 size_t numS = m_scalarSets.size();
01550 for(size_t i=0;i<numS;i++)
01551 delete m_scalarSets[i];
01552 m_scalarSets.clear();
01553 size_t numV = m_vec3Sets.size();
01554 for(size_t i=0;i<numV;i++)
01555 delete m_vec3Sets[i];
01556 m_vec3Sets.clear();
01557 delete m_mesh;
01558 m_mesh = NULL;
01559 delete m_vmesh;
01560 m_vmesh = NULL;
01561 }
01562
01563 #endif
01564
01565
01566