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