MeshKit
1.0
|
00001 #ifndef MESHKIT_ITAPS_MESH_HPP 00002 #define MESHKIT_ITAPS_MESH_HPP 00003 00007 #include "moab/EntityType.hpp" 00008 #include "iMesh.h" 00009 #include "iRel.hpp" 00010 #include <string.h> 00011 #include <stdlib.h> 00012 #include <vector> 00013 #include <limits> 00014 #include <string> 00015 00016 #define ITAPS_PREFIX iMesh 00017 #include "meshkit/iBase.hpp" 00018 #undef ITAPS_PREFIX 00019 00031 class iMesh : public iMeshBase { 00032 public: 00033 inline iRel::IfaceType iface_type() const { 00034 return iRel::IMESH_IFACE; 00035 } 00036 00037 00038 /* map to MB's entity type from TSTT's entity topology */ 00039 static const moab::EntityType mb_topology_table[iMesh_ALL_TOPOLOGIES+1]; 00040 00041 typedef iMesh_EntityTopology EntityTopology; 00042 typedef iBase_AdjacencyCost AdjacencyCost; 00043 00044 explicit inline iMesh( const char* options = 0 ); 00045 inline iMesh( iMesh_Instance imesh ); 00046 00047 inline ~iMesh(); 00048 00049 inline Error load( EntitySetHandle set, 00050 const char* file_name, 00051 const char* options = 0 ); 00052 00053 inline Error save( EntitySetHandle set, 00054 const char* file_name, 00055 const char* options = 0 ); 00056 00057 inline int getGeometricDimension() const; 00058 00059 inline Error setGeometricDimension( int dim ); 00060 00061 inline StorageOrder getDfltStorage() const; 00062 00063 typedef AdjacencyCost (*AdjTableType)[4]; 00064 inline const AdjTableType getAdjTable(); 00065 00066 inline Error getNumOfType( EntitySetHandle set, EntityType type, int& count_out ) const; 00067 00068 inline Error getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const; 00069 00070 inline bool optimize(); 00071 00072 inline Error getEntities( EntitySetHandle set, 00073 EntityType type, 00074 EntityTopology topo, 00075 std::vector<EntityHandle>& entities_out ) const; 00076 00077 inline Error getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const; 00078 inline Error setVtxCoord( EntityHandle vertex, double x, double y, double z ); 00079 00080 00081 inline Error getVtxArrCoords( const EntityHandle* vertex_handles, 00082 int vertex_handles_size, 00083 StorageOrder storage_order, 00084 double* coords_out ) const; 00085 00086 inline Error setVtxArrCoords( const EntityHandle* vertex_handles, 00087 int vertex_handles_size, 00088 StorageOrder storage_order, 00089 const double* new_coords ); 00090 00091 inline Error createVtx( double x, double y, double z, EntityHandle& vertex_out ); 00092 00093 inline Error createVtxArr( int num_verts, 00094 StorageOrder storage_order, 00095 const double* new_coords, 00096 EntityHandle* new_vertex_handles_out ); 00097 00098 inline Error createEnt( EntityTopology topology, 00099 const EntityHandle* lower_order_entity_handles, 00100 int lower_order_entity_handles_size, 00101 EntityHandle& new_entity_handle_out ); 00102 00103 inline Error createEntArr( EntityTopology new_entity_topology, 00104 const EntityHandle* lower_order_entity_handles, 00105 int lower_order_entity_handles_size, 00106 EntityHandle* new_entity_handles_out ); 00107 00108 inline Error deleteEnt( EntityHandle handle ); 00109 00110 inline Error deleteEntArr( const EntityHandle* entity_handles, int num_handles ); 00111 00112 inline Error getAdjEntities( EntitySetHandle set, 00113 EntityType type_requestor, 00114 EntityTopology topo_requestor, 00115 EntityType type_requested, 00116 std::vector<EntityHandle>& adj_entity_handles, 00117 std::vector<int>& offset ) const; 00118 00122 class EntArrIter { 00123 private: 00124 friend class iMesh; 00125 iBase_EntityArrIterator mHandle; 00126 iMesh_Instance mInstance; 00127 int mSize; 00128 public: 00129 EntArrIter() : mHandle(0), mInstance(0), mSize(0) {} 00130 inline ~EntArrIter(); 00131 inline Error getNext( EntityHandle* entity_handles_out, 00132 int& size_out, 00133 bool& has_more_data_out ); 00134 inline Error reset(); 00135 }; 00136 00140 class EntIter { 00141 private: 00142 friend class iMesh; 00143 iBase_EntityIterator mHandle; 00144 iMesh_Instance mInstance; 00145 public: 00146 EntIter() : mHandle(0), mInstance(0) {} 00147 inline ~EntIter(); 00148 inline Error getNext( EntityHandle& entity_handle_out, 00149 bool& has_more_data_out ); 00150 inline Error reset(); 00151 }; 00152 00153 inline Error initEntIter( EntitySetHandle set, 00154 EntityType requested_type, 00155 EntityTopology requested_topo, 00156 int resilient, 00157 EntIter& iter ); 00158 inline Error initEntArrIter( EntitySetHandle set, 00159 EntityType requested_type, 00160 EntityTopology requested_topo, 00161 int requested_array_size, 00162 int resilient, 00163 EntArrIter& iter ); 00164 00165 inline Error getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const; 00166 inline Error getEntArrTopo( const EntityHandle* entity_handles, 00167 int entity_handles_Size, 00168 EntityTopology* topos_out ) const; 00169 00170 inline Error getEntType( EntityHandle handle, EntityType& type_out ) const; 00171 inline Error getEntArrType( const EntityHandle* entity_handles, 00172 int entity_handles_Size, 00173 EntityType* types_out ) const; 00174 00175 inline Error getEntAdj( EntityHandle handle, 00176 EntityType type_requested, 00177 std::vector<EntityHandle>& adj_entities_out ) const; 00178 inline Error getEntArrAdj( const EntityHandle* entity_handles, 00179 int entity_handles_size, 00180 EntityType type_requested, 00181 std::vector<EntityHandle>& adjacent_entity_handles_out, 00182 int* offsets_out ) const ; 00183 00184 inline Error getEnt2ndAdj( EntityHandle handle, 00185 EntityType bridge_entity_type, 00186 EntityType type_requested, 00187 std::vector<EntityHandle> adj_entities_out ) const; 00188 inline Error getEntArr2ndAdj( const EntityHandle* entity_handles, 00189 int entity_handles_size, 00190 EntityType order_key, 00191 EntityType type_requested, 00192 std::vector<EntityHandle>& adjacent_entity_handles_out, 00193 int* offsets_out ) const; 00194 00195 inline Error getAdjEntIndices( EntitySetHandle set, 00196 EntityType requestor_type, 00197 EntityTopology requestor_topo, 00198 EntityType type_requested, 00199 std::vector<EntityHandle>& entity_handles_out, 00200 std::vector<EntityHandle>& adj_entity_handles_out, 00201 std::vector<int>& adj_entity_indices_out, 00202 std::vector<int>& offsets_out ) const; 00203 00204 private: 00205 bool iMeshInstanceOwner; 00206 AdjacencyCost adjTable[4][4]; 00207 Error adjTableErr; 00208 00209 void cacheAdjTable(); 00210 00211 // prohibit copying 00212 iMesh( const iMesh& ) {} 00213 void operator=(const iMesh&) {} 00214 }; 00215 00216 inline void 00217 iMesh::cacheAdjTable() 00218 { 00219 int err; 00220 if (sizeof(int) == sizeof(AdjacencyCost)) { 00221 int* ptr = (int*)&adjTable[0][0]; 00222 int size = 16, alloc = 16; 00223 iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err ); 00224 adjTableErr = (Error)err; 00225 } 00226 else { 00227 int data[16]; 00228 int* ptr = data; 00229 int size = 16, alloc = 16; 00230 iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err ); 00231 adjTableErr = (Error)err; 00232 for (int i = 0; i < 4; ++i) 00233 for (int j = 0; j < 4; ++j) 00234 adjTable[i][j] = (AdjacencyCost)data[4*i+1]; 00235 } 00236 } 00237 00238 inline 00239 iMesh::iMesh( const char* options ) 00240 { 00241 int err, len = options ? strlen(options) : 0; 00242 iMesh_newMesh( options, &mInstance, &err, len ); 00243 if (iBase_SUCCESS != err) { 00244 mInstance = 0; 00245 iMeshInstanceOwner = false; 00246 } 00247 else { 00248 iMeshInstanceOwner = true; 00249 cacheAdjTable(); 00250 } 00251 } 00252 00253 inline 00254 iMesh::iMesh( iMesh_Instance instance ) 00255 : iMeshInstanceOwner(false) 00256 { 00257 mInstance = instance; 00258 cacheAdjTable(); 00259 } 00260 00261 inline iMesh::~iMesh() 00262 { 00263 if (iMeshInstanceOwner) { 00264 int err; 00265 iMesh_dtor( mInstance, &err ); 00266 } 00267 } 00268 00269 inline iMesh::Error 00270 iMesh::load( EntitySetHandle set, 00271 const char* file_name, 00272 const char* options ) 00273 { 00274 int err, len = options ? strlen(options) : 0; 00275 iMesh_load( mInstance, set, file_name, options, &err, strlen(file_name), len ); 00276 return (Error)err; 00277 } 00278 00279 00280 inline iMesh::Error 00281 iMesh::save( EntitySetHandle set, 00282 const char* file_name, 00283 const char* options ) 00284 { 00285 int err, len = options ? strlen(options) : 0; 00286 iMesh_save( mInstance, set, file_name, options, &err, strlen(file_name), len ); 00287 return (Error)err; 00288 } 00289 00290 00291 inline int 00292 iMesh::getGeometricDimension() const 00293 { 00294 int err, result; 00295 iMesh_getGeometricDimension( mInstance, &result, &err ); 00296 return iBase_SUCCESS == err ? result : -err; 00297 } 00298 00299 00300 inline iMesh::Error 00301 iMesh::setGeometricDimension( int dim ) 00302 { 00303 int err; 00304 iMesh_setGeometricDimension( mInstance, dim, &err ); 00305 return (Error)err; 00306 } 00307 00308 inline iMesh::StorageOrder 00309 iMesh::getDfltStorage() const 00310 { 00311 int err, order; 00312 iMesh_getDfltStorage( mInstance, &order, &err ); 00313 return (iBase_SUCCESS == err) ? (StorageOrder)order : iBase_BLOCKED; 00314 } 00315 00316 inline const iMesh::AdjTableType 00317 iMesh::getAdjTable() 00318 { 00319 return (iBase_SUCCESS == adjTableErr) ? adjTable : 0; 00320 } 00321 00322 inline iMesh::Error 00323 iMesh::getNumOfType( EntitySetHandle set, EntityType type, int& count_out ) const 00324 { 00325 int err; 00326 iMesh_getNumOfType( mInstance, set, type, &count_out, &err ); 00327 return (Error)err; 00328 } 00329 00330 inline iMesh::Error 00331 iMesh::getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const 00332 { 00333 int err; 00334 iMesh_getNumOfTopo( mInstance, set, topo, &count_out, &err ); 00335 return (Error)err; 00336 } 00337 00338 inline bool 00339 iMesh::optimize() 00340 { 00341 int err, result; 00342 iMesh_optimize( mInstance, &result, &err ); 00343 return (iBase_SUCCESS == err) ? !!result : true; 00344 } 00345 00346 inline iMesh::Error 00347 iMesh::getEntities( EntitySetHandle set, 00348 EntityType type, 00349 EntityTopology topo, 00350 std::vector<EntityHandle>& entities_out ) const 00351 { 00352 // if input vect has no allocated space, allocate some so 00353 // we don't accidentally ask the impl to allocate an array 00354 if (entities_out.capacity() == 0) { 00355 Error err2; 00356 int count; 00357 if (topo == iMesh_ALL_TOPOLOGIES) 00358 err2 = getNumOfType( set, type, count ); 00359 else 00360 err2 = getNumOfTopo( set, topo, count ); 00361 if (err2 != iBase_SUCCESS) 00362 return err2; 00363 entities_out.resize( count ); 00364 } 00365 00366 // try getting results using whatever space input vector has allocated 00367 int err, size = 0, alloc = entities_out.capacity(); 00368 entities_out.resize( entities_out.capacity() ); 00369 EntityHandle* ptr = &entities_out[0]; 00370 iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err ); 00371 entities_out.resize(size); 00372 00373 // if input vector was too small, try again with increased size 00374 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00375 alloc = entities_out.size(); 00376 ptr = &entities_out[0]; 00377 iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err ); 00378 } 00379 00380 return (Error)err; 00381 } 00382 00383 inline iMesh::Error 00384 iMesh::getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const 00385 { 00386 int err; 00387 iMesh_getVtxCoord( mInstance, vertex, &x, &y, &z, &err ); 00388 return (Error)err; 00389 } 00390 00391 inline iMesh::Error 00392 iMesh::setVtxCoord( EntityHandle vertex, double x, double y, double z ) 00393 { 00394 int err; 00395 iMesh_setVtxCoord( mInstance, vertex, x, y, z, &err ); 00396 return (Error)err; 00397 } 00398 00399 00400 inline iMesh::Error 00401 iMesh::getVtxArrCoords( const EntityHandle* vertex_handles, 00402 int vertex_handles_size, 00403 StorageOrder storage_order, 00404 double* coords_out ) const 00405 { 00406 int err, alloc = 3*vertex_handles_size, junk, order = storage_order; 00407 iMesh_getVtxArrCoords( mInstance, vertex_handles, vertex_handles_size, 00408 order, &coords_out, &alloc, &junk, &err ); 00409 return (Error)err; 00410 } 00411 00412 inline iMesh::Error 00413 iMesh::setVtxArrCoords( const EntityHandle* vertex_handles, 00414 int vertex_handles_size, 00415 StorageOrder storage_order, 00416 const double* new_coords ) 00417 { 00418 int err, dim = getGeometricDimension(); 00419 iMesh_setVtxArrCoords( mInstance, vertex_handles, vertex_handles_size, 00420 storage_order, new_coords, dim*vertex_handles_size, 00421 &err ); 00422 return (Error)err; 00423 } 00424 00425 inline iMesh::Error 00426 iMesh::createVtx( double x, double y, double z, EntityHandle& vertex_out ) 00427 { 00428 int err; 00429 iMesh_createVtx( mInstance, x, y, z, &vertex_out, &err ); 00430 return (Error)err; 00431 } 00432 00433 00434 inline iMesh::Error 00435 iMesh::createVtxArr( int num_verts, 00436 StorageOrder storage_order, 00437 const double* new_coords, 00438 EntityHandle* new_vertex_handles_out ) 00439 { 00440 int err, alloc = num_verts, junk, dim = getGeometricDimension(); 00441 iMesh_createVtxArr( mInstance, num_verts, storage_order, new_coords, 00442 dim * num_verts, &new_vertex_handles_out, 00443 &alloc, &junk, &err ); 00444 return (Error)err; 00445 } 00446 00447 inline iMesh::Error 00448 iMesh::createEnt( EntityTopology topology, 00449 const EntityHandle* entities, 00450 int entities_size, 00451 EntityHandle& new_entity_out ) 00452 { 00453 int err, status; 00454 iMesh_createEnt( mInstance, topology, entities, entities_size, &new_entity_out, &status, &err ); 00455 if (err == iBase_SUCCESS) 00456 if (status == iBase_ALREADY_EXISTED || status == iBase_CREATION_FAILED) 00457 err = iBase_ENTITY_CREATION_ERROR; 00458 return (Error)err; 00459 } 00460 00461 inline iMesh::Error 00462 iMesh::createEntArr( EntityTopology new_entity_topology, 00463 const EntityHandle* lower_order_handles, 00464 int lower_order_handles_size, 00465 EntityHandle* new_entity_handles_out ) 00466 { 00467 std::vector<int> status(lower_order_handles_size, iBase_CREATION_FAILED); 00468 int err, alloc = lower_order_handles_size, size = 0; 00469 int status_alloc = status.size(), junk, *stat_ptr = &status[0]; 00470 00471 iMesh_createEntArr( mInstance, new_entity_topology, 00472 lower_order_handles, lower_order_handles_size, 00473 &new_entity_handles_out, &alloc, &size, 00474 &stat_ptr, &status_alloc, &junk, &err ); 00475 00476 if (iBase_SUCCESS == err) { 00477 for (int i = 0; i < size; ++i) 00478 if (status[i] != iBase_NEW && status[i] != iBase_CREATED_DUPLICATE) 00479 err = iBase_ENTITY_CREATION_ERROR; 00480 } 00481 00482 if (iBase_SUCCESS != err) { 00483 int err2, w = 0; 00484 for (int r = 0; r < size; ++r) 00485 if (status[r] == iBase_NEW || status[r] == iBase_CREATED_DUPLICATE) 00486 new_entity_handles_out[w++] = new_entity_handles_out[r]; 00487 iMesh_deleteEntArr( mInstance, new_entity_handles_out, w, &err2 ); 00488 } 00489 00490 return (Error)err; 00491 } 00492 00493 inline iMesh::Error 00494 iMesh::deleteEnt( EntityHandle handle ) 00495 { 00496 int err; 00497 iMesh_deleteEnt( mInstance, handle, &err ); 00498 return (Error)err; 00499 } 00500 00501 inline iMesh::Error 00502 iMesh::deleteEntArr( const EntityHandle* entity_handles, int num_handles ) 00503 { 00504 int err; 00505 iMesh_deleteEntArr( mInstance, entity_handles, num_handles, &err ); 00506 return (Error)err; 00507 } 00508 00509 inline iMesh::Error 00510 iMesh::getAdjEntities( EntitySetHandle set, 00511 EntityType type_requestor, 00512 EntityTopology topo_requestor, 00513 EntityType type_requested, 00514 std::vector<EntityHandle>& adj_entity_handles, 00515 std::vector<int>& offset ) const 00516 { 00517 std::vector<EntityHandle> entities; 00518 Error err = getEntities( set, type_requestor, topo_requestor, entities ); 00519 if (iBase_SUCCESS != err) 00520 return err; 00521 00522 offset.resize( entities.size() + 1 ); 00523 return getEntArrAdj( &entities[0], entities.size(), type_requested, 00524 adj_entity_handles, &offset[0] ); 00525 } 00526 00527 inline iMesh::Error 00528 iMesh::initEntIter( EntitySetHandle set, 00529 EntityType requested_type, 00530 EntityTopology requested_topo, 00531 int resilient, 00532 iMesh::EntIter& iter ) 00533 { 00534 int err; 00535 iter.mInstance = mInstance; 00536 iMesh_initEntIter( mInstance, set, requested_type, requested_topo, resilient, 00537 &iter.mHandle, &err ); 00538 return (Error)err; 00539 } 00540 00541 inline iMesh::Error 00542 iMesh::initEntArrIter( EntitySetHandle set, 00543 EntityType requested_type, 00544 EntityTopology requested_topo, 00545 int requested_array_size, 00546 int resilient, 00547 iMesh::EntArrIter& iter ) 00548 { 00549 int err; 00550 iter.mInstance = mInstance; 00551 iter.mSize = requested_array_size; 00552 iMesh_initEntArrIter( mInstance, set, requested_type, requested_topo, 00553 requested_array_size, resilient, &iter.mHandle, &err ); 00554 return (Error)err; 00555 } 00556 00557 inline 00558 iMesh::EntArrIter::~EntArrIter() 00559 { 00560 int err; 00561 if (mHandle != 0) { 00562 iMesh_endEntArrIter( mInstance, mHandle, &err ); 00563 mHandle = 0; 00564 } 00565 } 00566 00567 inline 00568 iMesh::EntIter::~EntIter() 00569 { 00570 int err; 00571 if (mHandle != 0) { 00572 iMesh_endEntIter( mInstance, mHandle, &err ); 00573 mHandle = 0; 00574 } 00575 } 00576 00577 inline iMesh::Error 00578 iMesh::EntArrIter::getNext( EntityHandle* entity_handles, 00579 int& size_out, 00580 bool& has_more_data_out ) 00581 { 00582 int err, alloc = mSize, has_data; 00583 iMesh_getNextEntArrIter( mInstance, mHandle, &entity_handles, &alloc, 00584 &size_out, &has_data, &err ); 00585 has_more_data_out = (has_data != 0); 00586 return (Error)err; 00587 } 00588 00589 inline iMesh::Error 00590 iMesh::EntIter::getNext( EntityHandle& handle_out, bool& has_more_data_out ) 00591 { 00592 int err, has_data; 00593 iMesh_getNextEntIter( mInstance, mHandle, &handle_out, &has_data, &err ); 00594 has_more_data_out = (has_data != 0); 00595 return (Error)err; 00596 } 00597 00598 inline iMesh::Error 00599 iMesh::EntArrIter::reset() 00600 { 00601 int err; 00602 iMesh_resetEntArrIter( mInstance, mHandle, &err ); 00603 return (Error)err; 00604 } 00605 00606 inline iMesh::Error 00607 iMesh::EntIter::reset() 00608 { 00609 int err; 00610 iMesh_resetEntIter( mInstance, mHandle, &err ); 00611 return (Error)err; 00612 } 00613 00614 inline iMesh::Error 00615 iMesh::getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const 00616 { 00617 int err, result; 00618 iMesh_getEntTopo( mInstance, handle, &result, &err ); 00619 topo_out = (EntityTopology)result; 00620 return (Error)err; 00621 } 00622 00623 inline iMesh::Error 00624 iMesh::getEntArrTopo( const EntityHandle* entity_handles, 00625 int entity_handles_size, 00626 EntityTopology* topos_out ) const 00627 { 00628 int err, alloc = entity_handles_size, junk, *ptr; 00629 std::vector<int> storage; 00630 if (sizeof(EntityTopology) == sizeof(int)) 00631 ptr = reinterpret_cast<int*>(topos_out); 00632 else { 00633 storage.resize( entity_handles_size ); 00634 ptr = &storage[0]; 00635 } 00636 00637 iMesh_getEntArrTopo( mInstance, entity_handles, entity_handles_size, 00638 &ptr, &alloc, &junk, &err ); 00639 00640 if (sizeof(EntityTopology) != sizeof(int)) 00641 for (int i = 0; i < entity_handles_size; ++i) 00642 topos_out[i] = (EntityTopology)storage[i]; 00643 00644 return (Error)err; 00645 } 00646 00647 inline iMesh::Error 00648 iMesh::getEntType( EntityHandle handle, EntityType& type_out ) const 00649 { 00650 int err, result; 00651 iMesh_getEntType( mInstance, handle, &result, &err ); 00652 type_out = (EntityType)result; 00653 return (Error)err; 00654 } 00655 00656 inline iMesh::Error 00657 iMesh::getEntArrType( const EntityHandle* entity_handles, 00658 int entity_handles_size, 00659 EntityType* types_out ) const 00660 { 00661 int err, alloc = entity_handles_size, junk, *ptr; 00662 std::vector<int> storage; 00663 if (sizeof(EntityType) == sizeof(int)) 00664 ptr = reinterpret_cast<int*>(types_out); 00665 else { 00666 storage.resize( entity_handles_size ); 00667 ptr = &storage[0]; 00668 } 00669 00670 iMesh_getEntArrType( mInstance, entity_handles, entity_handles_size, 00671 &ptr, &alloc, &junk, &err ); 00672 00673 if (sizeof(EntityType) != sizeof(int)) 00674 for (int i = 0; i < entity_handles_size; ++i) 00675 types_out[i] = (EntityType)storage[i]; 00676 00677 return (Error)err; 00678 } 00679 00680 inline iMesh::Error 00681 iMesh::getEntAdj( EntityHandle handle, 00682 EntityType type_requested, 00683 std::vector<EntityHandle>& adj_entities_out ) const 00684 { 00685 if (adj_entities_out.capacity() == 0) 00686 adj_entities_out.resize(12); 00687 else 00688 adj_entities_out.resize( adj_entities_out.capacity() ); 00689 00690 int err, alloc = adj_entities_out.size(), size = 0; 00691 EntityHandle* ptr = &adj_entities_out[0]; 00692 iMesh_getEntAdj( mInstance, handle, type_requested, 00693 &ptr, &alloc, &size, &err ); 00694 adj_entities_out.resize(size); 00695 00696 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00697 alloc = adj_entities_out.size(); 00698 ptr = &adj_entities_out[0]; 00699 iMesh_getEntAdj( mInstance, handle, type_requested, 00700 &ptr, &alloc, &size, &err ); 00701 } 00702 00703 return (Error)err; 00704 } 00705 00706 inline iMesh::Error 00707 iMesh::getEntArrAdj( const EntityHandle* entity_handles, 00708 int entity_handles_size, 00709 EntityType type_requested, 00710 std::vector<EntityHandle>& adj_entities_out, 00711 int* offsets_out ) const 00712 { 00713 if (adj_entities_out.capacity() == 0) 00714 adj_entities_out.resize(12*entity_handles_size); 00715 else 00716 adj_entities_out.resize( adj_entities_out.capacity() ); 00717 00718 int err, alloc = adj_entities_out.size(), size = 0; 00719 int off_alloc = entity_handles_size+1, junk; 00720 EntityHandle* ptr = &adj_entities_out[0]; 00721 iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size, 00722 type_requested, 00723 &ptr, &alloc, &size, 00724 &offsets_out, &off_alloc, &junk, 00725 &err ); 00726 adj_entities_out.resize(size); 00727 00728 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00729 alloc = adj_entities_out.size(); 00730 ptr = &adj_entities_out[0]; 00731 iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size, 00732 type_requested, 00733 &ptr, &alloc, &size, 00734 &offsets_out, &off_alloc, &junk, 00735 &err ); 00736 } 00737 00738 return (Error)err; 00739 } 00740 00741 00742 inline iMesh::Error 00743 iMesh::getEnt2ndAdj( EntityHandle handle, 00744 EntityType bridge_entity_type, 00745 EntityType type_requested, 00746 std::vector<EntityHandle> adj_entities_out ) const 00747 { 00748 if (adj_entities_out.capacity() == 0) 00749 adj_entities_out.resize(12); 00750 else 00751 adj_entities_out.resize( adj_entities_out.capacity() ); 00752 00753 int err, alloc = adj_entities_out.size(), size = 0; 00754 EntityHandle* ptr = &adj_entities_out[0]; 00755 iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested, 00756 &ptr, &alloc, &size, &err ); 00757 adj_entities_out.resize(size); 00758 00759 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00760 alloc = adj_entities_out.size(); 00761 ptr = &adj_entities_out[0]; 00762 iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested, 00763 &ptr, &alloc, &size, &err ); 00764 } 00765 00766 return (Error)err; 00767 } 00768 00769 inline iMesh::Error 00770 iMesh::getEntArr2ndAdj( const EntityHandle* entity_handles, 00771 int entity_handles_size, 00772 EntityType order_key, 00773 EntityType type_requested, 00774 std::vector<EntityHandle>& adj_entities_out, 00775 int* offsets_out ) const 00776 { 00777 if (adj_entities_out.capacity() == 0) 00778 adj_entities_out.resize(12*entity_handles_size); 00779 else 00780 adj_entities_out.resize( adj_entities_out.capacity() ); 00781 00782 int err, alloc = adj_entities_out.size(), size = 0; 00783 int off_alloc = entity_handles_size+1, junk; 00784 EntityHandle* ptr = &adj_entities_out[0]; 00785 iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size, 00786 order_key, type_requested, 00787 &ptr, &alloc, &size, 00788 &offsets_out, &off_alloc, &junk, 00789 &err ); 00790 adj_entities_out.resize(size); 00791 00792 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00793 alloc = adj_entities_out.size(); 00794 ptr = &adj_entities_out[0]; 00795 iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size, 00796 order_key, type_requested, 00797 &ptr, &alloc, &size, 00798 &offsets_out, &off_alloc, &junk, 00799 &err ); 00800 } 00801 00802 return (Error)err; 00803 } 00804 00805 00806 inline iMesh::Error 00807 iMesh::getAdjEntIndices( EntitySetHandle set, 00808 EntityType requestor_type, 00809 EntityTopology requestor_topo, 00810 EntityType type_requested, 00811 std::vector<EntityHandle>& entities_out, 00812 std::vector<EntityHandle>& adj_entities_out, 00813 std::vector<int>& adj_indices_out, 00814 std::vector<int>& offsets_out ) const 00815 { 00816 // if input vects have no allocated space, allocate some so 00817 // we don't accidentally ask the impl to allocate an array 00818 if (entities_out.capacity() == 0) { 00819 Error err2; 00820 int count; 00821 if (requestor_topo == iMesh_ALL_TOPOLOGIES) 00822 err2 = getNumOfType( set, requestor_type, count ); 00823 else 00824 err2 = getNumOfTopo( set, requestor_topo, count ); 00825 if (err2 != iBase_SUCCESS) 00826 return err2; 00827 entities_out.resize( count ); 00828 } 00829 else 00830 entities_out.resize( entities_out.capacity() ); 00831 00832 if (adj_entities_out.capacity() == 0) 00833 adj_entities_out.resize( 12*entities_out.size() ); 00834 else 00835 adj_entities_out.resize( adj_entities_out.capacity() ); 00836 00837 if (adj_indices_out.capacity() == 0) 00838 adj_indices_out.resize( 12*entities_out.size() ); 00839 else 00840 adj_indices_out.resize( adj_indices_out.capacity() ); 00841 00842 if (offsets_out.capacity() == 0) 00843 offsets_out.resize( entities_out.size() + 1 ); 00844 else 00845 offsets_out.resize( offsets_out.capacity() ); 00846 00847 int err; 00848 int entities_size = 0, entities_alloc = entities_out.size(); 00849 int adj_entities_size = 0, adj_entities_alloc = adj_entities_out.size(); 00850 int adj_indices_size = 0, adj_indices_alloc = adj_indices_out.size(); 00851 int offsets_size = 0, offsets_alloc = offsets_out.size(); 00852 EntityHandle* entities_ptr = & entities_out[0]; 00853 EntityHandle* adj_entities_ptr = &adj_entities_out[0]; 00854 int * adj_indices_ptr = & adj_indices_out[0]; 00855 int * offsets_ptr = & offsets_out[0]; 00856 00857 iMesh_getAdjEntIndices( mInstance, 00858 set, requestor_type, requestor_topo, 00859 type_requested, 00860 & entities_ptr, & entities_alloc, & entities_size, 00861 &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size, 00862 & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size, 00863 & offsets_ptr, & offsets_alloc, & offsets_size, 00864 &err ); 00865 00866 entities_out.resize( entities_size ); 00867 adj_entities_out.resize( adj_entities_size ); 00868 adj_indices_out.resize( adj_indices_size ); 00869 offsets_out.resize( offsets_size ); 00870 00871 if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) { 00872 entities_alloc = entities_out.size(); 00873 adj_entities_alloc = adj_entities_out.size(); 00874 adj_indices_alloc = adj_indices_out.size(); 00875 offsets_alloc = offsets_out.size(); 00876 entities_ptr = & entities_out[0]; 00877 adj_entities_ptr = &adj_entities_out[0]; 00878 adj_indices_ptr = & adj_indices_out[0]; 00879 offsets_ptr = & offsets_out[0]; 00880 00881 iMesh_getAdjEntIndices( mInstance, 00882 set, requestor_type, requestor_topo, 00883 type_requested, 00884 & entities_ptr, & entities_alloc, & entities_size, 00885 &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size, 00886 & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size, 00887 & offsets_ptr, & offsets_alloc, & offsets_size, 00888 &err ); 00889 } 00890 00891 return (Error)err; 00892 } 00893 00894 #endif 00895