|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
|
MOAB: Mesh Oriented datABase
(version 5.4.1)
|
00001 #ifndef _ITAPS_iMesh 00002 #define _ITAPS_iMesh 00003 00004 #include "iBase.h" 00005 #include "iMesh_protos.h" 00006 00007 /***************************************************************************/ /** 00008 * \ingroup 00009 *VersionNumbers 00010 * \brief Compile time 00011 *version number 00012 *digits 00013 * 00014 * iMesh maintains a 00015 *major, minor and 00016 *patch digit in its 00017 *version number. 00018 * Technically 00019 *speaking, there is 00020 *not much practical 00021 *value in patch digit 00022 * for an interface 00023 *specification. A 00024 *patch release is 00025 *typically only used 00026 * for bug fix 00027 *releases. Although 00028 *it is rare, 00029 *sometimes a bug fix 00030 * necessitates an API 00031 *change. So, we 00032 *define a patch digit 00033 *for iMesh. 00034 ******************************************************************************/ 00035 #define IMESH_VERSION_MAJOR ITAPS_VERSION_MAJOR 00036 #define IMESH_VERSION_MINOR ITAPS_VERSION_MINOR 00037 #define IMESH_VERSION_PATCH ITAPS_VERSION_PATCH 00038 00039 /***************************************************************************/ /** 00040 * \ingroup 00041 *VersionNumbers 00042 * \brief Maintain 00043 *backward 00044 *compatibility with 00045 *old version symbol 00046 *names 00047 ******************************************************************************/ 00048 #define IMESH_MAJOR_VERSION IMESH_VERSION_MAJOR 00049 #define IMESH_MINOR_VERSION IMESH_VERSION_MINOR 00050 #define IMESH_PATCH_VERSION IMESH_VERSION_PATCH 00051 00052 /***************************************************************************/ /** 00053 * \ingroup 00054 *VersionNumbers 00055 * \brief Version 00056 *Comparison 00057 * 00058 * Evaluates to true 00059 *at CPP time if the 00060 *version of iMesh 00061 *currently being 00062 * compiled is greater 00063 *than or equal to the 00064 *version specified. 00065 ******************************************************************************/ 00066 #define IMESH_VERSION_GE( Maj, Min, Pat ) ITAPS_VERSION_GE( Maj, Min, Pat ) 00067 00068 /***************************************************************************/ /** 00069 * \ingroup 00070 *VersionNumbers 00071 * \brief Compose 00072 *string represention 00073 *of the iMesh version 00074 *number 00075 ******************************************************************************/ 00076 #define IMESH_VERSION_STRING ITAPS_VERSION_STRING_( iMesh ) 00077 00078 /***************************************************************************/ /** 00079 * \ingroup 00080 *VersionNumbers 00081 * \brief Compose a 00082 *symbol name derived 00083 *from the current 00084 *iMesh version 00085 *number. 00086 ******************************************************************************/ 00087 #define IMESH_VERSION_TAG ITAPS_VERSION_TAG_( iMesh ) 00088 00089 /***************************************************************************/ /** 00090 * \ingroup 00091 *VersionNumbers 00092 * \brief Define 00093 *iMesh_newMesh symbol 00094 *such that it depends 00095 *on version number. 00096 * 00097 * Note: We ran into 00098 *problems with this 00099 *as it influences or 00100 *is influenced by 00101 * fortran name 00102 *mangling and so 00103 *breaks fortran 00104 *compilation. So, 00105 *this is currently 00106 *disabled. 00107 ******************************************************************************/ 00108 #define IMESH_NEW_MESH_NAME__( A, B, C ) A##_##B##_##C 00109 #define IMESH_NEW_MESH_NAME_( A, B, C ) IMESH_NEW_MESH_NAME__( A, B, C ) 00110 #define IMESH_NEW_MESH_NAME( A ) IMESH_NEW_MESH_NAME_( A, IMESH_VERSION_MAJOR, IMESH_VERSION_MINOR ) 00111 /* 00112 #undef iMesh_newMesh 00113 #define iMesh_newMesh IMESH_NEW_MESH_NAME(iMesh_newMesh) 00114 */ 00115 00116 #ifdef __cplusplus 00117 extern "C" { 00118 #endif 00119 00120 /***************************************************************************/ /** 00121 * \ingroup Datatypes 00122 * \brief iMesh 00123 *instance 00124 ******************************************************************************/ 00125 typedef struct iMesh_Instance_Private* iMesh_Instance; 00126 00127 /***************************************************************************/ /** 00128 * \ingroup Datatypes 00129 * \brief Entity 00130 *Topology 00131 ******************************************************************************/ 00132 enum iMesh_EntityTopology 00133 { 00134 iMesh_EntityTopology_MIN = 0, 00135 /**< MIN symbol used to facilitate iteration over topologies */ 00136 iMesh_POINT = iMesh_EntityTopology_MIN, 00137 /**< a 0D entity (e.g. a vertex) */ 00138 iMesh_LINE_SEGMENT, 00139 /**< a 1D entity (e.g. an edge) */ 00140 iMesh_POLYGON, 00141 /**< a general 2D entity */ 00142 iMesh_TRIANGLE, 00143 /**< a specific 2D entity bounded by 3 edge entities */ 00144 iMesh_QUADRILATERAL, 00145 /**< a specific 2D entity bounded by 4 edge entities */ 00146 iMesh_POLYHEDRON, 00147 /**< a general 3D entity */ 00148 iMesh_TETRAHEDRON, 00149 /**< a specific 3D entity bounded by 4 triangle entities */ 00150 iMesh_HEXAHEDRON, 00151 /**< a specific 3D entity bounded by 6 quadrilateral entities */ 00152 iMesh_PRISM, 00153 /**< a specific 3D entity bounded by a combination of 3 quadrilateral 00154 entities and 2 triangle entities */ 00155 iMesh_PYRAMID, 00156 /**< a specific 3D entity bounded by a combination of 1 quadrilateral 00157 entity and 4 triangle entities */ 00158 iMesh_SEPTAHEDRON, 00159 /**< a hexahedral entity with one collapsed edge */ 00160 iMesh_ALL_TOPOLOGIES, 00161 /**< used only in queries to request information about all topologies */ 00162 iMesh_EntityTopology_MAX = iMesh_ALL_TOPOLOGIES 00163 /**< MAX symbol used to facilitate iteration over topologies */ 00164 }; 00165 00166 /***************************************************************************/ /** 00167 * \ingroup 00168 *ErrorHandling \brief 00169 *Get the error type 00170 *returned from the 00171 *last iMesh function 00172 ******************************************************************************/ 00173 void iMesh_getErrorType( iMesh_Instance instance, 00174 /**< [in] iMesh instance handle */ 00175 int* error_type 00176 /**< [out] Error type returned from last iMesh function 00177 (see iBase_ErrorType) */ 00178 00179 ); 00180 00181 /***************************************************************************/ /** 00182 * \ingroup 00183 *ErrorHandling \brief 00184 *Get a description of 00185 *the error returned 00186 *from the last iMesh 00187 *function 00188 ******************************************************************************/ 00189 void iMesh_getDescription( iMesh_Instance instance, 00190 /**< [in] iMesh instance handle */ 00191 char* descr, 00192 /**< [in,out] Pointer to a character string to be filled with a 00193 description of the error from the last iMesh function */ 00194 int descr_len 00195 /**< [in] Length of the character string pointed to by descr 00196 (\ref strlen) */ 00197 ); 00198 00199 /***************************************************************************/ /** 00200 * \ingroup 00201 *Initialization 00202 * \brief Construct a 00203 *new iMesh instance 00204 * 00205 ******************************************************************************/ 00206 00207 void iMesh_newMesh( const char* options, 00208 /**< [in] Pointer to implementation-specific options string 00209 (\ref options) */ 00210 iMesh_Instance* instance, 00211 /**< [in] iMesh instance handle */ 00212 int* err, 00213 /**< [out] Returned Error status (see iBase_ErrorType) */ 00214 int options_len 00215 /**< [in] Length of the character string pointed to by options 00216 (\ref strlen) */ 00217 ); 00218 00219 /***************************************************************************/ /** 00220 * \ingroup 00221 *Initialization 00222 * \brief Destroy an 00223 *iMesh instance 00224 * 00225 ******************************************************************************/ 00226 00227 void iMesh_dtor( iMesh_Instance instance, 00228 /**< [in] iMesh instance handle */ 00229 int* err 00230 /**< [out] Returned Error status (see iBase_ErrorType) */ 00231 ); 00232 00233 /***************************************************************************/ /** 00234 * \ingroup 00235 *Initialization 00236 * \brief Load a mesh 00237 *from a file 00238 * 00239 * Load a mesh from a 00240 *file. If entity set 00241 *is specified, loaded 00242 *mesh is added to 00243 *that set; specify 00244 *root set if that is 00245 *not desired. 00246 ******************************************************************************/ 00247 00248 void iMesh_load( iMesh_Instance instance, 00249 /**< [in] iMesh instance handle */ 00250 const iBase_EntitySetHandle entity_set_handle, 00251 /**< [in] Set to which loaded mesh will be added, otherwise root */ 00252 const char* name, 00253 /**< [in] File name from which mesh is to be loaded */ 00254 const char* options, 00255 /**< [in] Pointer to implementation-specific options string 00256 (\ref options) */ 00257 int* err, 00258 /**< [out] Returned Error status (see iBase_ErrorType) */ 00259 int name_len, 00260 /**< [in] Length of the file name character string 00261 (\ref strlen) */ 00262 int options_len 00263 /**< [in] Length of the options character string 00264 (\ref strlen) */ 00265 ); 00266 00267 /***************************************************************************/ /** 00268 * \ingroup 00269 *Initialization 00270 * \brief Save a mesh 00271 *to a file 00272 * 00273 * Save a mesh to a 00274 *file. If entity set 00275 *is specified, save 00276 *only the mesh 00277 *contained in that 00278 *set. 00279 ******************************************************************************/ 00280 00281 void iMesh_save( iMesh_Instance instance, 00282 /**< [in] iMesh instance handle */ 00283 const iBase_EntitySetHandle entity_set_handle, 00284 /**< [in] Entity set being saved */ 00285 const char* name, 00286 /**< [in] File name to which mesh is to be saved */ 00287 const char* options, 00288 /**< [in] Pointer to implementation-specific options string 00289 (\ref options) */ 00290 int* err, 00291 /**< [out] Returned Error status (see iBase_ErrorType) */ 00292 const int name_len, 00293 /**< [in] Length of the file name character string 00294 (\ref strlen) */ 00295 int options_len 00296 /**< [in] Length of the options character string 00297 (\ref strlen) */ 00298 ); 00299 00300 /***************************************************************************/ /** 00301 * \ingroup 00302 *Initialization 00303 * \brief Get handle 00304 *of the root set for 00305 *this instance 00306 * 00307 * Get handle of the 00308 *root set for this 00309 *instance. All mesh 00310 *entities in this 00311 *instance can be 00312 *accessed from this 00313 *set. 00314 ******************************************************************************/ 00315 00316 void iMesh_getRootSet( iMesh_Instance instance, 00317 /**< [in] iMesh instance handle */ 00318 iBase_EntitySetHandle* root_set, 00319 /**< [out] Pointer to set handle returned from function */ 00320 int* err 00321 /**< [out] Returned Error status (see iBase_ErrorType) */ 00322 ); 00323 00324 /***************************************************************************/ /** 00325 * \ingroup 00326 *Initialization 00327 * \brief Get the 00328 *geometric dimension 00329 *of mesh represented 00330 *in this instance 00331 * 00332 ******************************************************************************/ 00333 00334 void iMesh_getGeometricDimension( iMesh_Instance instance, 00335 /**< [in] iMesh instance handle */ 00336 int* geom_dim, 00337 /**< [out] Pointer to dimension returned from this function */ 00338 int* err 00339 /**< [out] Returned Error status (see iBase_ErrorType) */ 00340 ); 00341 00342 /***************************************************************************/ /** 00343 * \ingroup 00344 *Initialization 00345 * \brief Set 00346 *geometric dimension 00347 *of vertex 00348 *coordinates 00349 * 00350 * Set the geometric 00351 *dimension of the 00352 *mesh. Note: An 00353 *application should 00354 *not expect this 00355 *function to succeed 00356 *unless the mesh 00357 *instance is empty. 00358 *An empty mesh 00359 *instance is any mesh 00360 *instance in which 00361 *there are no vertex 00362 *entities. 00363 ******************************************************************************/ 00364 00365 void iMesh_setGeometricDimension( iMesh_Instance instance, 00366 /**< [in] iMesh instance handle */ 00367 int geom_dim, 00368 /**< [in] Requested geometric dimension. */ 00369 int* err 00370 /**< [out] Returned Error status (see iBase_ErrorType) */ 00371 ); 00372 00373 /***************************************************************************/ /** 00374 * \ingroup 00375 *Initialization 00376 * \brief Get the 00377 *default storage 00378 *order used by this 00379 *implementation 00380 * 00381 * Get the default 00382 *storage order used 00383 *by this 00384 *implementation. 00385 *Value returned is a 00386 *member of the 00387 *iBase_StorageOrder 00388 *enumeration. 00389 ******************************************************************************/ 00390 00391 void iMesh_getDfltStorage( iMesh_Instance instance, 00392 /**< [in] iMesh instance handle */ 00393 int* order, 00394 /**< [out] Pointer to storage order returned from function 00395 (\sa iBase_StorageOrder) */ 00396 int* err 00397 /**< [out] Returned Error status (see iBase_ErrorType) */ 00398 ); 00399 00400 /***************************************************************************/ /** 00401 * \ingroup 00402 *Adjacencies \brief 00403 *Get the adjacency 00404 *table for this 00405 *implementation 00406 * 00407 * Get the adjacency 00408 *table for this 00409 *implementation. This 00410 *table is a 4x4 array 00411 *whose entries 00412 *characterize how the 00413 *implementation 00414 * behaves when 00415 *adjacent and 00416 *intermediate 00417 *entities are 00418 *queried. Entry [i,j] 00419 *(i=row, j=col, 00420 *0-based indexing) 00421 *will have one of the 00422 *values in the 00423 *iBase_AdjacencyCost 00424 *enumeration. 00425 *Off-diagonal entres, 00426 *i!=j, represents the 00427 *relative cost of 00428 *retrieving entities 00429 *of dimension i 00430 *adjacent to entities 00431 *of dimension j. 00432 * Diagonal entries, 00433 *i==j, indicate 00434 *whether or not 00435 *handles to ALL 00436 * entities of that 00437 *dimension are 00438 *obtainable from 00439 *calls that return 00440 * entity handles. 00441 *This is always true 00442 *by definition for 00443 *i==j==0 as well as 00444 *for i==j==2 in a 2D 00445 *mesh and i==j==3 in 00446 *a 3D mesh. However, 00447 *diagonal entries 00448 *[1,1] for a 2D mesh 00449 *and both [1,1] and 00450 *[2,2] for a 3D mesh 00451 *indicate whether or 00452 *not handles to ALL 00453 * intermediate 00454 *dimensioned entities 00455 *(ALL edges in a 2D 00456 *mesh or ALL edges 00457 *and ALL faces in a 00458 *3D mesh) are 00459 *obtainable from 00460 *calls that return 00461 *entity handles. A 00462 *value of 00463 *iBase_AVAILABLE for 00464 *a diagonal entry 00465 *indicates that 00466 *handles are 00467 *obtainable for ALL 00468 * entities of that 00469 *dimension while a 00470 *value of 00471 *iBase_UNAVAILABLE 00472 * indicates that 00473 *handles are not 00474 *obtainable for ALL 00475 *entities of that 00476 * dimension. 00477 ******************************************************************************/ 00478 00479 void iMesh_getAdjTable( iMesh_Instance instance, 00480 /**< [in] iMesh instance handle */ 00481 int** adjacency_table, 00482 /**< [out] Pointer to array representing adjacency table 00483 \ref trio) */ 00484 int* adjacency_table_allocated, 00485 /**< [in,out] Pointer to allocated size of adjacency_table */ 00486 int* adjacency_table_size, 00487 /**< [out] Pointer to occupied size of adjacency_table */ 00488 int* err 00489 /**< [out] Returned Error status (see iBase_ErrorType) */ 00490 ); 00491 00492 /***************************************************************************/ /** 00493 * \ingroup 00494 *Adjacencies \brief 00495 *Set the adjacency 00496 *table as requested 00497 *by the application 00498 * 00499 * Set the adjacency 00500 *table as requested 00501 *by the application. 00502 * See 00503 *iMesh_getAdjTable 00504 *for a description of 00505 *the meaning of the 00506 *entries in this 00507 *table. This call to 00508 *set the adjacency 00509 *table allows an 00510 *application to 00511 *request how it would 00512 *like an 00513 *implementation to 00514 *behave when adjacent 00515 * and/or intermediate 00516 *entities are 00517 *queried. If the 00518 *implementation is 00519 *not able to 00520 *accommodate the 00521 *requested query 00522 *behavior associated 00523 *with ANY entry in 00524 *the table, the call 00525 *will fail and return 00526 *an error of 00527 * iBase_NOT_SUPPORTED. 00528 *Otherwise, the 00529 *implementation is 00530 *able to accommodate 00531 * the requested query 00532 *behavior associated 00533 *with ALL table 00534 *entries and the call 00535 *will succeed. In 00536 *either case, 00537 *however, the 00538 *implementation will 00539 * over-write the 00540 *entries in the 00541 *adjacency_table 00542 *argument with the 00543 *same values that 00544 *would be obtained in 00545 *a succeeding call to 00546 *iMesh_getAdjTable. 00547 ******************************************************************************/ 00548 00549 void iMesh_setAdjTable( iMesh_Instance instance, 00550 /**< [in] iMesh instance handle */ 00551 int* adjacency_table, 00552 /**< [in,out] Array representing adjacency table requested by 00553 application */ 00554 int adjacency_table_size, 00555 /**< [in] Size of adj table array */ 00556 int* err 00557 /**< [out] Returned Error status (see iBase_ErrorType) */ 00558 ); 00559 00560 /***************************************************************************/ /** 00561 * \ingroup EntitySets 00562 * \brief Get the 00563 *number of entities 00564 *of specified type in 00565 *the instance or set 00566 * 00567 * Get the number of 00568 *entities with the 00569 *specified type in 00570 *the instance or set. 00571 *If entity set handle 00572 *is root set, return 00573 *information for 00574 *instance, otherwise 00575 *for set. Value of 00576 *entity type must be 00577 *from the 00578 * iBase_EntityType 00579 *enumeration. If 00580 *iBase_ALL_TYPES is 00581 *specified, total 00582 *number of entities 00583 *(excluding entity 00584 *sets) is returned. 00585 ******************************************************************************/ 00586 00587 void iMesh_getNumOfType( iMesh_Instance instance, 00588 /**< [in] iMesh instance handle */ 00589 const iBase_EntitySetHandle entity_set_handle, 00590 /**< [in] Entity set being queried */ 00591 const int entity_type, 00592 /**< [in] Type of entity requested */ 00593 int* num_type, 00594 /**< [out] Pointer to number of entities, returned from function */ 00595 int* err 00596 /**< [out] Returned Error status (see iBase_ErrorType) */ 00597 ); 00598 00599 /***************************************************************************/ /** 00600 * \ingroup EntitySets 00601 * \brief Get the 00602 *number of entities 00603 *of specified 00604 *topology in instance 00605 *or set 00606 * 00607 * Get the number of 00608 *entities with the 00609 *specified topology 00610 *in the instance or 00611 *set. If entity set 00612 *handle is root set, 00613 *return information 00614 *for instance, 00615 * otherwise for set. 00616 *Value of entity 00617 *topology must be 00618 *from the 00619 * iMesh_EntityTopology 00620 *enumeration. If 00621 *iMesh_ALL_TOPOLOGIES 00622 *is specified, total 00623 *number of entities 00624 *(excluding entity 00625 *sets) is returned. 00626 ******************************************************************************/ 00627 00628 void iMesh_getNumOfTopo( iMesh_Instance instance, 00629 /**< [in] iMesh instance handle */ 00630 const iBase_EntitySetHandle entity_set_handle, 00631 /**< [in] Entity set being queried */ 00632 const int entity_topology, 00633 /**< [in] Topology of entity requested */ 00634 int* num_topo, 00635 /**< [out] Pointer to number of entities, returned from function */ 00636 int* err 00637 /**< [out] Returned Error status (see iBase_ErrorType) */ 00638 ); 00639 00640 /***************************************************************************/ /** 00641 * \ingroup 00642 *MeshModification 00643 * \brief Permit 00644 *implementation to 00645 *'optimize' the mesh 00646 *instance 00647 * 00648 * Its concievable 00649 *that after a series 00650 *of operations 00651 *modifying the mesh 00652 * instance, the 00653 *implementation's 00654 *internal 00655 *representation of 00656 *the mesh may include 00657 *data and tie up 00658 *memory resources 00659 *that could be 00660 *'optimized' away. 00661 * For example, if the 00662 *implementation only 00663 *marks removed 00664 *entities for 00665 *deletion but does 00666 *not actually free up 00667 *memory resources 00668 *associated those 00669 *entities, a call to 00670 *this function gives 00671 *the implementation 00672 *the 'ok' to go ahead 00673 *and free up such 00674 *memory. 00675 * 00676 * Depending on the 00677 *implementation as 00678 *well as the amount 00679 *and kind of changes 00680 * to the mesh that 00681 *have been made prior 00682 *to calling it, this 00683 *call may be very 00684 *expensive in time 00685 *complexity. On the 00686 *other hand, it is 00687 *also perfectly 00688 * acceptable that an 00689 *implementation 00690 *basically treat this 00691 *operation as a 00692 *no-op. 00693 * 00694 * In any event, any 00695 *entity, entity set, 00696 *iterator or tag 00697 *handle obtained 00698 *prior to calling 00699 *this method will may 00700 *be invalidated as a 00701 *result of this call. 00702 *In that case, the 00703 *caller must 00704 *re-acquire handles 00705 *after making this 00706 *call. A return 00707 *argument indicates 00708 *if handles have been 00709 *invalidated. 00710 ******************************************************************************/ 00711 00712 void iMesh_optimize( iMesh_Instance instance, 00713 /**< [in] iMesh instance handle */ 00714 int* handles_invalidated, 00715 /**< [out] Returned flag indicating if any handles the caller held 00716 before calling this function have been invalidated as a result of 00717 this call. A value of non-zero returned here indicates that any 00718 handles the caller had prior to this call must not be trusted and 00719 must be re-acquired by caller. */ 00720 int* err 00721 /**< [out] Returned Error status (see iBase_ErrorType) */ 00722 ); 00723 00724 /***************************************************************************/ /** 00725 * \ingroup Entities 00726 * \brief Get 00727 *entities of specific 00728 *type and/or topology 00729 *in set or instance 00730 * 00731 * Get entities of 00732 *specific type and/or 00733 *topology in set or 00734 *instance. All 00735 * entities of a given 00736 *type or topology are 00737 *requested by 00738 *specifying 00739 * iBase_ALL_TOPOLOGIES 00740 *or iBase_ALL_TYPES, 00741 *respectively. 00742 *Specified type or 00743 *topology must be a 00744 *value in the 00745 *iBase_EntityType or 00746 *iBase_EntityTopology 00747 * enumeration, 00748 *respectively. 00749 ******************************************************************************/ 00750 00751 void iMesh_getEntities( iMesh_Instance instance, 00752 /**< [in] iMesh instance handle */ 00753 const iBase_EntitySetHandle entity_set_handle, 00754 /**< [in] Entity set being queried */ 00755 const int entity_type, 00756 /**< [in] Type of entities being requested */ 00757 const int entity_topology, 00758 /**< [in] Topology of entities being requested */ 00759 iBase_EntityHandle** entity_handles, 00760 /**< [in,out] Pointer to array of entity handles returned \ref trio) */ 00761 int* entity_handles_allocated, 00762 /**< [in,out] Pointer to allocated size of entity_handles array */ 00763 int* entity_handles_size, 00764 /**< [out] Pointer to occupied size of entity_handles array */ 00765 int* err 00766 /**< [out] Returned Error status (see iBase_ErrorType) */ 00767 ); 00768 00769 /***************************************************************************/ /** 00770 * \ingroup 00771 *VertexEntities 00772 * \brief Get 00773 *coordinates of 00774 *specified vertices 00775 * 00776 * Get coordinates of 00777 *specified vertices. 00778 *Coordinates are 00779 *returned in the 00780 *storage order 00781 *indicated by the 00782 *storage_order 00783 *argument. 00784 ******************************************************************************/ 00785 00786 void iMesh_getVtxArrCoords( iMesh_Instance instance, 00787 /**< [in] iMesh instance handle */ 00788 const iBase_EntityHandle* vertex_handles, 00789 /**< [in] Array of mesh vertex handles whose coordinates are being 00790 requested */ 00791 const int vertex_handles_size, 00792 /**< [in] Number of vertices in vertex_handles array */ 00793 const int storage_order, 00794 /**< [in] Requested storage order of returned coordinates 00795 (see iBase_StorageOrder) */ 00796 double** coords, 00797 /**< [in,out] Pointer to array of coordinates returned from function 00798 \ref trio) */ 00799 int* coords_allocated, 00800 /**< [in,out] Pointer to allocated size of coords array */ 00801 int* coords_size, 00802 /**< [out] Pointer to occupied size of coords array */ 00803 int* err 00804 /**< [out] Returned Error status (see iBase_ErrorType) */ 00805 ); 00806 00807 /***************************************************************************/ /** 00808 * \ingroup 00809 *EntityIterators 00810 * \brief Initialize 00811 *an array iterator 00812 *over specified 00813 *entity type, 00814 *topology, and size 00815 * 00816 * Initialize an array 00817 *iterator over 00818 *specified entity 00819 *type, topology, and 00820 * size, for a 00821 *specified set or 00822 *instance. Iterator 00823 *returned can be used 00824 * as input to 00825 *functions returning 00826 *entities for the 00827 *iterator. If all 00828 * entities of a 00829 *specified type 00830 *and/or topology are 00831 *to be iterated, 00832 * specify 00833 *iBase_ALL_TYPES or 00834 *iMesh_ALL_TOPOLOGIES, 00835 *respectively. 00836 * Specified type or 00837 *topology must be a 00838 *value in the 00839 *iBase_EntityType or 00840 * iMesh_EntityTopology 00841 *enumerations, 00842 *respectively. 00843 ******************************************************************************/ 00844 00845 void iMesh_initEntArrIter( iMesh_Instance instance, 00846 /**< [in] iMesh instance handle */ 00847 const iBase_EntitySetHandle entity_set_handle, 00848 /**< [in] Entity set being iterated */ 00849 const int requested_entity_type, 00850 /**< [in] Type of entity to iterate */ 00851 const int requested_entity_topology, 00852 /**< [in] Topology of entity to iterate */ 00853 const int requested_array_size, 00854 /**< [in] Size of chunks of handles returned for each value of the 00855 iterator */ 00856 const int resilient, 00857 /**< [in] If zero, return a non-resilient iterator. 00858 Otherwise, a resilient iterator (\ref resilient) */ 00859 iBase_EntityArrIterator* entArr_iterator, 00860 /**< [out] Pointer to iterator returned from function */ 00861 int* err 00862 /**< [out] Returned Error status (see iBase_ErrorType) */ 00863 ); 00864 00865 /***************************************************************************/ /** 00866 * \ingroup 00867 *EntityIterators 00868 * \brief Get 00869 *entities contained 00870 *in array iterator 00871 *and increment 00872 *iterator 00873 * 00874 * Get the entities 00875 *corresponding to an 00876 *array iterator (e.g. 00877 *dereference the 00878 *array iterator), and 00879 *increment the 00880 *iterator. The 00881 *dereferenced 00882 * value(s) are 00883 *returned in 00884 *entity_handles. If 00885 *the iterator is at 00886 *the end of the 00887 *iteration, the 00888 *dereferenced 00889 *value(s) are 00890 *undefined and 00891 * has_data will be 00892 *returned with a 00893 *value of zero. 00894 *Otherwise, has_data 00895 * will be returned 00896 *with a non-zero 00897 *value. 00898 ******************************************************************************/ 00899 00900 void iMesh_getNextEntArrIter( iMesh_Instance instance, 00901 /**< [in] iMesh instance handle */ 00902 iBase_EntityArrIterator entArr_iterator, 00903 /**< [in] Iterator being queried */ 00904 iBase_EntityHandle** entity_handles, 00905 /**< [in,out] Pointer to array of entity handles contained in current 00906 value of iterator \ref trio) */ 00907 int* entity_handles_allocated, 00908 /**< [in,out] Pointer to allocated size of entity_handles */ 00909 int* entity_handles_size, 00910 /**< [out] Pointer to occupied size of entity_handles */ 00911 int* has_data, 00912 /**< [out] Pointer to a flag indicating if the value(s) returned 00913 in entity_handles are valid. A non-zero value indicates the value(s) 00914 are valid. A zero value indicates the value(s) are NOT valid. */ 00915 int* err 00916 /**< [out] Returned Error status (see iBase_ErrorType) */ 00917 ); 00918 00919 /***************************************************************************/ /** 00920 * \ingroup 00921 *EntityIterators 00922 * \brief Reset the 00923 *array iterator 00924 * 00925 ******************************************************************************/ 00926 00927 void iMesh_resetEntArrIter( iMesh_Instance instance, 00928 /**< [in] iMesh instance handle */ 00929 iBase_EntityArrIterator entArr_iterator, 00930 /**< [in] Iterator to reset */ 00931 int* err 00932 /**< [out] Returned Error status (see iBase_ErrorType) */ 00933 ); 00934 00935 /***************************************************************************/ /** 00936 * \ingroup 00937 *EntityIterators 00938 * \brief Destroy the 00939 *specified array 00940 *iterator 00941 * 00942 ******************************************************************************/ 00943 00944 void iMesh_endEntArrIter( iMesh_Instance instance, 00945 /**< [in] iMesh instance handle */ 00946 iBase_EntityArrIterator entArr_iterator, 00947 /**< [in] Iterator which gets destroyed */ 00948 int* err 00949 /**< [out] Returned Error status (see iBase_ErrorType) */ 00950 ); 00951 00952 /***************************************************************************/ /** 00953 * \ingroup Entities 00954 * \brief Get the 00955 *entity topology for 00956 *the specified 00957 *entities 00958 * 00959 * Get the entity 00960 *topology for the 00961 *specified entities. 00962 *Topologies returned 00963 *are values in the 00964 *iMesh_EntityTopology 00965 *enumeration. 00966 ******************************************************************************/ 00967 00968 void iMesh_getEntArrTopo( iMesh_Instance instance, 00969 /**< [in] iMesh instance handle */ 00970 const iBase_EntityHandle* entity_handles, 00971 /**< [in] Array of entity handles being queried */ 00972 const int entity_handles_size, 00973 /**< [in] Number of entities in entity_handles array */ 00974 int** topology, 00975 /**< [in,out] Pointer to array of entity topologies returned 00976 \ref trio) */ 00977 int* topology_allocated, 00978 /**< [in,out] Pointer to allocated size of topology array */ 00979 int* topology_size, 00980 /**< [out] Pointer to occupied size of topology array */ 00981 int* err 00982 /**< [out] Returned Error status (see iBase_ErrorType) */ 00983 ); 00984 00985 /***************************************************************************/ /** 00986 * \ingroup Entities 00987 * \brief Get the 00988 *entity type for the 00989 *specified entities 00990 * 00991 * Get the entity type 00992 *for the specified 00993 *entities. Types 00994 * returned are values 00995 *in the 00996 *iBase_EntityType 00997 *enumeration. 00998 ******************************************************************************/ 00999 01000 void iMesh_getEntArrType( iMesh_Instance instance, 01001 /**< [in] iMesh instance handle */ 01002 const iBase_EntityHandle* entity_handles, 01003 /**< [in] Array of entity handles being queried */ 01004 const int entity_handles_size, 01005 /**< [in] Number of entities in entity_handles array */ 01006 int** type, 01007 /**< [in,out] Pointer to array of types returned from function 01008 \ref trio) */ 01009 int* type_allocated, 01010 /**< [in,out] Pointer to allocated size of type array */ 01011 int* type_size, 01012 /**< [out] Pointer to occupied size of type array */ 01013 int* err 01014 /**< [out] Returned Error status (see iBase_ErrorType) */ 01015 ); 01016 01017 /***************************************************************************/ /** 01018 * \ingroup 01019 *Adjacencies \brief 01020 *Get entities of 01021 *specified type 01022 *adjacent to entities 01023 * 01024 * Get entities of 01025 *specified type 01026 *adjacent to 01027 *entities. Specified 01028 *type must be value 01029 *in the 01030 *iBase_EntityType 01031 *enumeration. \em 01032 *offset(i) is index 01033 *of first entity in 01034 *adjacentEntityHandles 01035 *array adjacent to 01036 * entity_handles[i]. 01037 *More precisely, the 01038 *entities adjacent to 01039 *the ith entity in 01040 *entity_handles are 01041 *found in 01042 *adjacentEntityHandles 01043 * running from 01044 *offset[i] to 01045 *offset[i+1] - 1. 01046 *This implies that 01047 *the offset_size will 01048 *be 01049 *entity_handles_size 01050 *+ 1. 01051 * 01052 * Note 1: Because 01053 *'adjacent' as 01054 *defined by the iMesh 01055 *data model refers to 01056 *those entities that 01057 *bound another, the 01058 *entities being 01059 *queried here (in 01060 *entity_handles arg) 01061 *are NEVER ALSO 01062 *returned in 01063 * adjacentEntityHandles 01064 *even if the 01065 *entity_type_requested 01066 * matches the 01067 *entity type(s) in 01068 *entity_handles. 01069 ******************************************************************************/ 01070 01071 void iMesh_getEntArrAdj( iMesh_Instance instance, 01072 /**< [in] iMesh instance handle */ 01073 const iBase_EntityHandle* entity_handles, 01074 /**< [in] Array of entity handles being queried */ 01075 const int entity_handles_size, 01076 /**< [in] Number of entities in entity_handles array */ 01077 const int entity_type_requested, 01078 /**< [in] Type of adjacent entities requested */ 01079 iBase_EntityHandle** adjacentEntityHandles, 01080 /**< [in,out] Pointer to array of adjacentEntityHandles \ref trio) 01081 returned from function. Note that the implicit INTERLEAVED storage 01082 order rule applies (see iBase_StorageOrder) */ 01083 int* adjacentEntityHandles_allocated, 01084 /**< [in,out] Pointer to allocated size of adjacentEntityHandles array */ 01085 int* adj_entity_handles_size, 01086 /**< [out] Pointer to occupied size of adjacentEntityHandles array */ 01087 int** offset, 01088 /**< [in,out] Pointer to array of offsets returned from function 01089 \ref trio) */ 01090 int* offset_allocated, 01091 /**< [in,out] Pointer to allocated size of offset array */ 01092 int* offset_size, 01093 /**< [out] Pointer to occupied size of offset array */ 01094 int* err 01095 /**< [out] Returned Error status (see iBase_ErrorType) */ 01096 ); 01097 01098 /***************************************************************************/ /** 01099 * \ingroup 01100 *Adjacencies \brief 01101 *Get "2nd order" 01102 *adjacencies to an 01103 *array of entities 01104 * 01105 * Get "2nd order" 01106 *adjacencies to an 01107 *array of entities, 01108 *that is, from each 01109 * entity, through 01110 *other entities of a 01111 *specified "bridge" 01112 *dimension, to other 01113 * entities of another 01114 *specified "to" 01115 *dimension. Note 1: 01116 *If the "bridge" 01117 *dimension is the 01118 *same as the "to" 01119 *dimension, the 01120 *output will be empty 01121 *(and an error code 01122 *of 01123 * iBase_INVALID_ARGUMENT 01124 *returned). If the 01125 *type of a particular 01126 * entity matches 01127 *the "bridge" 01128 *dimension, there 01129 *will be no entities 01130 * returned for 01131 *that input entity. 01132 *This is consistent 01133 *with the definition 01134 *of adjacencies and 01135 *the behavior of 01136 *iMesh first 01137 * adjacency calls. 01138 * Note 2: An entity 01139 *will never be 01140 *returned as a second 01141 *adjacency of itself, 01142 *on the grounds that 01143 *this is the most 01144 *likely expectation 01145 *of applications, and 01146 *that it is easier 01147 *for an application 01148 *to add the original 01149 *entity to the 01150 *returned data than 01151 *to find and remove 01152 *it. Note 3: The 01153 *entities adjacent to 01154 *the ith entity in 01155 *entity_handles are 01156 * found in 01157 *adj_entity_handles 01158 *running from 01159 *offset[i] to 01160 * offset[i+1] - 1. 01161 *This implies that 01162 *the offset_size will 01163 *be 01164 * entity_handles_size 01165 *+ 1. 01166 ******************************************************************************/ 01167 01168 void iMesh_getEntArr2ndAdj( iMesh_Instance instance, 01169 /**< [in] iMesh instance handle */ 01170 iBase_EntityHandle const* entity_handles, 01171 /**< [in] Entities from which adjacencies are requested */ 01172 int entity_handles_size, 01173 /**< [in] Number of entities whose adjacencies are requested */ 01174 int bridge_entity_type, 01175 /**< [in] Type of bridge entity for 2nd order adjacencies */ 01176 int requested_entity_type, 01177 /**< [in] Type of adjacent entities returned */ 01178 iBase_EntityHandle** adj_entity_handles, 01179 /**< [in,out] Adjacent entities. Note that the implicit INTERLEAVED 01180 storage order rule applies (see iBase_StorageOrder) 01181 \ref trio) */ 01182 int* adj_entity_handles_allocated, 01183 /**< [in,out] Allocated size of returned array */ 01184 int* adj_entity_handles_size, 01185 /**< [out] Occupied size of returned array */ 01186 int** offset, 01187 /**< [in,out] Offset[i] is offset into adj_entity_handles of 2nd order 01188 adjacencies of ith entity in entity_handles \ref trio) */ 01189 int* offset_allocated, 01190 /**< [in,out] Allocated size of offset array */ 01191 int* offset_size, 01192 /**< [out] Occupied size of offset array */ 01193 int* err 01194 /**< [out] Returned Error status (see iBase_ErrorType) */ 01195 ); 01196 01197 /***************************************************************************/ /** 01198 * \ingroup 01199 *Adjacencies \brief 01200 *Get indexed 01201 *representation of 01202 *mesh or subset of 01203 *mesh 01204 * 01205 * Given an entity set 01206 *and optionally a 01207 *type or topology, 01208 *return: 01209 * - The entities in 01210 *the set of the 01211 *specified type or 01212 *topology 01213 * - The entities 01214 *adjacent to those 01215 *entities with a 01216 *specified type, as a 01217 *list of unique 01218 *handles. 01219 * - For each entity 01220 *in the first list, 01221 *the adjacent 01222 *entities, specified 01223 *as indices into the 01224 *second list. 01225 * 01226 * Note 1: Because 01227 *'adjacent' as 01228 *defined by the iMesh 01229 *data model refers to 01230 *those entities that 01231 *bound another, the 01232 *entities being 01233 *queried here (in 01234 *entity_set_handle 01235 *arg) are NEVER ALSO 01236 *returned in 01237 * adj_entity_handles 01238 *even if the 01239 *entity_type_requested 01240 * matches the 01241 *entity type(s) in 01242 *entity_set_handle. 01243 * Note 2: The 01244 *entities adjacent to 01245 *the ith entity in 01246 *entity_handles are 01247 * found in 01248 *adj_entity_handles 01249 *running from 01250 *offset[i] to 01251 * offset[i+1] 01252 *- 1. This implies 01253 *that the offset_size 01254 *will be 01255 *entity_handles_size 01256 *+ 1. Note 3: This 01257 *function will fail 01258 *and return an error 01259 *if the caller passes 01260 * a 01261 *combination of 01262 *entity_type and 01263 *entity_topology that 01264 *are not consistent. 01265 ******************************************************************************/ 01266 01267 void iMesh_getAdjEntIndices( iMesh_Instance instance, 01268 /**< [in] iMesh instance handle */ 01269 iBase_EntitySetHandle entity_set_handle, 01270 /**< [in] The set of entities from which to query */ 01271 int entity_type_requester, 01272 /**< [in] If not iBase_ALL_TYPES, act only on the subset of entities 01273 contained in entity_set_handle of the specified type. */ 01274 int entity_topology_requester, 01275 /**< [in] If not iMesh_ALL_TOPOLOGIES, act only on the subset of 01276 entities contained in entity_set_handle of specified topology. */ 01277 int entity_type_requested, 01278 /**< [in] The type of the adjacent entities to return */ 01279 iBase_EntityHandle** entity_handles, 01280 /**< [in,out] The handles of the (non-struct) subset of the entities 01281 contained in entity_set_handle indicated by the optional type and 01282 topology filtering arguments. \ref trio) */ 01283 int* entity_handles_allocated, 01284 /**< [in,out] Allocated size of entity_handles array */ 01285 int* entity_handles_size, 01286 /**< [out] Occupied size of entity_handles array */ 01287 iBase_EntityHandle** adj_entity_handles, 01288 /**< [in,out] The union of the unique entities of type 01289 requested_entity_type adjacent to each entity in entity_handles. 01290 Note that the implicit INTERLEAVED storage order rule 01291 applies (see iBase_StorageOrder) \ref trio) */ 01292 int* adj_entity_handles_allocated, 01293 /**< [in,out] Allocated size of adj_entity_handles array */ 01294 int* adj_entity_handles_size, 01295 /**< [out] Occupied size of adj_entity_handles array */ 01296 int** adj_entity_indices, 01297 /**< [in,out] For each entity in entity_handles, the adjacent 01298 entities of type entity_type_requested, specified as indices into 01299 adj_entity_handles. The values are concatenated into a single 01300 array in the order of the entity handles in entity_handles. 01301 \ref trio) */ 01302 int* adj_entity_indices_allocated, 01303 /**< [in,out] Allocated size of adj_entity_indices array */ 01304 int* adj_entity_indices_size, 01305 /**< [out] Occupied size of adj_entity_indices array */ 01306 int** offset, 01307 /**< [in,out] For each entity in the corresponding position in 01308 entity_handles, the position in adj_entity_indices at which 01309 values for that entity are stored \ref trio) */ 01310 int* offset_allocated, 01311 /**< [in,out] Allocated size of offset array */ 01312 int* offset_size, 01313 /**< [out] Occipied size of offset array */ 01314 int* err 01315 /**< [out] Returned Error status (see iBase_ErrorType) */ 01316 ); 01317 01318 /***************************************************************************/ /** 01319 * \ingroup EntitySets 01320 * \brief Create an 01321 *entity set 01322 * 01323 * Create an entity 01324 *set, either ordered 01325 *(isList=1) or 01326 *unordered 01327 *(isList=0). 01328 * Unordered entity 01329 *sets can contain a 01330 *given entity or set 01331 *only once. 01332 * 01333 * An entity set in 01334 *iMesh supports 01335 *managing its 01336 *contained members in 01337 *one of two modes. 01338 *When an entitiy set 01339 *is first created, 01340 *the caller is 01341 *required to indicate 01342 *which mode of 01343 *membership the set 01344 *will support. The 01345 *two modes that are 01346 *supported are a) 01347 *order-preserving 01348 *(isList=1) or b) 01349 *duplicate-preventing 01350 *(isList=0). 01351 * 01352 * For 01353 *order-preserving 01354 *membership, the 01355 *implementation will 01356 *permit duplicate 01357 * entities. However, 01358 *the implementation 01359 *will guarantee that 01360 *the order in which 01361 * entities are added 01362 *to the set will be 01363 *the same as the 01364 *order in which they 01365 *are queried by the 01366 *various methods that 01367 *return the entities 01368 *of a set. This order 01369 * preserving 01370 *guarantee holds 01371 *across removals. 01372 *However, it does not 01373 *hold across removals 01374 *followed by 01375 *re-additions of the 01376 *previously removed 01377 *entities. This kind 01378 *of an entity set 01379 *behaves like an STL 01380 *vector or STL list 01381 *and is created by 01382 *setting isList=1 01383 *when creating an 01384 *entity set. 01385 * 01386 * For 01387 *duplicate-preventing 01388 *membership, the 01389 *implementation will 01390 *guarantee that 01391 * duplicate entities 01392 *are prevented. Any 01393 *attempts to add 01394 *duplicate entities 01395 *to such a set will 01396 *be detected, 01397 *prevented and 01398 *silently ignored by 01399 *the implementation. 01400 *This kind of entity 01401 *set behaves like an 01402 *STL set and is 01403 *created by setting 01404 *isList=0 when 01405 *creating an entity 01406 *set. 01407 * 01408 * Finally, all of the 01409 *above comments apply 01410 *only to entity 01411 *members of an entity 01412 * set and do not 01413 *apply to the entity 01414 *set members. 01415 *Order-preserving and 01416 * duplicate 01417 *preventing behavior 01418 *for entity set 01419 *members is 01420 *unspecified. Each 01421 * implementation may 01422 *behave differently 01423 *for entity set 01424 *members. This design 01425 *was chosen because 01426 *we could not 01427 *identify any use 01428 *cases where 01429 * order-preserving 01430 *behavior for set 01431 *members was 01432 *necessary. However, 01433 *if users encounter 01434 *situations where 01435 *such behavior is 01436 *desirable or 01437 *necessary, then the 01438 *ITAPS development 01439 *team can certainly 01440 *consider adjusting 01441 *the interface 01442 * specification to 01443 *support it. 01444 ******************************************************************************/ 01445 01446 void iMesh_createEntSet( iMesh_Instance instance, 01447 /**< [in] iMesh instance handle */ 01448 const int isList, 01449 /**< [in] If non-zero, an ordered list is created, otherwise an 01450 unordered set is created. */ 01451 iBase_EntitySetHandle* entity_set_created, 01452 /**< [out] Entity set created by function */ 01453 int* err 01454 /**< [out] Returned Error status (see iBase_ErrorType) */ 01455 ); 01456 01457 /***************************************************************************/ /** 01458 * \ingroup EntitySets 01459 * \brief Destroy an 01460 *entity set 01461 * 01462 ******************************************************************************/ 01463 01464 void iMesh_destroyEntSet( iMesh_Instance instance, 01465 /**< [in] iMesh instance handle */ 01466 iBase_EntitySetHandle entity_set, 01467 /**< [in] Entity set to be destroyed */ 01468 int* err 01469 /**< [out] Returned Error status (see iBase_ErrorType) */ 01470 ); 01471 01472 /***************************************************************************/ /** 01473 * \ingroup EntitySets 01474 * \brief Return 01475 *whether a specified 01476 *set is ordered or 01477 *unordered 01478 * 01479 * Return whether a 01480 *specified set is 01481 *ordered (*is_list=1) 01482 *or unordered 01483 *(*is_list=0) 01484 ******************************************************************************/ 01485 01486 void iMesh_isList( iMesh_Instance instance, 01487 /**< [in] iMesh instance handle */ 01488 const iBase_EntitySetHandle entity_set, 01489 /**< [in] Entity set being queried */ 01490 int* is_list, 01491 /**< [out] Pointer to flag returned from function */ 01492 int* err 01493 /**< [out] Returned Error status (see iBase_ErrorType) */ 01494 ); 01495 01496 /***************************************************************************/ /** 01497 * \ingroup EntitySets 01498 * \brief Get the 01499 *number of entity 01500 *sets contained in a 01501 *set or interface 01502 * 01503 * Get the number of 01504 *entity sets 01505 *contained in a set 01506 *or interface. 01507 ******************************************************************************/ 01508 01509 void iMesh_getNumEntSets( iMesh_Instance instance, 01510 /**< [in] iMesh instance handle */ 01511 const iBase_EntitySetHandle entity_set_handle, 01512 /**< [in] Entity set being queried */ 01513 const int num_hops, 01514 /**< [in] Maximum hops from entity_set_handle to contained set, not 01515 inclusive of the contained set. \ref numhops) */ 01516 int* num_sets, 01517 /**< [out] Pointer to the number of sets returned from function */ 01518 int* err 01519 /**< [out] Returned Error status (see iBase_ErrorType) */ 01520 ); 01521 01522 /***************************************************************************/ /** 01523 * \ingroup EntitySets 01524 * \brief Get the 01525 *entity sets 01526 *contained in a set 01527 *or interface 01528 * 01529 * Get the entity sets 01530 *contained in a set 01531 *or interface. 01532 ******************************************************************************/ 01533 01534 void iMesh_getEntSets( iMesh_Instance instance, 01535 /**< [in] iMesh instance handle */ 01536 const iBase_EntitySetHandle entity_set_handle, 01537 /**< [in] Entity set being queried */ 01538 const int num_hops, 01539 /**< [in] Maximum hops from entity_set_handle to contained set, not 01540 inclusive of the contained set \ref numhops) */ 01541 iBase_EntitySetHandle** contained_set_handles, 01542 /**< [in,out] Pointer to array of set handles returned \ref trio) */ 01543 int* contained_set_handles_allocated, 01544 /**< [in,out] Pointer to allocated length of */ 01545 int* contained_set_handles_size, 01546 /**< [out] Pointer to occupied length of */ 01547 int* err 01548 /**< [out] Returned Error status (see iBase_ErrorType) */ 01549 ); 01550 01551 /***************************************************************************/ /** 01552 * \ingroup EntitySets 01553 * \brief Add an 01554 *entity to a set 01555 * 01556 ******************************************************************************/ 01557 01558 void iMesh_addEntToSet( iMesh_Instance instance, 01559 /**< [in] iMesh instance handle */ 01560 iBase_EntityHandle entity_handle, 01561 /**< [in] The entity being added */ 01562 iBase_EntitySetHandle entity_set, 01563 /**< [in] Pointer to the set being added to */ 01564 int* err 01565 /**< [out] Returned Error status (see iBase_ErrorType) */ 01566 ); 01567 01568 /***************************************************************************/ /** 01569 * \ingroup EntitySets 01570 * \brief Remove an 01571 *entity from a set 01572 * 01573 ******************************************************************************/ 01574 01575 void iMesh_rmvEntFromSet( iMesh_Instance instance, 01576 /**< [in] iMesh instance handle */ 01577 iBase_EntityHandle entity_handle, 01578 /**< [in] The entity being removed */ 01579 iBase_EntitySetHandle entity_set, 01580 /**< [in] Pointer to the set being removed from */ 01581 int* err 01582 /**< [out] Returned Error status (see iBase_ErrorType) */ 01583 ); 01584 01585 /***************************************************************************/ /** 01586 * \ingroup EntitySets 01587 * \brief Add an 01588 *array of entities to 01589 *a set 01590 * 01591 ******************************************************************************/ 01592 01593 void iMesh_addEntArrToSet( iMesh_Instance instance, 01594 /**< [in] iMesh instance handle */ 01595 const iBase_EntityHandle* entity_handles, 01596 /**< [in] Array of entities being added */ 01597 int entity_handles_size, 01598 /**< [in] Number of entities in entity_handles array */ 01599 iBase_EntitySetHandle entity_set, 01600 /**< [in] Pointer to the set being added to */ 01601 int* err 01602 /**< [out] Returned Error status (see iBase_ErrorType) */ 01603 ); 01604 01605 /***************************************************************************/ /** 01606 * \ingroup EntitySets 01607 * \brief Remove an 01608 *array of entities 01609 *from a set 01610 * 01611 ******************************************************************************/ 01612 01613 void iMesh_rmvEntArrFromSet( iMesh_Instance instance, 01614 /**< [in] iMesh instance handle */ 01615 const iBase_EntityHandle* entity_handles, 01616 /**< [in] Array of entities being remove */ 01617 int entity_handles_size, 01618 /**< [in] Number of entities in entity_handles array */ 01619 iBase_EntitySetHandle entity_set, 01620 /**< [in] Pointer to the set being removed from */ 01621 int* err 01622 /**< [out] Returned Error status (see iBase_ErrorType) */ 01623 ); 01624 01625 /***************************************************************************/ /** 01626 * \ingroup EntitySets 01627 * \brief Add an 01628 *entity set to a set 01629 * 01630 * Add an entity set 01631 *to a set (\ref 01632 *cycles) 01633 ******************************************************************************/ 01634 01635 void iMesh_addEntSet( iMesh_Instance instance, 01636 /**< [in] iMesh instance handle */ 01637 iBase_EntitySetHandle entity_set_to_add, 01638 /**< [in] The entity set being added */ 01639 iBase_EntitySetHandle entity_set_handle, 01640 /**< [in] Pointer to the set being added to */ 01641 int* err 01642 /**< [out] Returned Error status (see iBase_ErrorType) */ 01643 ); 01644 01645 /***************************************************************************/ /** 01646 * \ingroup EntitySets 01647 * \brief Remove an 01648 *entity set from a 01649 *set 01650 * 01651 * Remove an entity 01652 *set from a set 01653 ******************************************************************************/ 01654 01655 void iMesh_rmvEntSet( iMesh_Instance instance, 01656 /**< [in] iMesh instance handle */ 01657 iBase_EntitySetHandle entity_set_to_remove, 01658 /**< [in] The entity set being removed */ 01659 iBase_EntitySetHandle entity_set_handle, 01660 /**< [in] Pointer to the set being removed from */ 01661 int* err 01662 /**< [out] Returned Error status (see iBase_ErrorType) */ 01663 ); 01664 01665 /***************************************************************************/ /** 01666 * \ingroup EntitySets 01667 * \brief Return 01668 *whether an entity is 01669 *contained in another 01670 *set 01671 * 01672 * Return whether an 01673 *entity is contained 01674 *(*is_contained=1) or 01675 *not contained 01676 *(*is_contained=0) in 01677 *another set 01678 ******************************************************************************/ 01679 01680 void iMesh_isEntContained( iMesh_Instance instance, 01681 /**< [in] iMesh instance handle */ 01682 iBase_EntitySetHandle containing_entity_set, 01683 /**< [in] Entity set being queried */ 01684 iBase_EntityHandle contained_entity, 01685 /**< [in] Entity potentially contained in containing_entity_set */ 01686 int* is_contained, 01687 /**< [out] Pointer to flag returned from function */ 01688 int* err 01689 /**< [out] Returned Error status (see iBase_ErrorType) */ 01690 ); 01691 01692 /***************************************************************************/ /** 01693 * \ingroup EntitySets 01694 * \brief Return 01695 *whether entities are 01696 *contained in a set 01697 * 01698 ******************************************************************************/ 01699 01700 void iMesh_isEntArrContained( iMesh_Instance instance, 01701 /**< [in] iMesh instance handle */ 01702 iBase_EntitySetHandle containing_entity_set, 01703 /**< [in] Entity set being queried */ 01704 const iBase_EntityHandle* entity_handles, 01705 /**< [in] List of entities for which to check containment. */ 01706 int num_entity_handles, 01707 /**< [in] Size of entity_handles array of entities to be checked. */ 01708 int** is_contained, 01709 /**< [in,out] One value for each input entity, 1 if contained in set, 01710 zero otherwise. \ref trio) */ 01711 int* is_contained_allocated, 01712 /**< [in,out] Allocated size of is_contained array */ 01713 int* is_contained_size, 01714 /**< [out] Occupied size of is_contained array */ 01715 int* err 01716 /**< [out] Returned Error status (see iBase_ErrorType) */ 01717 ); 01718 01719 /***************************************************************************/ /** 01720 * \ingroup EntitySets 01721 * \brief Return 01722 *whether an entity 01723 *set is contained in 01724 *another set 01725 * 01726 * Return whether a 01727 *set is contained 01728 *(*is_contained=1) or 01729 *not contained 01730 * (*is_contained=0) 01731 *in another set 01732 ******************************************************************************/ 01733 01734 void iMesh_isEntSetContained( iMesh_Instance instance, 01735 /**< [in] iMesh instance handle */ 01736 const iBase_EntitySetHandle containing_entity_set, 01737 /**< [in] Entity set being queried */ 01738 const iBase_EntitySetHandle contained_entity_set, 01739 /**< [in] Entity set potentially contained in containing_entity_set */ 01740 int* is_contained, 01741 /**< [out] Pointer to flag returned from function */ 01742 int* err 01743 /**< [out] Returned Error status (see iBase_ErrorType) */ 01744 ); 01745 01746 /***************************************************************************/ /** 01747 * \ingroup 01748 *ParentChildLinks 01749 * \brief Add 01750 *parent/child links 01751 *between two sets 01752 * 01753 * Add parent/child 01754 *links between two 01755 *sets. Makes parent 01756 *point to child and 01757 *child point to 01758 *parent. (\ref 01759 *cycles) 01760 ******************************************************************************/ 01761 01762 void iMesh_addPrntChld( iMesh_Instance instance, 01763 /**< [in] iMesh instance handle */ 01764 iBase_EntitySetHandle parent_entity_set, 01765 /**< [in] Pointer to parent set */ 01766 iBase_EntitySetHandle child_entity_set, 01767 /**< [in] Pointer to child set */ 01768 int* err 01769 /**< [out] Returned Error status (see iBase_ErrorType) */ 01770 ); 01771 01772 /***************************************************************************/ /** 01773 * \ingroup 01774 *ParentChildLinks 01775 * \brief Remove 01776 *parent/child links 01777 *between two sets 01778 * 01779 * Remove parent/child 01780 *links between two 01781 *sets. 01782 ******************************************************************************/ 01783 01784 void iMesh_rmvPrntChld( iMesh_Instance instance, 01785 /**< [in] iMesh instance handle */ 01786 iBase_EntitySetHandle parent_entity_set, 01787 /**< [in] Pointer to parent set */ 01788 iBase_EntitySetHandle child_entity_set, 01789 /**< [in] Pointer to child set */ 01790 int* err 01791 /**< [out] Returned Error status (see iBase_ErrorType) */ 01792 ); 01793 01794 /***************************************************************************/ /** 01795 * \ingroup 01796 *ParentChildLinks 01797 * \brief Return 01798 *whether two sets are 01799 *related by 01800 *parent/child links 01801 * 01802 * Return whether two 01803 *sets are related 01804 *(*is_child=1) or not 01805 *(*is_child=0) by 01806 *parent/child links 01807 ******************************************************************************/ 01808 01809 void iMesh_isChildOf( iMesh_Instance instance, 01810 /**< [in] iMesh instance handle */ 01811 const iBase_EntitySetHandle parent_entity_set, 01812 /**< [in] Pointer to parent set */ 01813 const iBase_EntitySetHandle child_entity_set, 01814 /**< [in] Pointer to child set */ 01815 int* is_child, 01816 /**< [out] Pointer to flag returned from function */ 01817 int* err 01818 /**< [out] Returned Error status (see iBase_ErrorType) */ 01819 ); 01820 01821 /***************************************************************************/ /** 01822 * \ingroup 01823 *ParentChildLinks 01824 * \brief Get the 01825 *number of child sets 01826 *linked from a 01827 *specified set 01828 * 01829 * Get the number of 01830 *child sets linked 01831 *from a specified 01832 *set. 01833 ******************************************************************************/ 01834 01835 void iMesh_getNumChld( iMesh_Instance instance, 01836 /**< [in] iMesh instance handle */ 01837 const iBase_EntitySetHandle entity_set, 01838 /**< [in] Entity set being queried */ 01839 const int num_hops, 01840 /**< [in] Maximum hops from entity_set_handle to child set, not 01841 inclusive of the child set. \ref numhops) */ 01842 int* num_child, 01843 /**< [out] Pointer to number of children returned from function */ 01844 int* err 01845 /**< [out] Returned Error status (see iBase_ErrorType) */ 01846 ); 01847 01848 /***************************************************************************/ /** 01849 * \ingroup 01850 *ParentChildLinks 01851 * \brief Get the 01852 *number of parent 01853 *sets linked from a 01854 *specified set 01855 * 01856 * Get the number of 01857 *parent sets linked 01858 *from a specified 01859 *set. 01860 ******************************************************************************/ 01861 01862 void iMesh_getNumPrnt( iMesh_Instance instance, 01863 /**< [in] iMesh instance handle */ 01864 const iBase_EntitySetHandle entity_set, 01865 /**< [in] Entity set being queried */ 01866 const int num_hops, 01867 /**< [in] Maximum hops from entity_set_handle to parent set, not 01868 inclusive of the parent set. \ref numhops) */ 01869 int* num_parent, 01870 /**< [out] Pointer to number of parents returned from function */ 01871 int* err 01872 /**< [out] Returned Error status (see iBase_ErrorType) */ 01873 ); 01874 01875 /***************************************************************************/ /** 01876 * \ingroup 01877 *ParentChildLinks 01878 * \brief Get the 01879 *child sets linked 01880 *from a specified set 01881 * 01882 * Get the child sets 01883 *linked from a 01884 *specified set. 01885 ******************************************************************************/ 01886 01887 void iMesh_getChldn( iMesh_Instance instance, 01888 /**< [in] iMesh instance handle */ 01889 const iBase_EntitySetHandle from_entity_set, 01890 /**< [in] Entity set being queried */ 01891 const int num_hops, 01892 /**< [in] Maximum hops from entity_set_handle to child set, 01893 \ref numhops) */ 01894 iBase_EntitySetHandle** entity_set_handles, 01895 /**< [in,out] Pointer to array of child sets \ref trio) */ 01896 int* entity_set_handles_allocated, 01897 /**< [in,out] Pointer to allocated size of */ 01898 int* entity_set_handles_size, 01899 /**< [out] Pointer to occupied size of */ 01900 int* err 01901 /**< [out] Returned Error status (see iBase_ErrorType) */ 01902 ); 01903 01904 /***************************************************************************/ /** 01905 * \ingroup 01906 *ParentChildLinks 01907 * \brief Get the 01908 *parent sets linked 01909 *from a specified set 01910 * 01911 * Get the parent sets 01912 *linked from a 01913 *specified set. 01914 ******************************************************************************/ 01915 01916 void iMesh_getPrnts( iMesh_Instance instance, 01917 /**< [in] iMesh instance handle */ 01918 const iBase_EntitySetHandle from_entity_set, 01919 /**< [in] Entity set being queried */ 01920 const int num_hops, 01921 /**< [in] Maximum hops from entity_set_handle to parent set, 01922 \ref numhops) */ 01923 iBase_EntitySetHandle** entity_set_handles, 01924 /**< [in,out] Pointer to array of parent sets \ref trio) */ 01925 int* entity_set_handles_allocated, 01926 /**< [in,out] Pointer to allocated size of */ 01927 int* entity_set_handles_size, 01928 /**< [out] Pointer to occupied size of */ 01929 int* err 01930 /**< [out] Returned Error status (see iBase_ErrorType) */ 01931 ); 01932 01933 /***************************************************************************/ /** 01934 * \ingroup 01935 *VertexEntities 01936 * \brief Set 01937 *coordinates for an 01938 *array of vertices 01939 * 01940 * Set coordinates for 01941 *an array of 01942 *vertices. Specified 01943 *storage order must 01944 *be either 01945 *iBase_INTERLEAVED or 01946 *iBase_BLOCKED, and 01947 * indicates order of 01948 *x, y, and z 01949 *coordinates in 01950 *coordinate array. 01951 ******************************************************************************/ 01952 01953 void iMesh_setVtxArrCoords( iMesh_Instance instance, 01954 /**< [in] iMesh instance handle */ 01955 const iBase_EntityHandle* vertex_handles, 01956 /**< [in] Array of vertex handles */ 01957 const int vertex_handles_size, 01958 /**< [in] Number of vertex handles in array */ 01959 const int storage_order, 01960 /**< [in] Storage order of coordinates in coordinate array */ 01961 const double* new_coords, 01962 /**< [in] Coordinate array */ 01963 const int new_coords_size, 01964 /**< [in] Size of coordinate array; should be */ 01965 int* err 01966 /**< [out] Returned Error status (see iBase_ErrorType) */ 01967 ); 01968 01969 /***************************************************************************/ /** 01970 * \ingroup 01971 *VertexEntities 01972 * \brief Create an 01973 *array of new 01974 *vertices at 01975 *specified 01976 *coordinates 01977 * 01978 * Create an array of 01979 *new vertices at 01980 *specified 01981 *coordinates. Value 01982 *of storage_order 01983 *must be either 01984 *iBase_INTERLEAVED or 01985 *iBase_BLOCKED. 01986 ******************************************************************************/ 01987 01988 void iMesh_createVtxArr( iMesh_Instance instance, 01989 /**< [in] iMesh instance handle */ 01990 const int num_verts, 01991 /**< [in] Number of new vertices to be created */ 01992 const int storage_order, 01993 /**< [in] Storage order of coordinates in new_coords array 01994 (see iBase_StorageOrder) */ 01995 const double* new_coords, 01996 /**< [in] Array of coordinates of new vertices. Should be G*num_verts 01997 in length where G is geometric dimension of the mesh. */ 01998 const int new_coords_size, 01999 /**< [in] Number of coordinates in new_coords array, should */ 02000 iBase_EntityHandle** new_vertex_handles, 02001 /**< [in,out] Pointer to array of new vertex handles \ref trio) */ 02002 int* new_vertex_handles_allocated, 02003 /**< [in,out] Pointer to allocated size of */ 02004 int* new_vertex_handles_size, 02005 /**< [out] Pointer to occupied size of */ 02006 int* err 02007 /**< [out] Returned Error status (see iBase_ErrorType) */ 02008 ); 02009 02010 /***************************************************************************/ /** 02011 * \ingroup Entities 02012 * \brief Create an 02013 *array of new 02014 *entities with 02015 *specified 02016 *lower-order topology 02017 * 02018 * Create an array of 02019 *new entities with 02020 *specified 02021 *lower-order 02022 *topology. Specified 02023 *new_entity_topology 02024 *must be value in 02025 *iMesh_EntityTopology 02026 * enumeration. Values 02027 *return in status 02028 *array must be values 02029 *in the 02030 * iBase_CreationStatus 02031 *enumeration. 02032 ******************************************************************************/ 02033 02034 void iMesh_createEntArr( iMesh_Instance instance, 02035 /**< [in] iMesh instance handle */ 02036 const int new_entity_topology, 02037 /**< [in] Topology of created entity */ 02038 const iBase_EntityHandle* lower_order_entity_handles, 02039 /**< [in] Array of lower order entity handles to be used to construct 02040 new entities */ 02041 const int lower_order_entity_handles_size, 02042 /**< [in] Number of entities in lower_order_entity_handles array */ 02043 iBase_EntityHandle** new_entity_handles, 02044 /**< [in,out] Pointer to array of new_entity_handles 02045 \ref trio) */ 02046 int* new_entity_handles_allocated, 02047 /**< [in,out] Pointer to allocated size of */ 02048 int* new_entity_handles_size, 02049 /**< [out] Pointer to occupied size of */ 02050 int** status, 02051 /**< [in,out] Pointer to array of creation status returned from 02052 \ref trio) (see iBase_CreationStatus) */ 02053 int* status_allocated, 02054 /**< [in,out] Pointer to allocated size of status array */ 02055 int* status_size, 02056 /**< [out] Pointer to occupied size of status array */ 02057 int* err 02058 /**< [out] Returned Error status (see iBase_ErrorType) */ 02059 ); 02060 02061 /***************************************************************************/ /** 02062 * \ingroup Entities 02063 * \brief Delete 02064 *specified entities 02065 * 02066 * Delete specified 02067 *entities 02068 ******************************************************************************/ 02069 02070 void iMesh_deleteEntArr( iMesh_Instance instance, 02071 /**< [in] iMesh instance handle */ 02072 const iBase_EntityHandle* entity_handles, 02073 /**< [in] Array of entity handles to be deleted */ 02074 const int entity_handles_size, 02075 /**< [in] Number of entities in array to be deleted */ 02076 int* err 02077 /**< [out] Returned Error status (see iBase_ErrorType) */ 02078 ); 02079 02080 /***************************************************************************/ /** 02081 * \ingroup Tags 02082 * \brief Create a 02083 *tag with specified 02084 *name, size, and type 02085 * 02086 * Create a tag with 02087 *specified name, 02088 *size, and type. Tag 02089 *size is in units of 02090 *size of tag_type 02091 *data types. Value 02092 *input for tag type 02093 *must be value in 02094 *iBase_TagType 02095 *enumeration. 02096 ******************************************************************************/ 02097 02098 void iMesh_createTag( iMesh_Instance instance, 02099 /**< [in] iMesh instance handle */ 02100 const char* tag_name, 02101 /**< [in] Character string indicating tag name */ 02102 const int tag_size, 02103 /**< [in] Size of each tag value, in units of number of 02104 tag_type datums. */ 02105 const int tag_type, 02106 /**< [in] Data type for data stored in this tag */ 02107 iBase_TagHandle* tag_handle, 02108 /**< [out] Pointer to tag handle returned from function */ 02109 int* err, 02110 /**< [out] Returned Error status (see iBase_ErrorType) */ 02111 const int tag_name_len 02112 /**< [in] Length of tag name string (\ref strlen) */ 02113 ); 02114 02115 /***************************************************************************/ /** 02116 * \ingroup Tags 02117 * \brief Destroy a 02118 *tag 02119 * 02120 * Destroy a tag. If 02121 *forced is non-zero 02122 *and entities still 02123 *have values set for 02124 *this tag, tag is 02125 *deleted anyway and 02126 *those values 02127 *disappear, otherwise 02128 *tag is not deleted. 02129 ******************************************************************************/ 02130 02131 void iMesh_destroyTag( iMesh_Instance instance, 02132 /**< [in] iMesh instance handle */ 02133 iBase_TagHandle tag_handle, 02134 /**< [in] Handle of tag to be deleted */ 02135 const int forced, 02136 /**< [in] If non-zero, delete the tag even if entities have values set 02137 for the tag. */ 02138 int* err 02139 /**< [out] Returned Error status (see iBase_ErrorType) */ 02140 ); 02141 02142 /***************************************************************************/ /** 02143 * \ingroup Tags 02144 * \brief Get the 02145 *name for a given tag 02146 *handle 02147 * 02148 * Get the name for a 02149 *given tag handle 02150 ******************************************************************************/ 02151 02152 void iMesh_getTagName( iMesh_Instance instance, 02153 /**< [in] iMesh instance handle */ 02154 const iBase_TagHandle tag_handle, 02155 /**< [in] Tag handle being queried */ 02156 char* name, 02157 /**< [in,out] Pointer to character string to store name returned from */ 02158 int* err, 02159 /**< [out] Returned Error status (see iBase_ErrorType) */ 02160 int name_len 02161 /**< [in] Length of character string input to function 02162 (\ref strlen) */ 02163 ); 02164 02165 /***************************************************************************/ /** 02166 * \ingroup Tags 02167 * \brief Get size of 02168 *a tag in units of 02169 *numbers of tag data 02170 *type 02171 * 02172 * Get size of a tag 02173 *in units of numbers 02174 *of tag data type 02175 ******************************************************************************/ 02176 02177 void iMesh_getTagSizeValues( iMesh_Instance instance, 02178 /**< [in] iMesh instance handle */ 02179 const iBase_TagHandle tag_handle, 02180 /**< [in] Handle of tag being queried */ 02181 int* tag_size, 02182 /**< [out] Pointer to tag size returned from function */ 02183 int* err 02184 /**< [out] Returned Error status (see iBase_ErrorType) */ 02185 ); 02186 02187 /***************************************************************************/ /** 02188 * \ingroup Tags 02189 * \brief Get size of 02190 *a tag in units of 02191 *bytes 02192 * 02193 * Get size of a tag 02194 *in units of bytes 02195 ******************************************************************************/ 02196 02197 void iMesh_getTagSizeBytes( iMesh_Instance instance, 02198 /**< [in] iMesh instance handle */ 02199 const iBase_TagHandle tag_handle, 02200 /**< [in] Handle of tag being queried */ 02201 int* tag_size, 02202 /**< [out] Pointer to tag size returned from function */ 02203 int* err 02204 /**< [out] Returned Error status (see iBase_ErrorType) */ 02205 ); 02206 02207 /***************************************************************************/ /** 02208 * \ingroup Tags 02209 * \brief Get a the 02210 *handle of an 02211 *existing tag with 02212 *the specified name 02213 * 02214 * Get a the handle of 02215 *an existing tag with 02216 *the specified name 02217 ******************************************************************************/ 02218 02219 void iMesh_getTagHandle( iMesh_Instance instance, 02220 /**< [in] iMesh instance handle */ 02221 const char* tag_name, 02222 /**< [in] Name of tag being queried */ 02223 iBase_TagHandle* tag_handle, 02224 /**< [out] Pointer to tag handle returned from function */ 02225 int* err, 02226 /**< [out] Returned Error status (see iBase_ErrorType) */ 02227 int tag_name_len 02228 /**< [in] Length of tag name string (\ref strlen) */ 02229 ); 02230 02231 /***************************************************************************/ /** 02232 * \ingroup Tags 02233 * \brief Get the 02234 *data type of the 02235 *specified tag handle 02236 * 02237 * Get the data type 02238 *of the specified tag 02239 *handle. Tag type is 02240 *a value in the 02241 *iBase_TagType 02242 *enumeration. 02243 ******************************************************************************/ 02244 02245 void iMesh_getTagType( iMesh_Instance instance, 02246 /**< [in] iMesh instance handle */ 02247 const iBase_TagHandle tag_handle, 02248 /**< [in] Handle for the tag being queried */ 02249 int* tag_type, 02250 /**< [out] Pointer to tag type returned from function */ 02251 int* err 02252 /**< [out] Returned Error status (see iBase_ErrorType) */ 02253 ); 02254 02255 /***************************************************************************/ /** 02256 * \ingroup TagsOnSets 02257 * \brief Set a tag 02258 *value of arbitrary 02259 *type on an entity 02260 *set 02261 * 02262 * Set a tag value of 02263 *arbitrary type on an 02264 *entity set. The tag 02265 *data is passed as 02266 *void*. 02267 *tag_value_size 02268 *specifies the size 02269 *of the memory 02270 * pointed to by 02271 *tag_value in terms 02272 *of bytes. 02273 *Applications are 02274 *free to use this 02275 *function to set data 02276 *of any type, not 02277 *just iBase_BYTES. 02278 * However, in all 02279 *cases, the size 02280 *specified by 02281 *tag_value_size is 02282 * always in terms of 02283 *bytes. 02284 ******************************************************************************/ 02285 02286 void iMesh_setEntSetData( iMesh_Instance instance, 02287 /**< [in] iMesh instance handle */ 02288 iBase_EntitySetHandle entity_set_handle, 02289 /**< [in] Entity set on which tag is being set */ 02290 const iBase_TagHandle tag_handle, 02291 /**< [in] Tag being set on an entity set */ 02292 const void* tag_value, 02293 /**< [in] Pointer to tag data being set on entity set */ 02294 const int tag_value_size, 02295 /**< [in] Size in bytes of tag data */ 02296 int* err 02297 /**< [out] Returned Error status (see iBase_ErrorType) */ 02298 ); 02299 02300 /***************************************************************************/ /** 02301 * \ingroup TagsOnSets 02302 * \brief Set a tag 02303 *value of integer 02304 *type on an entity 02305 *set 02306 * 02307 * Set a tag value of 02308 *integer type on an 02309 *entity set. 02310 ******************************************************************************/ 02311 02312 void iMesh_setEntSetIntData( iMesh_Instance instance, 02313 /**< [in] iMesh instance handle */ 02314 iBase_EntitySetHandle entity_set, 02315 /**< [in] Entity set on which tag is being set */ 02316 const iBase_TagHandle tag_handle, 02317 /**< [in] Tag being set on an entity set */ 02318 const int tag_value, 02319 /**< [in] Tag value being set on entity set */ 02320 int* err 02321 /**< [out] Returned Error status (see iBase_ErrorType) */ 02322 ); 02323 02324 /***************************************************************************/ /** 02325 * \ingroup TagsOnSets 02326 * \brief Set a tag 02327 *value of double type 02328 *on an entity set 02329 * 02330 * Set a tag value of 02331 *double type on an 02332 *entity set. 02333 ******************************************************************************/ 02334 02335 void iMesh_setEntSetDblData( iMesh_Instance instance, 02336 /**< [in] iMesh instance handle */ 02337 iBase_EntitySetHandle entity_set, 02338 /**< [in] Entity set on which tag is being set */ 02339 const iBase_TagHandle tag_handle, 02340 /**< [in] Tag being set on an entity set */ 02341 const double tag_value, 02342 /**< [in] Tag value being set on entity set */ 02343 int* err 02344 /**< [out] Returned Error status (see iBase_ErrorType) */ 02345 ); 02346 02347 /***************************************************************************/ /** 02348 * \ingroup TagsOnSets 02349 * \brief Set a tag 02350 *value of entity 02351 *handle type on an 02352 *entity set 02353 * 02354 * Set a tag value of 02355 *entity handle type 02356 *on an entity set. 02357 ******************************************************************************/ 02358 02359 void iMesh_setEntSetEHData( iMesh_Instance instance, 02360 /**< [in] iMesh instance handle */ 02361 iBase_EntitySetHandle entity_set, 02362 /**< [in] Entity set on which tag is being set */ 02363 const iBase_TagHandle tag_handle, 02364 /**< [in] Tag being set on an entity set */ 02365 const iBase_EntityHandle tag_value, 02366 /**< [in] Tag value being set on entity set */ 02367 int* err 02368 /**< [out] Returned Error status (see iBase_ErrorType) */ 02369 ); 02370 02371 /***************************************************************************/ /** 02372 * \ingroup TagsOnSets 02373 * \brief Set a tag 02374 *value of entity set 02375 *handle type on an 02376 * 02377 * entity set 02378 * Set a tag value of 02379 *entity set handle 02380 *type on an entity 02381 *set. 02382 ******************************************************************************/ 02383 02384 void iMesh_setEntSetESHData( iMesh_Instance instance, 02385 /**< [in] iMesh instance handle */ 02386 iBase_EntitySetHandle entity_set, 02387 /**< [in] Entity set on which tag is being set */ 02388 const iBase_TagHandle tag_handle, 02389 /**< [in] Tag being set on an entity set */ 02390 const iBase_EntitySetHandle tag_value, 02391 /**< [in] Tag value being set on entity set */ 02392 int* err 02393 /**< [out] Returned Error status (see iBase_ErrorType) */ 02394 ); 02395 02396 /***************************************************************************/ /** 02397 * \ingroup TagsOnSets 02398 * \brief Get the 02399 *value of a tag of 02400 *arbitrary type on an 02401 *entity set 02402 * 02403 * Get the value of a 02404 *tag of arbitrary 02405 *type on an entity 02406 *set. Tag data is 02407 *returned back as 02408 *void*. 02409 *tag_value_size 02410 *specifies the size 02411 *of the memory 02412 *pointed to by 02413 *tag_value in terms 02414 *of bytes. 02415 *Applications may use 02416 *this function to get 02417 *data of any type, 02418 *not just 02419 *iBase_BYTES. However 02420 *because this 02421 *function supports 02422 *data of arbitrary 02423 *type, in all cases 02424 *the size specified 02425 *by tag_value_size is 02426 *always in terms of 02427 *bytes. 02428 ******************************************************************************/ 02429 02430 void iMesh_getEntSetData( iMesh_Instance instance, 02431 /**< [in] iMesh instance handle */ 02432 const iBase_EntitySetHandle entity_set_handle, 02433 /**< [in] Entity set on which tag is being set */ 02434 const iBase_TagHandle tag_handle, 02435 /**< [in] Tag being set on an entity set */ 02436 void* tag_value, 02437 /**< [in,out] Pointer to tag data array being queried 02438 \ref trio) */ 02439 int* tag_value_allocated, 02440 /**< [in,out] Pointer allocated size, in bytes, of tag_value array. */ 02441 int* tag_value_size, 02442 /**< [out] Pointer to occupied size, in bytes, of tag_value array. */ 02443 int* err 02444 /**< [out] Returned Error status (see iBase_ErrorType) */ 02445 ); 02446 02447 /***************************************************************************/ /** 02448 * \ingroup TagsOnSets 02449 * \brief Get the 02450 *value of a tag of 02451 *integer type on an 02452 *entity set 02453 * 02454 * Get the value of a 02455 *tag of integer type 02456 *on an entity set. 02457 ******************************************************************************/ 02458 02459 void iMesh_getEntSetIntData( iMesh_Instance instance, 02460 /**< [in] iMesh instance handle */ 02461 const iBase_EntitySetHandle entity_set, 02462 /**< [in] Entity set on which tag is being set */ 02463 const iBase_TagHandle tag_handle, 02464 /**< [in] Tag being set on an entity set */ 02465 int* out_data, 02466 /**< [out] Pointer to tag value returned from function */ 02467 int* err 02468 /**< [out] Returned Error status (see iBase_ErrorType) */ 02469 ); 02470 02471 /***************************************************************************/ /** 02472 * \ingroup TagsOnSets 02473 * \brief Get the 02474 *value of a tag of 02475 *double type on an 02476 *entity set 02477 * 02478 * Get the value of a 02479 *tag of double type 02480 *on an entity set. 02481 ******************************************************************************/ 02482 02483 void iMesh_getEntSetDblData( iMesh_Instance instance, 02484 /**< [in] iMesh instance handle */ 02485 const iBase_EntitySetHandle entity_set, 02486 /**< [in] Entity set on which tag is being set */ 02487 const iBase_TagHandle tag_handle, 02488 /**< [in] Tag being set on an entity set */ 02489 double* out_data, 02490 /**< [out] Pointer to tag value returned from function */ 02491 int* err 02492 /**< [out] Returned Error status (see iBase_ErrorType) */ 02493 ); 02494 02495 /***************************************************************************/ /** 02496 * \ingroup TagsOnSets 02497 * \brief Get the 02498 *value of a tag of 02499 *entity handle type 02500 *on an entity set 02501 * 02502 * Get the value of a 02503 *tag of entity handle 02504 *type on an entity 02505 *set. 02506 ******************************************************************************/ 02507 02508 void iMesh_getEntSetEHData( iMesh_Instance instance, 02509 /**< [in] iMesh instance handle */ 02510 const iBase_EntitySetHandle entity_set, 02511 /**< [in] Entity set on which tag is being set */ 02512 const iBase_TagHandle tag_handle, 02513 /**< [in] Tag being set on an entity set */ 02514 iBase_EntityHandle* out_data, 02515 /**< [out] Pointer to tag value returned from function */ 02516 int* err 02517 /**< [out] Returned Error status (see iBase_ErrorType) */ 02518 ); 02519 02520 /***************************************************************************/ /** 02521 * \ingroup TagsOnSets 02522 * \brief Get the 02523 *value of a tag of 02524 *entity set handle 02525 *type on an 02526 * 02527 * entity set 02528 * Get the value of a 02529 *tag of entity set 02530 *handle type on an 02531 *entity set. 02532 ******************************************************************************/ 02533 02534 void iMesh_getEntSetESHData( iMesh_Instance instance, 02535 /**< [in] iMesh instance handle */ 02536 const iBase_EntitySetHandle entity_set, 02537 /**< [in] Entity set on which tag is being set */ 02538 const iBase_TagHandle tag_handle, 02539 /**< [in] Tag being set on an entity set */ 02540 iBase_EntitySetHandle* out_data, 02541 /**< [out] Pointer to tag value returned from function */ 02542 int* err 02543 /**< [out] Returned Error status (see iBase_ErrorType) */ 02544 ); 02545 02546 /***************************************************************************/ /** 02547 * \ingroup Tags 02548 * \brief Get all the 02549 *tags associated with 02550 *a specified entity 02551 *set 02552 * 02553 * Get all the tags 02554 *associated with a 02555 *specified entity set 02556 ******************************************************************************/ 02557 02558 void iMesh_getAllEntSetTags( iMesh_Instance instance, 02559 /**< [in] iMesh instance handle */ 02560 const iBase_EntitySetHandle entity_set_handle, 02561 /**< [in] Entity being queried */ 02562 iBase_TagHandle** tag_handles, 02563 /**< [in,out] Pointer to array of tag_handles returned from 02564 \ref trio) */ 02565 int* tag_handles_allocated, 02566 /**< [in,out] Pointer to allocated size of tag_handles */ 02567 int* tag_handles_size, 02568 /**< [out] Pointer to occupied size of tag_handles array */ 02569 int* err 02570 /**< [out] Returned Error status (see iBase_ErrorType) */ 02571 ); 02572 02573 /***************************************************************************/ /** 02574 * \ingroup Tags 02575 * \brief Remove a 02576 *tag value from an 02577 *entity set 02578 * 02579 * Remove a tag value 02580 *from an entity set 02581 ******************************************************************************/ 02582 02583 void iMesh_rmvEntSetTag( iMesh_Instance instance, 02584 /**< [in] iMesh instance handle */ 02585 iBase_EntitySetHandle entity_set_handle, 02586 /**< [in] Entity set from which tag is being removed */ 02587 const iBase_TagHandle tag_handle, 02588 /**< [in] Tag handle of tag being removed */ 02589 int* err 02590 /**< [out] Returned Error status (see iBase_ErrorType) */ 02591 ); 02592 02593 /***************************************************************************/ /** 02594 * \ingroup 02595 *VertexEntities 02596 * \brief Set 02597 *coordinates for a 02598 *vertex 02599 * 02600 * Set coordinates for 02601 *a vertex. 02602 ******************************************************************************/ 02603 02604 void iMesh_setVtxCoord( iMesh_Instance instance, 02605 /**< [in] iMesh instance handle */ 02606 iBase_EntityHandle vertex_handle, 02607 /**< [in] vertex handle being set */ 02608 const double x, 02609 /**< [in] x coordinate being set */ 02610 const double y, 02611 /**< [in] y coordinate being set */ 02612 const double z, 02613 /**< [in] z coordinate being set */ 02614 int* err 02615 /**< [out] Returned Error status (see iBase_ErrorType) */ 02616 ); 02617 02618 /***************************************************************************/ /** 02619 * \ingroup 02620 *VertexEntities 02621 * \brief Create a 02622 *new vertex at 02623 *specified 02624 *coordinates 02625 * 02626 * Create a new vertex 02627 *at specified 02628 *coordinates. 02629 ******************************************************************************/ 02630 02631 void iMesh_createVtx( iMesh_Instance instance, 02632 /**< [in] iMesh instance handle */ 02633 const double x, 02634 /**< [in] x coordinate of new vertex */ 02635 const double y, 02636 /**< [in] y coordinate of new vertex */ 02637 const double z, 02638 /**< [in] z coordinate of new vertex */ 02639 iBase_EntityHandle* new_vertex_handle, 02640 /**< [out] Pointer to new vertex handles returned from */ 02641 int* err 02642 /**< [out] Returned Error status (see iBase_ErrorType) */ 02643 ); 02644 02645 /***************************************************************************/ /** 02646 * \ingroup Entities 02647 * \brief Create a 02648 *new entity with 02649 *specified 02650 *lower-order topology 02651 * 02652 * Create a new entity 02653 *with specified 02654 *lower-order 02655 *topology. Specified 02656 *new_entity_topology 02657 *must be value in 02658 *iMesh_EntityTopology 02659 * enumeration. Value 02660 *returned as status 02661 *must be a value in 02662 *the 02663 * iBase_CreationStatus 02664 *enumeration. 02665 ******************************************************************************/ 02666 02667 void iMesh_createEnt( iMesh_Instance instance, 02668 /**< [in] iMesh instance handle */ 02669 const int new_entity_topology, 02670 /**< [in] Topology of created entity */ 02671 const iBase_EntityHandle* lower_order_entity_handles, 02672 /**< [in] Array of lower order entity handles to be used to construct 02673 new entity. */ 02674 const int lower_order_entity_handles_size, 02675 /**< [in] Number of entities in lower_order_entity_handles array */ 02676 iBase_EntityHandle* new_entity_handle, 02677 /**< [out] Pointer to new entity handle returned from */ 02678 int* status, 02679 /**< [out] Pointer to creation status returned from function 02680 (see iBase_CreationStatus) */ 02681 int* err 02682 /**< [out] Returned Error status (see iBase_ErrorType) */ 02683 ); 02684 02685 /***************************************************************************/ /** 02686 * \ingroup Entities 02687 * \brief Delete 02688 *specified entity 02689 * 02690 * Delete specified 02691 *entity 02692 ******************************************************************************/ 02693 02694 void iMesh_deleteEnt( iMesh_Instance instance, 02695 /**< [in] iMesh instance handle */ 02696 iBase_EntityHandle entity_handle, 02697 /**< [in] Entity to be deleted */ 02698 int* err 02699 /**< [out] Returned Error status (see iBase_ErrorType) */ 02700 ); 02701 02702 /***************************************************************************/ /** 02703 * \ingroup TagsOnArr 02704 * \brief Get tag 02705 *values of arbitrary 02706 *type for an array of 02707 *entities 02708 * 02709 * Get tag values of 02710 *arbitrary type for 02711 *an array of 02712 *entities. Tag data 02713 * is returned as 02714 *void*. 02715 *tag_values_size 02716 *specifies the size 02717 *of the memory 02718 *pointed to by 02719 *tag_values in terms 02720 *of bytes. 02721 *Applications may use 02722 *this function to get 02723 *data of any type, 02724 *not just 02725 *iBase_BYTES. 02726 * However, because 02727 *this function 02728 *supports data of 02729 *arbitrary type, in 02730 * all cases the size 02731 *specified by 02732 *tag_values_size 02733 *always in terms of 02734 * bytes. 02735 ******************************************************************************/ 02736 02737 void iMesh_getArrData( iMesh_Instance instance, 02738 /**< [in] iMesh instance handle */ 02739 const iBase_EntityHandle* entity_handles, 02740 /**< [in] Entity array on which tag is being set */ 02741 const int entity_handles_size, 02742 /**< [in] Number of entities in array */ 02743 const iBase_TagHandle tag_handle, 02744 /**< [in] Tag being set on an entity */ 02745 void* tag_values, 02746 /**< [in,out] Pointer to tag data array being returned. Note that the 02747 implicit INTERLEAVED storage order rule applies 02748 (see iBase_StorageOrder) \ref trio) */ 02749 int* tag_values_allocated, 02750 /**< [in,out] Pointer to allocated size of tag data array */ 02751 int* tag_values_size, 02752 /**< [out] Pointer to occupied size in bytes of tag data */ 02753 int* err 02754 /**< [out] Returned Error status (see iBase_ErrorType) */ 02755 ); 02756 02757 /***************************************************************************/ /** 02758 * \ingroup TagsOnArr 02759 * \brief Get tag 02760 *values of integer 02761 *type for an array of 02762 *entities 02763 * 02764 * Get tag values of 02765 *integer type for an 02766 *array of entities. 02767 ******************************************************************************/ 02768 02769 void iMesh_getIntArrData( iMesh_Instance instance, 02770 /**< [in] iMesh instance handle */ 02771 const iBase_EntityHandle* entity_handles, 02772 /**< [in] Entity array on which tag is being set */ 02773 const int entity_handles_size, 02774 /**< [in] Number of entities in array */ 02775 const iBase_TagHandle tag_handle, 02776 /**< [in] Tag being set on an entity */ 02777 int** tag_values, 02778 /**< [in,out] Pointer to tag data array being returned. Note that the 02779 implicit INTERLEAVED storage order rule applies 02780 (see iBase_StorageOrder) \ref trio) */ 02781 int* tag_values_allocated, 02782 /**< [in,out] Pointer to allocated size of tag data array */ 02783 int* tag_values_size, 02784 /**< [out] Pointer to occupied size of tag data array */ 02785 int* err 02786 /**< [out] Returned Error status (see iBase_ErrorType) */ 02787 ); 02788 02789 /***************************************************************************/ /** 02790 * \ingroup TagsOnArr 02791 * \brief Get tag 02792 *values of double 02793 *type for an array of 02794 *entities 02795 * 02796 * Get tag values of 02797 *double type for an 02798 *array of entities. 02799 ******************************************************************************/ 02800 02801 void iMesh_getDblArrData( iMesh_Instance instance, 02802 /**< [in] iMesh instance handle */ 02803 const iBase_EntityHandle* entity_handles, 02804 /**< [in] Entity array on which tag is being set */ 02805 const int entity_handles_size, 02806 /**< [in] Number of entities in array */ 02807 const iBase_TagHandle tag_handle, 02808 /**< [in] Tag being set on an entity */ 02809 double** tag_values, 02810 /**< [in,out] Pointer to tag data array being returned. Note that the 02811 implicit INTERLEAVED storage order rule applies 02812 (see iBase_StorageOrder) \ref trio) */ 02813 int* tag_values_allocated, 02814 /**< [in,out] Pointer to allocated size of tag data array */ 02815 int* tag_values_size, 02816 /**< [out] Pointer to occupied size of tag data array */ 02817 int* err 02818 /**< [out] Returned Error status (see iBase_ErrorType) */ 02819 ); 02820 02821 /***************************************************************************/ /** 02822 * \ingroup TagsOnArr 02823 * \brief Get tag 02824 *values of entity 02825 *handle type for an 02826 *array of entities 02827 * 02828 * Get tag values of 02829 *entity handle type 02830 *for an array of 02831 *entities. 02832 ******************************************************************************/ 02833 02834 void iMesh_getEHArrData( iMesh_Instance instance, 02835 /**< [in] iMesh instance handle */ 02836 const iBase_EntityHandle* entity_handles, 02837 /**< [in] Entity array on which tag is being set */ 02838 const int entity_handles_size, 02839 /**< [in] Number of entities in array */ 02840 const iBase_TagHandle tag_handle, 02841 /**< [in] Tag being set on an entity */ 02842 iBase_EntityHandle** tag_value, 02843 /**< [in,out] Pointer to tag data array being returned. Note that the 02844 implicit INTERLEAVED storage order rule applies 02845 (see iBase_StorageOrder) \ref trio) */ 02846 int* tag_value_allocated, 02847 /**< [in,out] Pointer to allocated size of tag data array */ 02848 int* tag_value_size, 02849 /**< [out] Pointer to occupied size of tag data array */ 02850 int* err 02851 /**< [out] Returned Error status (see iBase_ErrorType) */ 02852 ); 02853 02854 /***************************************************************************/ /** 02855 * \ingroup TagsOnArr 02856 * \brief Get tag 02857 *values of entity set 02858 *handle type for an 02859 *array of 02860 * 02861 * entities 02862 * Get tag values of 02863 *entity set handle 02864 *type for an array of 02865 *entities. 02866 ******************************************************************************/ 02867 02868 void iMesh_getESHArrData( iMesh_Instance instance, 02869 /**< [in] iMesh instance handle */ 02870 const iBase_EntityHandle* entity_handles, 02871 /**< [in] Entity array on which tag is being set */ 02872 const int entity_handles_size, 02873 /**< [in] Number of entities in array */ 02874 const iBase_TagHandle tag_handle, 02875 /**< [in] Tag being set on an entity */ 02876 iBase_EntitySetHandle** tag_value, 02877 /**< [in,out] Pointer to tag data array being returned. Note that the 02878 implicit INTERLEAVED storage order rule applies 02879 (see iBase_StorageOrder) \ref trio) */ 02880 int* tag_value_allocated, 02881 /**< [in,out] Pointer to allocated size of tag data array */ 02882 int* tag_value_size, 02883 /**< [out] Pointer to occupied size of tag data array */ 02884 int* err 02885 /**< [out] Returned Error status (see iBase_ErrorType) */ 02886 ); 02887 02888 /***************************************************************************/ /** 02889 * \ingroup TagsOnArr 02890 * \brief Set tag 02891 *values of arbitrary 02892 *type on an array of 02893 *entities 02894 * 02895 * Set tag values of 02896 *arbitrary type on an 02897 *array of entities. 02898 *Tag data is passed 02899 *as void*. 02900 *tag_values_size 02901 *specifies the size 02902 *of the memory 02903 *pointed to by 02904 *tag_values in terms 02905 *of bytes. 02906 *Applications may use 02907 *this function to set 02908 *data of any type, 02909 *not just 02910 *iBase_BYTES. 02911 * However, because 02912 *this function 02913 *supports data of 02914 *arbitrary type, in 02915 *all cases the size 02916 *specified by 02917 *tag_values_size is 02918 *always in terms of 02919 * bytes. 02920 ******************************************************************************/ 02921 02922 void iMesh_setArrData( iMesh_Instance instance, 02923 /**< [in] iMesh instance handle */ 02924 const iBase_EntityHandle* entity_handles, 02925 /**< [in] Entity array on which tag is being set */ 02926 const int entity_handles_size, 02927 /**< [in] Number of entities in array */ 02928 const iBase_TagHandle tag_handle, 02929 /**< [in] Tag being set on an entity */ 02930 const void* tag_values, 02931 /**< [in] Pointer to tag data being set on entity. Note that the 02932 implicit INTERLEAVED storage order rule applies 02933 (see iBase_StorageOrder) */ 02934 const int tag_values_size, 02935 /**< [in] Size in bytes of tag data */ 02936 int* err 02937 /**< [out] Returned Error status (see iBase_ErrorType) */ 02938 ); 02939 02940 /***************************************************************************/ /** 02941 * \ingroup TagsOnArr 02942 * \brief Set tag 02943 *values of integer 02944 *type on an array of 02945 *entities 02946 * 02947 * Set tag values of 02948 *integer type on an 02949 *array of entities. 02950 ******************************************************************************/ 02951 02952 void iMesh_setIntArrData( iMesh_Instance instance, 02953 /**< [in] iMesh instance handle */ 02954 const iBase_EntityHandle* entity_handles, 02955 /**< [in] Entity array on which tag is being set */ 02956 const int entity_handles_size, 02957 /**< [in] Number of entities in array */ 02958 const iBase_TagHandle tag_handle, 02959 /**< [in] Tag being set on an entity */ 02960 const int* tag_values, 02961 /**< [in] Pointer to tag data being set on entities. Note that the 02962 implicit INTERLEAVED storage order rule applies 02963 (see iBase_StorageOrder) */ 02964 const int tag_values_size, 02965 /**< [in] Size in total number of integers of tag data */ 02966 int* err 02967 /**< [out] Returned Error status (see iBase_ErrorType) */ 02968 ); 02969 02970 /***************************************************************************/ /** 02971 * \ingroup TagsOnArr 02972 * \brief Set tag 02973 *values of double 02974 *type on an array of 02975 *entities 02976 * 02977 * Set tag values of 02978 *double type on an 02979 *array of entities. 02980 ******************************************************************************/ 02981 02982 void iMesh_setDblArrData( iMesh_Instance instance, 02983 /**< [in] iMesh instance handle */ 02984 const iBase_EntityHandle* entity_handles, 02985 /**< [in] Entity array on which tag is being set */ 02986 const int entity_handles_size, 02987 /**< [in] Number of entities in array */ 02988 const iBase_TagHandle tag_handle, 02989 /**< [in] Tag being set on an entity */ 02990 const double* tag_values, 02991 /**< [in] Pointer to tag data being set on entities. Note that the 02992 implicit INTERLEAVED storage order rule applies 02993 (see iBase_StorageOrder) */ 02994 const int tag_values_size, 02995 /**< [in] Size in total number of doubles of tag data */ 02996 int* err 02997 /**< [out] Returned Error status (see iBase_ErrorType) */ 02998 ); 02999 03000 /***************************************************************************/ /** 03001 * \ingroup TagsOnArr 03002 * \brief Set tag 03003 *values of entity 03004 *handle type on an 03005 *array of entities 03006 * 03007 * Set tag values of 03008 *entity handle type 03009 *on an array of 03010 *entities. 03011 ******************************************************************************/ 03012 03013 void iMesh_setEHArrData( iMesh_Instance instance, 03014 /**< [in] iMesh instance handle */ 03015 const iBase_EntityHandle* entity_handles, 03016 /**< [in] Entity array on which tag is being set */ 03017 const int entity_handles_size, 03018 /**< [in] Number of entities in array */ 03019 const iBase_TagHandle tag_handle, 03020 /**< [in] Tag being set on an entity */ 03021 const iBase_EntityHandle* tag_values, 03022 /**< [in] Pointer to tag data being set on entities. Note that the 03023 implicit INTERLEAVED storage order rule applies 03024 (see iBase_StorageOrder) */ 03025 const int tag_values_size, 03026 /**< [in] Size in total number of entity handles of tag */ 03027 int* err 03028 /**< [out] Returned Error status (see iBase_ErrorType) */ 03029 ); 03030 03031 /***************************************************************************/ /** 03032 * \ingroup TagsOnArr 03033 * \brief Set tag 03034 *values of entity set 03035 *handle type on an 03036 *array of 03037 * 03038 * entities 03039 * Set tag values of 03040 *entity set handle 03041 *type on an array of 03042 *entities. 03043 ******************************************************************************/ 03044 03045 void iMesh_setESHArrData( iMesh_Instance instance, 03046 /**< [in] iMesh instance handle */ 03047 const iBase_EntityHandle* entity_handles, 03048 /**< [in] Entity array on which tag is being set */ 03049 const int entity_handles_size, 03050 /**< [in] Number of entities in array */ 03051 const iBase_TagHandle tag_handle, 03052 /**< [in] Tag being set on an entity */ 03053 const iBase_EntitySetHandle* tag_values, 03054 /**< [in] Pointer to tag data being set on entities. Note that the 03055 implicit INTERLEAVED storage order rule applies 03056 (see iBase_StorageOrder) */ 03057 const int tag_values_size, 03058 /**< [in] Size in total number of entity handles of tag */ 03059 int* err 03060 /**< [out] Returned Error status (see iBase_ErrorType) */ 03061 ); 03062 03063 /***************************************************************************/ /** 03064 * \ingroup Tags 03065 * \brief Remove a 03066 *tag value from an 03067 *array of entities 03068 * 03069 * Remove a tag value 03070 *from an array of 03071 *entities 03072 ******************************************************************************/ 03073 03074 void iMesh_rmvArrTag( iMesh_Instance instance, 03075 /**< [in] iMesh instance handle */ 03076 const iBase_EntityHandle* entity_handles, 03077 /**< [in] Entity from which tag is being removed */ 03078 const int entity_handles_size, 03079 /**< [in] Number of entities in entity array */ 03080 const iBase_TagHandle tag_handle, 03081 /**< [in] Tag handle of tag being removed */ 03082 int* err 03083 /**< [out] Returned Error status (see iBase_ErrorType) */ 03084 ); 03085 03086 /***************************************************************************/ /** 03087 * \ingroup TagsOnEnts 03088 * \brief Get the 03089 *value of a tag of 03090 *arbitrary type on an 03091 *entity 03092 * 03093 * Get the value of a 03094 *tag of arbitrary 03095 *type on an entity. 03096 *Tag data is passed 03097 *back as void*. 03098 *tag_value_size 03099 *specifies the size 03100 *of the memory 03101 *pointed to by 03102 *tag_value in terms 03103 *of bytes. 03104 *Applications may use 03105 *this function to get 03106 *data of any type, 03107 *not just 03108 *iBase_BYTES. 03109 * However, because 03110 *this function 03111 *supports arbitrary 03112 *type, in all cases 03113 *the size specified 03114 *by tag_value_size is 03115 *always in terms of 03116 * bytes. 03117 ******************************************************************************/ 03118 03119 void iMesh_getData( iMesh_Instance instance, 03120 /**< [in] iMesh instance handle */ 03121 const iBase_EntityHandle entity_handle, 03122 /**< [in] Entity on which tag is being set */ 03123 const iBase_TagHandle tag_handle, 03124 /**< [in] Tag being set on an entity */ 03125 void* tag_value, 03126 /**< [in,out] Pointer to tag data array being queried 03127 \ref trio) */ 03128 int* tag_value_allocated, 03129 /**< [in,out] Pointer to tag data array allocated size */ 03130 int* tag_value_size, 03131 /**< [out] Pointer to occupied size in bytes of tag data */ 03132 int* err 03133 /**< [out] Returned Error status (see iBase_ErrorType) */ 03134 ); 03135 03136 /***************************************************************************/ /** 03137 * \ingroup TagsOnEnts 03138 * \brief Get the 03139 *value of a tag of 03140 *integer type on an 03141 *entity 03142 * 03143 * Get the value of a 03144 *tag of integer type 03145 *on an entity. 03146 ******************************************************************************/ 03147 03148 void iMesh_getIntData( iMesh_Instance instance, 03149 /**< [in] iMesh instance handle */ 03150 const iBase_EntityHandle entity_handle, 03151 /**< [in] Entity on which tag is being set */ 03152 const iBase_TagHandle tag_handle, 03153 /**< [in] Tag being set on an entity */ 03154 int* out_data, 03155 /**< [out] Pointer to tag value returned from function */ 03156 int* err 03157 /**< [out] Returned Error status (see iBase_ErrorType) */ 03158 ); 03159 03160 /***************************************************************************/ /** 03161 * \ingroup TagsOnEnts 03162 * \brief Get the 03163 *value of a tag of 03164 *double type on an 03165 *entity 03166 * 03167 * Get the value of a 03168 *tag of double type 03169 *on an entity. 03170 ******************************************************************************/ 03171 03172 void iMesh_getDblData( iMesh_Instance instance, 03173 /**< [in] iMesh instance handle */ 03174 const iBase_EntityHandle entity_handle, 03175 /**< [in] Entity on which tag is being set */ 03176 const iBase_TagHandle tag_handle, 03177 /**< [in] Tag being set on an entity */ 03178 double* out_data, 03179 /**< [out] Pointer to tag value returned from function */ 03180 int* err 03181 /**< [out] Returned Error status (see iBase_ErrorType) */ 03182 ); 03183 03184 /***************************************************************************/ /** 03185 * \ingroup TagsOnEnts 03186 * \brief Get the 03187 *value of a tag of 03188 *entity handle type 03189 *on an entity 03190 * 03191 * Get the value of a 03192 *tag of entity handle 03193 *type on an entity. 03194 ******************************************************************************/ 03195 03196 void iMesh_getEHData( iMesh_Instance instance, 03197 /**< [in] iMesh instance handle */ 03198 const iBase_EntityHandle entity_handle, 03199 /**< [in] Entity on which tag is being set */ 03200 const iBase_TagHandle tag_handle, 03201 /**< [in] Tag being set on an entity */ 03202 iBase_EntityHandle* out_data, 03203 /**< [out] Pointer to tag value returned from function */ 03204 int* err 03205 /**< [out] Returned Error status (see iBase_ErrorType) */ 03206 ); 03207 03208 /***************************************************************************/ /** 03209 * \ingroup TagsOnEnts 03210 * \brief Get the 03211 *value of a tag of 03212 *entity set handle 03213 *type on an 03214 * 03215 * entity 03216 * Get the value of a 03217 *tag of entity set 03218 *handle type on an 03219 *entity. 03220 ******************************************************************************/ 03221 03222 void iMesh_getESHData( iMesh_Instance instance, 03223 /**< [in] iMesh instance handle */ 03224 const iBase_EntityHandle entity_handle, 03225 /**< [in] Entity on which tag is being set */ 03226 const iBase_TagHandle tag_handle, 03227 /**< [in] Tag being set on an entity */ 03228 iBase_EntitySetHandle* out_data, 03229 /**< [out] Pointer to tag value returned from function */ 03230 int* err 03231 /**< [out] Returned Error status (see iBase_ErrorType) */ 03232 ); 03233 03234 /***************************************************************************/ /** 03235 * \ingroup TagsOnEnts 03236 * \brief Set a tag 03237 *value of arbitrary 03238 *type on an entity 03239 * 03240 * Set a tag value of 03241 *arbitrary type on an 03242 *entity. Tag data is 03243 *passed as void*. 03244 *tag_value_size 03245 *specifies the size 03246 *of the memory 03247 *pointed to by 03248 *tag_value in terms 03249 *of bytes. 03250 *Applications may use 03251 *this function to set 03252 *data of any type, 03253 *not just 03254 *iBase_BYTES. 03255 * However, because 03256 *this function 03257 *supports data of 03258 *arbitrary type, in 03259 * all cases the size 03260 *specified by 03261 *tag_value_size is 03262 *always in terms of 03263 *bytes. 03264 ******************************************************************************/ 03265 03266 void iMesh_setData( iMesh_Instance instance, 03267 /**< [in] iMesh instance handle */ 03268 iBase_EntityHandle entity_handle, 03269 /**< [in] Entity on which tag is being set */ 03270 const iBase_TagHandle tag_handle, 03271 /**< [in] Tag being set on an entity */ 03272 const void* tag_value, 03273 /**< [in] Pointer to tag data being set on entity */ 03274 const int tag_value_size, 03275 /**< [in] Size in bytes of tag data */ 03276 int* err 03277 /**< [out] Returned Error status (see iBase_ErrorType) */ 03278 ); 03279 03280 /***************************************************************************/ /** 03281 * \ingroup TagsOnEnts 03282 * \brief Set a tag 03283 *value of integer 03284 *type on an entity 03285 * 03286 * Set a tag value of 03287 *integer type on an 03288 *entity. 03289 ******************************************************************************/ 03290 03291 void iMesh_setIntData( iMesh_Instance instance, 03292 /**< [in] iMesh instance handle */ 03293 iBase_EntityHandle entity_handle, 03294 /**< [in] Entity on which tag is being set */ 03295 const iBase_TagHandle tag_handle, 03296 /**< [in] Tag being set on an entity */ 03297 const int tag_value, 03298 /**< [in] Tag value being set on entity */ 03299 int* err 03300 /**< [out] Returned Error status (see iBase_ErrorType) */ 03301 ); 03302 03303 /***************************************************************************/ /** 03304 * \ingroup TagsOnEnts 03305 * \brief Set a tag 03306 *value of double type 03307 *on an entity 03308 * 03309 * Set a tag value of 03310 *double type on an 03311 *entity. 03312 ******************************************************************************/ 03313 03314 void iMesh_setDblData( iMesh_Instance instance, 03315 /**< [in] iMesh instance handle */ 03316 iBase_EntityHandle entity_handle, 03317 /**< [in] Entity on which tag is being set */ 03318 const iBase_TagHandle tag_handle, 03319 /**< [in] Tag being set on an entity */ 03320 const double tag_value, 03321 /**< [in] Tag value being set on entity */ 03322 int* err 03323 /**< [out] Returned Error status (see iBase_ErrorType) */ 03324 ); 03325 03326 /***************************************************************************/ /** 03327 * \ingroup TagsOnEnts 03328 * \brief Set a tag 03329 *value of entity 03330 *handle type on an 03331 *entity 03332 * 03333 * Set a tag value of 03334 *entity handle type 03335 *on an entity. 03336 ******************************************************************************/ 03337 03338 void iMesh_setEHData( iMesh_Instance instance, 03339 /**< [in] iMesh instance handle */ 03340 iBase_EntityHandle entity_handle, 03341 /**< [in] Entity on which tag is being set */ 03342 const iBase_TagHandle tag_handle, 03343 /**< [in] Tag being set on an entity */ 03344 const iBase_EntityHandle tag_value, 03345 /**< [in] Tag value being set on entity */ 03346 int* err 03347 /**< [out] Returned Error status (see iBase_ErrorType) */ 03348 ); 03349 03350 /***************************************************************************/ /** 03351 * \ingroup TagsOnEnts 03352 * \brief Set a tag 03353 *value of entity set 03354 *handle type on an 03355 *entity 03356 * 03357 * Set a tag value of 03358 *entity set handle 03359 *type on an entity. 03360 ******************************************************************************/ 03361 03362 void iMesh_setESHData( iMesh_Instance instance, 03363 /**< [in] iMesh instance handle */ 03364 iBase_EntityHandle entity_handle, 03365 /**< [in] Entity on which tag is being set */ 03366 const iBase_TagHandle tag_handle, 03367 /**< [in] Tag being set on an entity */ 03368 const iBase_EntitySetHandle tag_value, 03369 /**< [in] Tag value being set on entity */ 03370 int* err 03371 /**< [out] Returned Error status (see iBase_ErrorType) */ 03372 ); 03373 03374 /***************************************************************************/ /** 03375 * \ingroup Tags 03376 * \brief Get all the 03377 *tags associated with 03378 *a specified entity 03379 *handle 03380 * 03381 * Get all the tags 03382 *associated with a 03383 *specified entity 03384 *handle 03385 ******************************************************************************/ 03386 03387 void iMesh_getAllTags( iMesh_Instance instance, 03388 /**< [in] iMesh instance handle */ 03389 const iBase_EntityHandle entity_handle, 03390 /**< [in] Entity being queried */ 03391 iBase_TagHandle** tag_handles, 03392 /**< [in,out] Pointer to array of tag_handles returned from 03393 \ref trio) */ 03394 int* tag_handles_allocated, 03395 /**< [in,out] Pointer to allocated size of tag_handles */ 03396 int* tag_handles_size, 03397 /**< [out] Pointer to occupied size of tag_handles array */ 03398 int* err 03399 /**< [out] Returned Error status (see iBase_ErrorType) */ 03400 ); 03401 03402 /***************************************************************************/ /** 03403 * \ingroup Tags 03404 * \brief Remove a 03405 *tag value from an 03406 *entity 03407 * 03408 * Remove a tag value 03409 *from an entity 03410 ******************************************************************************/ 03411 03412 void iMesh_rmvTag( iMesh_Instance instance, 03413 /**< [in] iMesh instance handle */ 03414 iBase_EntityHandle entity_handle, 03415 /**< [in] Entity from which tag is being removed */ 03416 const iBase_TagHandle tag_handle, 03417 /**< [in] Tag handle of tag being removed */ 03418 int* err 03419 /**< [out] Returned Error status (see iBase_ErrorType) */ 03420 ); 03421 03422 /***************************************************************************/ /** 03423 * \ingroup 03424 *EntityIterators 03425 * \brief Initialize 03426 *an iterator over 03427 *specified entity 03428 *type, topology, and 03429 *size 03430 * 03431 * Initialize an 03432 *iterator over 03433 *specified entity 03434 *type, topology, and 03435 *size, for a 03436 *specified set or 03437 *instance. Iterator 03438 *returned can be used 03439 *as input to 03440 *functions returning 03441 *the entity for the 03442 *iterator. If all 03443 *entities of a 03444 *specified type 03445 *and/or topology are 03446 *to be iterated, 03447 *specify 03448 * iBase_ALL_TYPES or 03449 *iMesh_ALL_TOPOLOGIES, 03450 *respectively. 03451 *Specified type or 03452 *topology must be a 03453 *value in the 03454 *iBase_EntityType or 03455 * iMesh_EntityTopology 03456 *enumerations, 03457 *respectively. 03458 * 03459 * Note: This function 03460 *will fail and return 03461 *an error if the 03462 *caller passes a 03463 * combination of 03464 *entity_type and 03465 *entity_topology that 03466 *are not consistent. 03467 ******************************************************************************/ 03468 03469 void iMesh_initEntIter( iMesh_Instance instance, 03470 /**< [in] iMesh instance handle */ 03471 const iBase_EntitySetHandle entity_set_handle, 03472 /**< [in] Entity set being iterated */ 03473 const int requested_entity_type, 03474 /**< [in] Type of entity to iterate */ 03475 const int requested_entity_topology, 03476 /**< [in] Topology of entity to iterate */ 03477 const int resilient, 03478 /**< [in] If zero, return a non-resilient iterator. 03479 Otherwise, a resilient iterator (\ref resilient) */ 03480 iBase_EntityIterator* entity_iterator, 03481 /**< [out] Pointer to iterator returned from function */ 03482 int* err 03483 /**< [out] Returned Error status (see iBase_ErrorType) */ 03484 ); 03485 03486 /***************************************************************************/ /** 03487 * \ingroup 03488 *EntityIterators 03489 * \brief Get entity 03490 *corresponding to an 03491 *iterator and 03492 *increment iterator 03493 * 03494 * Get the entity 03495 *corresponding to an 03496 *iterator (that is, 03497 *dereference the 03498 *iterator), and 03499 *increment the 03500 *iterator. The 03501 *dereferenced value 03502 * is returned in 03503 *'entity_handle'. If 03504 *the iterator is at 03505 *the end of the 03506 * iteration, the 03507 *dereferenced value 03508 *will be undefined 03509 *and 'has_data' will 03510 *have a value of 03511 *zero. Otherwise, 03512 *'has_data' will have 03513 *a non-zero value. 03514 ******************************************************************************/ 03515 03516 void iMesh_getNextEntIter( iMesh_Instance instance, 03517 /**< [in] iMesh instance handle */ 03518 iBase_EntityIterator entity_iterator, 03519 /**< [in] Iterator being queried */ 03520 iBase_EntityHandle* entity_handle, 03521 /**< [out] Pointer to an entity handle corresponding to the current 03522 value of iterator just prior to the call. */ 03523 int* has_data, 03524 /**< [out] Pointer to a flag indicating if the value returned in 03525 entity_handle is valid. A non-zero value indicates the value is 03526 valid. A zero value indicates the value is NOT valid. */ 03527 int* err 03528 /**< [out] Returned Error status (see iBase_ErrorType) */ 03529 ); 03530 03531 /***************************************************************************/ /** 03532 * \ingroup 03533 *EntityIterators 03534 * \brief Reset the 03535 *iterator 03536 * 03537 * Reset the iterator 03538 ******************************************************************************/ 03539 03540 void iMesh_resetEntIter( iMesh_Instance instance, 03541 /**< [in] iMesh instance handle */ 03542 iBase_EntityIterator entity_iterator, 03543 /**< [in] Iterator to reset */ 03544 int* err 03545 /**< [out] Returned Error status (see iBase_ErrorType) */ 03546 ); 03547 03548 /***************************************************************************/ /** 03549 * \ingroup 03550 *EntityIterators 03551 * \brief Destroy the 03552 *specified iterator 03553 * 03554 * Destroy the 03555 *specified iterator 03556 ******************************************************************************/ 03557 03558 void iMesh_endEntIter( iMesh_Instance instance, 03559 /**< [in] iMesh instance handle */ 03560 iBase_EntityIterator entity_iterator, 03561 /**< [in] Iterator which gets destroyed */ 03562 int* err 03563 /**< [out] Returned Error status (see iBase_ErrorType) */ 03564 ); 03565 03566 /***************************************************************************/ /** 03567 * \ingroup Entities 03568 * \brief Get the 03569 *entity topology for 03570 *the specified entity 03571 * 03572 * Get the entity 03573 *topology for the 03574 *specified entity. 03575 *Topology returned is 03576 *a value in the 03577 *iMesh_EntityTopology 03578 *enumeration. 03579 ******************************************************************************/ 03580 03581 void iMesh_getEntTopo( iMesh_Instance instance, 03582 /**< [in] iMesh instance handle */ 03583 const iBase_EntityHandle entity_handle, 03584 /**< [in] Entity handle being queried */ 03585 int* out_topo, 03586 /**< [out] Pointer to entity topology returned from function */ 03587 int* err 03588 /**< [out] Returned Error status (see iBase_ErrorType) */ 03589 ); 03590 03591 /***************************************************************************/ /** 03592 * \ingroup Entities 03593 * \brief Get the 03594 *entity type for the 03595 *specified entity 03596 * 03597 * Get the entity type 03598 *for the specified 03599 *entity. Type 03600 *returned is a value 03601 * in the 03602 *iBase_EntityType 03603 *enumeration. 03604 ******************************************************************************/ 03605 03606 void iMesh_getEntType( iMesh_Instance instance, 03607 /**< [in] iMesh instance handle */ 03608 const iBase_EntityHandle entity_handle, 03609 /**< [in] Entity handle being queried */ 03610 int* out_type, 03611 /**< [out] Pointer to entity type returned from function */ 03612 int* err 03613 /**< [out] Returned Error status (see iBase_ErrorType) */ 03614 ); 03615 03616 /***************************************************************************/ /** 03617 * \ingroup 03618 *VertexEntities 03619 * \brief Get 03620 *coordinates of 03621 *specified vertex 03622 * 03623 * Get coordinates of 03624 *specified vertex. 03625 ******************************************************************************/ 03626 03627 void iMesh_getVtxCoord( iMesh_Instance instance, 03628 /**< [in] iMesh instance handle */ 03629 const iBase_EntityHandle vertex_handle, 03630 /**< [in] Mesh vertex being queried */ 03631 double* x, 03632 /**< [out] Pointer to x coordinate returned from function */ 03633 double* y, 03634 /**< [out] Pointer to y coordinate returned from function */ 03635 double* z, 03636 /**< [out] Pointer to z coordinate returned from function */ 03637 int* err 03638 /**< [out] Returned Error status (see iBase_ErrorType) */ 03639 ); 03640 03641 /***************************************************************************/ /** 03642 * \ingroup 03643 *Adjacencies \brief 03644 *Get entities of 03645 *specified type 03646 *adjacent to an 03647 *entity 03648 * 03649 * Get entities of 03650 *specified type 03651 *adjacent to an 03652 *entity. Specified 03653 *type must be value 03654 *in the 03655 *iBase_EntityType 03656 *enumeration. 03657 * 03658 * Note 1: Because 03659 *'adjacent' as 03660 *defined by the iMesh 03661 *data model refers to 03662 *those entities that 03663 *bound another, the 03664 *entity being queried 03665 * here (in 03666 *entity_handle arg) 03667 *is NEVER ALSO 03668 *returned in 03669 * adj_entity_handles 03670 *even if the 03671 *entity_type_requested 03672 * matches the 03673 *entity type in 03674 *entity_handle. 03675 ******************************************************************************/ 03676 03677 void iMesh_getEntAdj( iMesh_Instance instance, 03678 /**< [in] iMesh instance handle */ 03679 const iBase_EntityHandle entity_handle, 03680 /**< [in] Entity handle being queried */ 03681 const int entity_type_requested, 03682 /**< [in] Type of adjacent entities requested */ 03683 iBase_EntityHandle** adj_entity_handles, 03684 /**< [in,out] Pointer to array of adjacent entities \ref trio) */ 03685 int* adj_entity_handles_allocated, 03686 /**< [in,out] Pointer to allocated size of adj_entity_handles */ 03687 int* adj_entity_handles_size, 03688 /**< [out] Pointer to occupied size of adj_entity_handles */ 03689 int* err 03690 /**< [out] Returned Error status (see iBase_ErrorType) */ 03691 ); 03692 03693 /***************************************************************************/ /** 03694 * \ingroup 03695 *Adjacencies \brief 03696 *Get "2nd order" 03697 *adjacencies to an 03698 *entity 03699 * 03700 * Get "2nd order" 03701 *adjacencies to an 03702 *entity, that is, 03703 *from an entity, 03704 *through other 03705 *entities of a 03706 *specified "bridge" 03707 *dimension, to other 03708 *entities of another 03709 *specified "to" 03710 *dimension. Note 1: 03711 *If the "bridge" 03712 *dimension is the 03713 *same as the "to" 03714 *dimension or the 03715 *dimension of the 03716 *input entity, the 03717 *output will be empty 03718 * (and an error 03719 *code of 03720 *iBase_INVALID_ARGUMENT 03721 *returned). This is 03722 * consistent with 03723 *the definition of 03724 *adjacencies and the 03725 *behavior of iMesh 03726 *first adjacency 03727 *calls. Note 2: An 03728 *entity will never be 03729 *returned as a second 03730 *adjacency of itself, 03731 *on the grounds that 03732 *this is the most 03733 *likely expectation 03734 *of applications, and 03735 *that it is easier 03736 *for an application 03737 *to add the original 03738 *entity to the 03739 *returned data than 03740 *to find and remove 03741 *it. 03742 ******************************************************************************/ 03743 03744 void iMesh_getEnt2ndAdj( iMesh_Instance instance, 03745 /**< [in] iMesh instance handle */ 03746 iBase_EntityHandle entity_handle, 03747 /**< [in] Entity from which adjacencies are requested */ 03748 int bridge_entity_type, 03749 /**< [in] Type of bridge entity for 2nd order adjacencies */ 03750 int requested_entity_type, 03751 /**< [in] Type of adjacent entities returned */ 03752 iBase_EntityHandle** adjacent_entities, 03753 /**< [in,out] Adjacent entities \ref trio) */ 03754 int* adjacent_entities_allocated, 03755 /**< [in,out] Allocated size of returned array */ 03756 int* adjacent_entities_size, 03757 /**< [out] Occupied size of returned array */ 03758 int* err 03759 /**< [out] Returned Error status (see iBase_ErrorType) */ 03760 ); 03761 03762 /***************************************************************************/ /** 03763 * \ingroup 03764 *EntitySetOperators 03765 * \brief Subtract 03766 *contents of one 03767 *entity set from 03768 *another 03769 * 03770 * Subtract contents 03771 *of one entity set 03772 *from another 03773 ******************************************************************************/ 03774 03775 void iMesh_subtract( iMesh_Instance instance, 03776 /**< [in] iMesh instance handle */ 03777 const iBase_EntitySetHandle entity_set_1, 03778 /**< [in] Entity set from which other set is being subtracted */ 03779 const iBase_EntitySetHandle entity_set_2, 03780 /**< [in] Entity set being subtracted from other set */ 03781 iBase_EntitySetHandle* result_entity_set, 03782 /**< [out] Pointer to entity set returned from function */ 03783 int* err 03784 /**< [out] Returned Error status (see iBase_ErrorType) */ 03785 ); 03786 03787 /***************************************************************************/ /** 03788 * \ingroup 03789 *EntitySetOperators 03790 * \brief Intersect 03791 *contents of one 03792 *entity set with 03793 *another 03794 * 03795 * Intersect contents 03796 *of one entity set 03797 *with another 03798 ******************************************************************************/ 03799 03800 void iMesh_intersect( iMesh_Instance instance, 03801 /**< [in] iMesh instance handle */ 03802 const iBase_EntitySetHandle entity_set_1, 03803 /**< [in] Entity set being intersected with another */ 03804 const iBase_EntitySetHandle entity_set_2, 03805 /**< [in] Entity set being intersected with another */ 03806 iBase_EntitySetHandle* result_entity_set, 03807 /**< [out] Pointer to entity set returned from function */ 03808 int* err 03809 /**< [out] Returned Error status (see iBase_ErrorType) */ 03810 ); 03811 03812 /***************************************************************************/ /** 03813 * \ingroup 03814 *EntitySetOperators 03815 * \brief Unite 03816 *contents of one 03817 *entity set with 03818 *another 03819 * 03820 ******************************************************************************/ 03821 03822 void iMesh_unite( iMesh_Instance instance, 03823 /**< [in] iMesh instance handle */ 03824 const iBase_EntitySetHandle entity_set_1, 03825 /**< [in] Entity set being united with another */ 03826 const iBase_EntitySetHandle entity_set_2, 03827 /**< [in] Entity set being united with another */ 03828 iBase_EntitySetHandle* result_entity_set, 03829 /**< [out] Pointer to entity set returned from function */ 03830 int* err 03831 /**< [out] Returned Error status (see iBase_ErrorType) */ 03832 ); 03833 03834 /***************************************************************************/ /** 03835 * \page imesh iMesh: 03836 *ITAPS Serial Mesh 03837 *Interface 03838 * 03839 * The ITAPS Mesh 03840 *Interface iMesh 03841 *provides a common 03842 *interface for 03843 * accessing mesh and 03844 *data associated with 03845 *a mesh. Applications 03846 *written to use this 03847 *interface can use a 03848 *variety of 03849 *implementations, 03850 *choosing the one 03851 *that best meets its 03852 *needs. They can 03853 *also use tools 03854 *written to this 03855 *interface, for 03856 *example mesh 03857 *smoothing, adaptive 03858 *mesh refinement, and 03859 *parallel mesh 03860 *support. 03861 * 03862 * The ITAPS 03863 *interfaces use a 03864 *data model composed 03865 *of four basic data 03866 *types: /Entity/: 03867 *basic topological 03868 *entities in a mesh, 03869 *e.g. vertices, 03870 * triangles, 03871 *hexahedra. /Entity 03872 *Set/: arbitrary 03873 *grouping of other 03874 *entities and sets. 03875 * Entity sets also 03876 *support parent/child 03877 *relations with other 03878 *sets which are 03879 *distinct from 03880 *entities contained 03881 *in those sets. 03882 *Parent/child links 03883 * can be used to 03884 *embed graph 03885 *relationships 03886 *between sets, e.g. 03887 *to represent 03888 *topological 03889 *relationships 03890 *between the sets. 03891 * /Interface/: the 03892 *object with which 03893 *mesh is associated 03894 *and on which 03895 * functions in iMesh 03896 *are called. /Tag/: 03897 *application data 03898 *associated with 03899 *objects of any of 03900 *the other data 03901 *types. Each tag has 03902 *a designated name, 03903 *size, and data type. 03904 * 03905 * ITAPS Entity Type, 03906 *Topology Each entity 03907 *has a specific 03908 *Entity Type and 03909 *Entity Topology. The 03910 *Entity Type is one 03911 *of VERTEX, EDGE, 03912 *FACE, and REGION, 03913 *and is synonymous 03914 *with the topological 03915 *dimension of the 03916 *entity. The Entity 03917 *Topology denotes the 03918 *specific shape, for 03919 *example TRIANGLE, 03920 *QUADRILATERAL, 03921 *TETRAHEDRON, and 03922 *HEXAHEDRON. Entity 03923 *Type and Entity 03924 *Topology exist as 03925 *enumerated types, 03926 *Entity Type in the 03927 *iBase_EntityType 03928 *enumeration, and 03929 * Entity Topology in 03930 *the 03931 *iMesh_EntityTopology 03932 *enumeration. 03933 * 03934 * ITAPS Entity-, 03935 *Array-, and 03936 *Iterator-Based 03937 *Access The iMesh 03938 *interface provides 03939 *functions for 03940 *accessing entities 03941 * individually, as 03942 *arrays of entities, 03943 *or using iterators. 03944 *These access methods 03945 *have different 03946 *memory versus 03947 *execution time 03948 *tradeoffs, depending 03949 *on the 03950 *implementation. 03951 * 03952 * \image html 03953 *example_pic.jpeg 03954 * 03955 * \subpage cycles 03956 * 03957 * \page cycles Cycles 03958 *in Set-Inclusion and 03959 *Parent-Child 03960 *structures. 03961 * 03962 * There are two 03963 *graph-like 03964 *structures in the 03965 *iMesh interface and 03966 *data model; the 03967 *set-inclusion 03968 *structure and the 03969 *parent-child link 03970 *structure. Whether 03971 *these structures 03972 *support cycles is 03973 *relevant to 03974 *implementors. 03975 * 03976 * Over the evolution 03977 *of the iMesh data 03978 *model and API, both 03979 *of these structures 03980 *have been viewed 03981 *more or less like a 03982 *tree and so cycles 03983 *seem incompatible 03984 *with that notion. 03985 * 03986 * Allowing a cycle in 03987 *the set inclusion 03988 *structure implies 03989 *all entity sets in 03990 *the cycle are all 03991 *equal to each other. 03992 *That is the only 03993 *rational, 03994 * model-level view 03995 *that would allow 03996 *them all to be 03997 *(improper) subsets 03998 *of each other. On 03999 *the other hand if 04000 *the iMesh 04001 *specification 04002 *excludes cycles from 04003 *the set inclusion 04004 *structure, the time 04005 *complexity 04006 *(performance) as a 04007 * function of the 04008 *number of entity 04009 *sets may be 04010 *prohibitive for 04011 * implementations to 04012 *detect and prevent 04013 *them. 04014 * 04015 * Allowing a cycle in 04016 *the parent-child 04017 *link structure seems 04018 *likewise hard to 04019 *justify. However, 04020 *when the 04021 *parent-child 04022 *structure is viewed 04023 *more like a general 04024 *graph (a view that 04025 *the current API 04026 *itself supports even 04027 *if the function 04028 *names themselves do 04029 *not suggest that) 04030 *than specifically a 04031 *tree, the admission 04032 *of cycles there is 04033 *potentially more 04034 *natural and useful. 04035 * 04036 * Implementations are 04037 *required to support 04038 *cycles in the 04039 *Parent-Child 04040 * structure. 04041 *Implementations are 04042 *neither required to 04043 *support nor required 04044 * to explicitly 04045 *prevent cycles in 04046 *the Set-Inclusion 04047 *structure. Portable 04048 * applications should 04049 *NOT rely on 04050 *implementations 04051 *support for cycles 04052 * in the 04053 *set-inclusion 04054 *structure. 04055 ******************************************************************************/ 04056 04057 /***************************************************************************/ /** 04058 * \defgroup iMesh 04059 *iMesh 04060 ******************************************************************************/ 04061 04062 /***************************************************************************/ /** 04063 * \defgroup 04064 *Initialization 04065 *Initialization 04066 * \ingroup iMesh 04067 ******************************************************************************/ 04068 04069 /***************************************************************************/ /** 04070 * \defgroup Entities 04071 *Entities \ingroup 04072 *iMesh 04073 ******************************************************************************/ 04074 04075 /***************************************************************************/ /** 04076 * \defgroup 04077 *VertexEntities 04078 *Vertex Entities 04079 * \ingroup Entities 04080 ******************************************************************************/ 04081 04082 /***************************************************************************/ /** 04083 * \defgroup 04084 *EntitySets Entity 04085 *Sets \ingroup iMesh 04086 ******************************************************************************/ 04087 04088 /***************************************************************************/ /** 04089 * \defgroup 04090 *EntitySetOperators 04091 *Entity Set Operators 04092 * \ingroup EntitySets 04093 ******************************************************************************/ 04094 04095 /***************************************************************************/ /** 04096 * \defgroup 04097 *Adjacencies 04098 *Adjacencies \ingroup 04099 *iMesh 04100 ******************************************************************************/ 04101 04102 /***************************************************************************/ /** 04103 * \defgroup 04104 *EntityIterators 04105 *Entity Iterators 04106 * \ingroup iMesh 04107 ******************************************************************************/ 04108 04109 /***************************************************************************/ /** 04110 * \defgroup Tags Tags 04111 * \ingroup iMesh 04112 ******************************************************************************/ 04113 04114 /***************************************************************************/ /** 04115 * \defgroup TagData 04116 *Tag Data \ingroup 04117 *iMesh 04118 ******************************************************************************/ 04119 04120 /***************************************************************************/ /** 04121 * \defgroup 04122 *TagsOnEnts Tag Data 04123 *On Entities \ingroup 04124 *TagData 04125 ******************************************************************************/ 04126 04127 /***************************************************************************/ /** 04128 * \defgroup 04129 *TagsOnSets Tag Data 04130 *On Entity Sets 04131 * \ingroup TagData 04132 ******************************************************************************/ 04133 04134 /***************************************************************************/ /** 04135 * \defgroup TagsOnArr 04136 *Tag Data On Arrays 04137 *of Entities \ingroup 04138 *TagData 04139 ******************************************************************************/ 04140 04141 /***************************************************************************/ /** 04142 * \defgroup 04143 *MeshModification 04144 *Mesh Modification 04145 * \ingroup iMesh 04146 ******************************************************************************/ 04147 04148 /***************************************************************************/ /** 04149 * \defgroup 04150 *ParentChildLinks 04151 *Parent Child Links 04152 * \ingroup iMesh 04153 ******************************************************************************/ 04154 04155 /***************************************************************************/ /** 04156 * \defgroup Datatypes 04157 *Datatypes \ingroup 04158 *iMesh 04159 ******************************************************************************/ 04160 04161 #ifdef __cplusplus 04162 } /* extern "C" */ 04163 #endif 04164 04165 #endif /* ifndef _ITAPS_iMesh */
1.7.6.1 
