 |
Mesh Oriented datABase
(version 5.4.1)
Array-based unstructured mesh datastructure
|
|
Mesh Oriented datABase
(version 5.4.1)
Array-based unstructured mesh datastructure
|
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.
Dark theme by Tilen Majerle. All rights reserved.