MOAB: Mesh Oriented datABase  (version 5.4.0)
FBiGeom.h
Go to the documentation of this file.
00001 #ifndef _ITAPS_FBiGeom
00002 #define _ITAPS_FBiGeom
00003 
00004 /** \mainpage The ITAPS Geometry Interface FBiGeom
00005  *
00006  * The ITAPS Geometry Interface FBiGeom provides a common interface for
00007  * accessing geometry and data associated with a mesh.  Applications written
00008  * to use this interface can use a variety of implementations, choosing
00009  * the one that best meets its needs.  They can also use tools written
00010  * to this interface.
00011  *
00012  * \section ITAPS Data Model
00013  *
00014  * The ITAPS interfaces use a data model composed of four basic data types:\n
00015  * \em Entity: basic topological entities in a model, e.g. vertices,
00016  * edges, faces, regions. \n
00017  * \em Entity \em Set: arbitrary grouping of other entities and sets.
00018  * Entity sets also support parent/child relations with other sets which
00019  * are distinct from entities contained in those sets.  Parent/child links
00020  * can be used to embed graph relationships between sets, e.g. to
00021  * represent topological relationships between the sets. \n
00022  * \em Interface: the object with which model is associated and on which
00023  * functions in FBiGeom are called. \n
00024  * \em Tag: application data associated with objects of any of the other
00025  * data types.  Each tag has a designated name, size, and data type.
00026  *
00027  * \section JTAPS Entity Type
00028  * Each entity has a specific Entity Type.  The Entity
00029  * Type is one of VERTEX, EDGE, FACE, and REGION, and is synonymous with
00030  * the topological dimension of the entity.  Entity Type is an enumerated
00031  * type in the iBase_EntityType enumeration.
00032  *
00033  * \section KTAPS Entity-, Array-, and Iterator-Based Access
00034  *
00035  * The FBiGeom interface provides functions for accessing entities
00036  * individually, as arrays of entities, or using iterators.  These access
00037  * methods have different memory versus execution time tradeoffs,
00038  * depending on the implementation.
00039  *
00040  * \section LTAPS Lists Passed Through Interface
00041  *
00042  * Many of the functions in FBiGeom have arguments corresponding to lists of
00043  * objects.  In-type arguments for lists consist of a pointer to an array and
00044  * a list size.  Lists returned from functions are passed in three arguments,
00045  * a pointer to the array representing the list, and pointers to the
00046  * allocated and occupied lengths of the array.  These three arguments are
00047  * inout-type arguments, because they can be allocated by the application and
00048  * passed into the interface to hold the results of the function.  Lists
00049  * which are pre-allocated must be large enough to hold the results of the
00050  * function; if this is not the case, an error is generated.  Otherwise, the
00051  * occupied size is changed to the size output from the function.  If a list
00052  * argument is unallocated (the list pointer points to a NULL value) or if
00053  * the incoming value of the allocated size is zero, the list storage will be
00054  * allocated by the implementation.  IN ALL CASES, MEMORY ALLOCATED BY ITAPS
00055  * INTERFACE IMPLEMENTATIONS IS DONE USING THE C MALLOC FUNCTION, AND CAN BE
00056  * DE-ALLOCATED USING THE C FREE FUNCTION.
00057  *
00058  */
00059 
00060 #include "iBase.h"
00061 #include "FBiGeom_protos.h"
00062 
00063 #ifdef __cplusplus
00064 extern "C" {
00065 #endif
00066 
00067 /**\brief  Type used to store FBiGeom interface handle
00068  *
00069  * Type used to store FBiGeom interface handle
00070  */
00071 typedef struct FBiGeom_Instance_Private* FBiGeom_Instance;
00072 
00073 /**\brief  Get a description of the error returned from the last FBiGeom call
00074  *
00075  * Get a description of the error returned from the last FBiGeom function
00076  * \param instance FBiGeom instance handle
00077  * \param descr Pointer to a character string to be filled with a
00078  *        description of the error from the last FBiGeom function
00079  * \param descr_len Length of the character string pointed to by descr
00080  */
00081 void FBiGeom_getDescription( FBiGeom_Instance instance, char* descr, int descr_len );
00082 
00083 /**\brief  Get the error type returned from the last FBiGeom function
00084  *
00085  * Get the error type returned from the last FBiGeom function.  Value
00086  * returned is a member of the iBase_ErrorType enumeration.
00087  * \param instance FBiGeom instance handle
00088  * \param *error_type Error type returned from last FBiGeom function
00089  */
00090 void FBiGeom_getErrorType( FBiGeom_Instance instance,
00091                            /*out*/ int* error_type );
00092 
00093 /**\brief  Construct a new FBiGeom instance
00094  *
00095  * Construct a new FBiGeom instance, using implementation-specific options
00096  * \param options Pointer to implementation-specific options string
00097  * \param instance Pointer to FBiGeom instance handle returned from function
00098  * \param *err Pointer to error type returned from function
00099  * \param options_len Length of the character string pointed to by options
00100  */
00101 void FBiGeom_newGeom( char const* options, FBiGeom_Instance* instance_out, int* err, int options_len );
00102 
00103 /**\brief  Construct a new FBiGeom instance
00104  *
00105  * Construct a new FBiGeom instance, using an existing moab iMesh instance
00106  * and a root set that encapsulates the topological model
00107  * \param mesh iMesh_Instance
00108  * \param set  root set for the mesh based geometry
00109  * \param options Pointer to implementation-specific options string
00110  * \param instance Pointer to FBiGeom instance handle returned from function
00111  * \param *err Pointer to error type returned from function
00112  * \param options_len Length of the character string pointed to by options
00113  */
00114 
00115 /*  void FBiGeom_newGeomFromMesh( iMesh_Instance mesh, iBase_EntitySetHandle set,
00116                           const char *options, FBiGeom_Instance *geom,
00117                           int *err, int options_len);*/
00118 /**\brief  Destroy an FBiGeom instance
00119  *
00120  * Destroy an FBiGeom instance
00121  * \param instance FBiGeom instance to be destroyed
00122  * \param *err Pointer to error type returned from function
00123  */
00124 void FBiGeom_dtor( FBiGeom_Instance instance, int* err );
00125 
00126 /**\brief  Load a geom from a file
00127  *
00128  * Load a geom from a file.  If entity set is specified, loaded geom
00129  * is added to that set; specify zero if that is not desired.
00130  * \param instance FBiGeom instance handle
00131  * \param entity_set_handle Set to which loaded geom will be added, zero
00132  *        if not desired
00133  * \param name File name from which geom is to be loaded
00134  * \param options Pointer to implementation-specific options string
00135  * \param *err Pointer to error type returned from function
00136  * \param name_len Length of the file name character string
00137  * \param options_len Length of the options character string
00138  */
00139 void FBiGeom_load( FBiGeom_Instance instance,
00140                    char const* name,
00141                    char const* options,
00142                    int* err,
00143                    int name_len,
00144                    int options_len );
00145 
00146 /**\brief  Save a geom to a file
00147  *
00148  * Save a geom to a file.  If entity set is specified, save only the
00149  * geom contained in that set.
00150  * \param instance FBiGeom instance handle
00151  * \param entity_set_handle Entity set being saved
00152  * \param name File name to which geom is to be saved
00153  * \param options Pointer to implementation-specific options string
00154  * \param *err Pointer to error type returned from function
00155  * \param name_len Length of the file name character string
00156  * \param options_len Length of the options character string
00157  */
00158 void FBiGeom_save( FBiGeom_Instance instance,
00159                    char const* name,
00160                    char const* options,
00161                    int* err,
00162                    int name_len,
00163                    int options_len );
00164 
00165 /**\brief  Get handle of the root set for this instance
00166  *
00167  * Get handle of the root set for this instance.  All geom in
00168  * this instance can be accessed from this set.
00169  * \param instance FBiGeom instance handle
00170  * \param root_set Pointer to set handle returned from function
00171  * \param *err Pointer to error type returned from function
00172  */
00173 void FBiGeom_getRootSet( FBiGeom_Instance instance, iBase_EntitySetHandle* root_set, int* err );
00174 
00175 /**\brief Get the bounding box of the entire model
00176  *
00177  * Get the bounding box of the entire model
00178  * \param instance FBiGeom instance handle
00179  * \param min_x Minimum coordinate of bounding box
00180  * \param min_y Minimum coordinate of bounding box
00181  * \param min_z Minimum coordinate of bounding box
00182  * \param max_x Maximum coordinate of bounding box
00183  * \param max_y Maximum coordinate of bounding box
00184  * \param max_z Maximum coordinate of bounding box
00185  * \param *err Pointer to error type returned from function
00186  */
00187 void FBiGeom_getBoundBox( FBiGeom_Instance instance,
00188                           double* min_x,
00189                           double* min_y,
00190                           double* min_z,
00191                           double* max_x,
00192                           double* max_y,
00193                           double* max_z,
00194                           int* err );
00195 
00196 /**\brief  Get entities of specific type in set or instance
00197  *
00198  * Get entities of specific type in set or instance.  All entities are
00199  * requested by specifying iBase_ALL_TYPES.  Specified type must be a value
00200  * in the iBase_EntityType enumeration.
00201  * \param instance FBiGeom instance handle
00202  * \param entity_set_handle Entity set being queried
00203  * \param entity_type Type of entities being requested
00204  * \param entity_topology Topology of entities being requested
00205  * \param *entity_handles Pointer to array of entity handles returned
00206  *        from function
00207  * \param *entity_handles_allocated Pointer to allocated size of
00208  *        entity_handles array
00209  * \param *entity_handles_size Pointer to occupied size of entity_handles
00210  *        array
00211  * \param *err Pointer to error type returned from function
00212  */
00213 void FBiGeom_getEntities( FBiGeom_Instance instance,
00214                           iBase_EntitySetHandle set_handle,
00215                           int entity_type,
00216                           iBase_EntityHandle** entity_handles,
00217                           int* entity_handles_allococated,
00218                           int* entity_handles_size,
00219                           int* err );
00220 
00221 /**\brief  Get the number of entities with the specified type in the
00222  *         instance or set
00223  *
00224  * Get the number of entities with the specified type in the instance
00225  * or set.  If entity set handle is zero, return information for instance,
00226  * otherwise for set.  Value of entity type must be from the
00227  * iBase_EntityType enumeration.  If iBase_ALL_TYPES is specified, total
00228  * number of entities (excluding entity sets) is returned.
00229  * \param instance FBiGeom instance handle
00230  * \param entity_set_handle Entity set being queried
00231  * \param entity_type Type of entity requested
00232  * \param num_type Pointer to number of entities, returned from function
00233  * \param *err Pointer to error type returned from function
00234  */
00235 void FBiGeom_getNumOfType( FBiGeom_Instance instance,
00236                            iBase_EntitySetHandle set_handle,
00237                            int entity_type,
00238                            int* num_out,
00239                            int* err );
00240 
00241 /**\brief  Get the entity type for the specified entity
00242  *
00243  * Get the entity type for the specified entity.  Type returned is a value
00244  * in the iBase_EntityType enumeration.
00245  * \param instance FBiGeom instance handle
00246  * \param entity_handle entity handle being queried
00247  * \param *type Pointer to location at which to store the returned type
00248  * \param *err Pointer to error type returned from function
00249  */
00250 void FBiGeom_getEntType( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* type, int* err );
00251 
00252 /**\brief  Get the entity type for the specified entities
00253  *
00254  * Get the entity type for the specified entities.  Types returned are
00255  * values in the iBase_EntityType enumeration.
00256  * \param instance FBiGeom instance handle
00257  * \param entity_handles Array of entity handles being queried
00258  * \param entity_handles_size Number of entities in entity_handles array
00259  * \param *type Pointer to array of types returned from function
00260  * \param *type_allocated Pointer to allocated size of type array
00261  * \param *type_size Pointer to occupied size of type array
00262  * \param *err Pointer to error type returned from function
00263  */
00264 void FBiGeom_getArrType( FBiGeom_Instance instance,
00265                          iBase_EntityHandle const* entity_handles,
00266                          int entity_handles_size,
00267                          int** type,
00268                          int* type_allocated,
00269                          int* type_size,
00270                          int* err );
00271 
00272 /**\brief  Get entities of specified type adjacent to an entity
00273  *
00274  * Get entities of specified type adjacent to an entity.  Specified type
00275  * must be value in the iBase_EntityType enumeration.
00276  * \param instance FBiGeom instance handle
00277  * \param entity_handle Entity handle being queried
00278  * \param entity_type_requested Type of adjacent entities requested
00279  * \param *adj_entity_handles Pointer to array of adjacent entities
00280  *        returned from function
00281  * \param *adj_entity_handles_allocated Pointer to allocated size of
00282  *        adj_entity_handles array
00283  * \param *adj_entity_handles_size Pointer to occupied size of
00284  *        adj_entity_handles array
00285  * \param *err Pointer to error type returned from function
00286  */
00287 void FBiGeom_getEntAdj( FBiGeom_Instance instance,
00288                         iBase_EntityHandle entity_handle,
00289                         int to_dimension,
00290                         iBase_EntityHandle** adj_entities,
00291                         int* adj_entities_allocated,
00292                         int* adj_entities_size,
00293                         int* err );
00294 
00295 /**\brief  Get entities of specified type adjacent to entities
00296  *
00297  * Get entities of specified type adjacent to entities.  Specified type
00298  * must be value in the iBase_EntityType enumeration.  \em offset(i) is
00299  * index of first entity in adjacentEntityHandles array adjacent to
00300  * entity_handles[i].
00301  * \param instance FBiGeom instance handle
00302  * \param entity_handles Array of entity handles being queried
00303  * \param entity_handles_size Number of entities in entity_handles array
00304  * \param entity_type_requested Type of adjacent entities requested
00305  * \param *adjacentEntityHandles Pointer to array of adjacentEntityHandles
00306  *        returned from function
00307  * \param *adjacentEntityHandles_allocated Pointer to allocated size of
00308  *        adjacentEntityHandles array
00309  * \param *adj_entity_handles_size Pointer to occupied size of
00310  *        adjacentEntityHandles array
00311  * \param *offset Pointer to array of offsets returned from function
00312  * \param *offset_allocated Pointer to allocated size of offset array
00313  * \param *offset_size Pointer to occupied size of offset array
00314  * \param *err Pointer to error type returned from function
00315  */
00316 void FBiGeom_getArrAdj( FBiGeom_Instance instance,
00317                         iBase_EntityHandle const* entity_handles,
00318                         int entity_handles_size,
00319                         int requested_entity_type,
00320                         iBase_EntityHandle** adj_entity_handles,
00321                         int* adj_entity_handles_allocated,
00322                         int* adj_entity_handles_size,
00323                         int** offset,
00324                         int* offset_allocated,
00325                         int* offset_size,
00326                         int* err );
00327 
00328 /**\brief  Get "2nd order" adjacencies to an entity
00329  *
00330  * Get "2nd order" adjacencies to an entity, that is, from an entity,
00331  * through other entities of a specified "bridge" dimension, to other
00332  * entities of another specified "to" dimension.
00333  * \param instance FBiGeom instance handle
00334  * \param entity_handle Entity from which adjacencies are requested
00335  * \param bridge_dimension Bridge dimension for 2nd order adjacencies
00336  * \param to_dimension Dimension of adjacent entities returned
00337  * \param adjacent_entities Adjacent entities
00338  * \param adjacent_entities_allocated Allocated size of returned array
00339  * \param adjacent_entities_size Occupied size of returned array
00340  * \param *err Pointer to error type returned from function
00341  */
00342 void FBiGeom_getEnt2ndAdj( FBiGeom_Instance instance,
00343                            iBase_EntityHandle entity_handle,
00344                            int bridge_dimension,
00345                            int to_dimension,
00346                            iBase_EntityHandle** adjacent_entities,
00347                            int* adjacent_entities_allocated,
00348                            int* adjacent_entities_size,
00349                            int* err );
00350 
00351 /**\brief  Get "2nd order" adjacencies to an array of entities
00352  *
00353  * Get "2nd order" adjacencies to an array of entities, that is, from each
00354  * entity, through other entities of a specified "bridge" dimension, to
00355  * other entities of another specified "to" dimension.
00356  * \param instance FBiGeom instance handle
00357  * \param entity_handles Entities from which adjacencies are requested
00358  * \param entity_handles_size Number of entities whose adjacencies are
00359  *        requested
00360  * \param bridge_dimension Bridge dimension for 2nd order adjacencies
00361  * \param to_dimension Dimension of adjacent entities returned
00362  * \param adj_entity_handles Adjacent entities
00363  * \param adj_entity_handles_allocated Allocated size of returned array
00364  * \param adj_entity_handles_size Occupied size of returned array
00365  * \param offset Offset[i] is offset into adj_entity_handles of 2nd order
00366  *        adjacencies of ith entity in entity_handles
00367  * \param offset_allocated Allocated size of offset array
00368  * \param offset_size Occupied size of offset array
00369  * \param *err Pointer to error type returned from function
00370  */
00371 void FBiGeom_getArr2ndAdj( FBiGeom_Instance instance,
00372                            iBase_EntityHandle const* entity_handles,
00373                            int entity_handles_size,
00374                            int order_adjacent_key,
00375                            int requested_entity_type,
00376                            iBase_EntityHandle** adj_entity_handles,
00377                            int* adj_entity_handles_allocated,
00378                            int* adj_entity_handles_size,
00379                            int** offset,
00380                            int* offset_allocated,
00381                            int* offset_size,
00382                            int* err );
00383 
00384 /**\brief  Return whether two entities are adjacent
00385  *
00386  * Return whether two entities are adjacent.
00387  * \param instance FBiGeom instance handle
00388  * \param entity_handle1 First entity queried
00389  * \param entity_handle2 Second entity queried
00390  * \param are_adjacent If returned non-zero, entities are adjacent,
00391  *        otherwise they are not
00392  * \param *err Pointer to error type returned from function
00393  */
00394 void FBiGeom_isEntAdj( FBiGeom_Instance instance,
00395                        iBase_EntityHandle entity_handle1,
00396                        iBase_EntityHandle entity_handle2,
00397                        int* are_adjacent,
00398                        int* err );
00399 
00400 /**\brief  Return whether entity pairs are adjacent
00401  *
00402  * Return whether entity pairs are adjacent, i.e. if entity_handles_1[i] is
00403  * adjacent to entity_handles_2[i].  This function requires
00404  * entity_handles_1_size and entity_handles_2_size to be equal.
00405  * \param instance FBiGeom instance handle
00406  * \param entity_handles_1 First array of entities
00407  * \param entity_handles_1_size Number of entities in first array
00408  * \param entity_handles_2 Second array of entities
00409  * \param entity_handles_2_size Number of entities in second array
00410  * \param is_adjacent_info Array of flags returned from function
00411  * \param is_adjacent_info_allocated Allocated size of flags array
00412  * \param is_adjacent_info_size Occupied size of flags array
00413  * \param *err Pointer to error type returned from function
00414  */
00415 void FBiGeom_isArrAdj( FBiGeom_Instance instance,
00416                        iBase_EntityHandle const* entity_handles_1,
00417                        int entity_handles_1_size,
00418                        iBase_EntityHandle const* entity_handles_2,
00419                        int entity_handles_2_size,
00420                        int** is_adjacent_info,
00421                        int* is_adjacent_info_allocated,
00422                        int* is_adjacent_info_size,
00423                        int* err );
00424 
00425 /**\brief  Return the topology level of the geometry
00426  *
00427  * Return the topology level of the geometry as an integer, where 0 = basic
00428  * entities only, 1 = manifold entities, 2 = non-manifold entities.
00429  * \param instance FBiGeom instance handle
00430  * \param topo_level_out The topology level
00431  * \param *err Pointer to error type returned from function
00432  */
00433 void FBiGeom_getTopoLevel( FBiGeom_Instance instance, int* topo_level_out, int* err );
00434 
00435 /**\brief  Get closest point to an entity
00436  *
00437  * Get closest point to a specified position on an entity
00438  * \param instance FBiGeom instance handle
00439  * \param entity_handle Entity being queried
00440  * \param near_x Coordinates of starting point
00441  * \param near_y Coordinates of starting point
00442  * \param near_z Coordinates of starting point
00443  * \param on_x Closest point on entity
00444  * \param on_y Closest point on entity
00445  * \param on_z Closest point on entity
00446  * \param *err Pointer to error type returned from function
00447  */
00448 void FBiGeom_getEntClosestPt( FBiGeom_Instance instance,
00449                               iBase_EntityHandle entity_handle,
00450                               double near_x,
00451                               double near_y,
00452                               double near_z,
00453                               double* on_x,
00454                               double* on_y,
00455                               double* on_z,
00456                               int* err );
00457 
00458 /**\brief  Get closest point for an array of entities and points
00459  * For surfaces, closest point could be on the void space inside it.
00460  * Get closest point for an array of entities and points.  If either the
00461  * number of entities or number of coordinate triples is unity, then all
00462  * points or entities are queried for that entity or point, respectively,
00463  * otherwise each point corresponds to each entity.  storage_order should be
00464  * a value in the iBase_StorageOrder enum.
00465  * \param instance FBiGeom instance handle
00466  * \param entity_handles Entity(ies) being queried
00467  * \param entity_handles_size Number of entities being queried
00468  * \param storage_order Storage order of input points
00469  * \param near_coordinates Coordinates of starting point(s)
00470  * \param near_coordinates_size Number of values in near_coordinates array
00471  * \param on_coordinates Coordinates of closest points
00472  * \param on_coordinates_allocated Allocated size of closest point array
00473  * \param on_coordinates_size Occupied size of closest point array
00474  * \param *err Pointer to error type returned from function
00475  */
00476 
00477 void FBiGeom_getEntClosestPtTrimmed( FBiGeom_Instance instance,
00478                                      iBase_EntityHandle entity_handle,
00479                                      double near_x,
00480                                      double near_y,
00481                                      double near_z,
00482                                      double* on_x,
00483                                      double* on_y,
00484                                      double* on_z,
00485                                      int* err );
00486 
00487 /**\brief  Get closest point for an array of entities and points
00488  * For surfaces, it made sure the closest point in on surface.
00489  * Get closest point for an array of entities and points.  If either the
00490  * number of entities or number of coordinate triples is unity, then all
00491  * points or entities are queried for that entity or point, respectively,
00492  * otherwise each point corresponds to each entity.  storage_order should be
00493  * a value in the iBase_StorageOrder enum.
00494  * \param instance FBiGeom instance handle
00495  * \param entity_handles Entity(ies) being queried
00496  * \param entity_handles_size Number of entities being queried
00497  * \param storage_order Storage order of input points
00498  * \param near_coordinates Coordinates of starting point(s)
00499  * \param near_coordinates_size Number of values in near_coordinates array
00500  * \param on_coordinates Coordinates of closest points
00501  * \param on_coordinates_allocated Allocated size of closest point array
00502  * \param on_coordinates_size Occupied size of closest point array
00503  * \param *err Pointer to error type returned from function
00504  */
00505 void FBiGeom_getArrClosestPt( FBiGeom_Instance instance,
00506                               iBase_EntityHandle const* entity_handles,
00507                               int entity_handles_size,
00508                               int storage_order,
00509                               double const* near_coordinates,
00510                               int near_coordinates_size,
00511                               double** on_coordinates,
00512                               int* on_coordinates_allocated,
00513                               int* on_coordinates_size,
00514                               int* err );
00515 
00516 /**\brief  Get the normal vector on an entity at the given position
00517  * Get the normal vector on an entity at the given position.
00518  * \param instance FBiGeom instance handle
00519  * \param entity_handle Entity being queried
00520  * \param x Coordinates of starting point
00521  * \param y Coordinates of starting point
00522  * \param z Coordinates of starting point
00523  * \param nrml_i Normal vector at starting point
00524  * \param nrml_j Normal vector at starting point
00525  * \param nrml_k Normal vector at starting point
00526  * \param *err Pointer to error type returned from function
00527  */
00528 void FBiGeom_getEntNrmlXYZ( FBiGeom_Instance instance,
00529                             iBase_EntityHandle entity_handle,
00530                             double x,
00531                             double y,
00532                             double z,
00533                             double* nrml_i,
00534                             double* nrml_j,
00535                             double* nrml_k,
00536                             int* err );
00537 
00538 /**\brief  Get the normal vector on an entity(ies) at given position(s)
00539  *
00540  * Get the normal vector on an entity(ies) at given position(s).  If either
00541  * the number of entities or number of coordinate triples is unity, then all
00542  * points or entities are queried for that entity or point, respectively,
00543  * otherwise each point corresponds to each entity.  storage_order should be
00544  * a value in the iBase_StorageOrder enum.
00545  * \param instance FBiGeom instance handle
00546  * \param entity_handles Entity(ies) being queried
00547  * \param entity_handles_size Number of entities being queried
00548  * \param storage_order Storage order of coordinates
00549  * \param coordinates Starting coordinates
00550  * \param coordinates_size Number of values in coordinates array
00551  * \param normals Normal coordinates
00552  * \param normals_allocated Allocated size of normals array
00553  * \param normals_size Occupied size of normals array
00554  * \param *err Pointer to error type returned from function
00555  */
00556 void FBiGeom_getArrNrmlXYZ( FBiGeom_Instance instance,
00557                             iBase_EntityHandle const* entity_handles,
00558                             int entity_handles_size,
00559                             int storage_order,
00560                             double const* coordinates,
00561                             int coordinates_size,
00562                             double** normals,
00563                             int* normals_allocated,
00564                             int* normals_size,
00565                             int* err );
00566 
00567 /**\brief  Get the normal vector AND closest point on an entity at given
00568  *         position
00569  *
00570  * Get the normal vector AND closest point on an entity at a given position.
00571  * \param entity_handle Entity being queried
00572  * \param instance FBiGeom instance handle
00573  * \param x Starting coordinates
00574  * \param y Starting coordinates
00575  * \param z Starting coordinates
00576  * \param pt_x Closest point
00577  * \param pt_y Closest point
00578  * \param pt_z Closest point
00579  * \param nrml_i Normal at closest point
00580  * \param nrml_j Normal at closest point
00581  * \param nrml_k Normal at closest point
00582  * \param *err Pointer to error type returned from function
00583  */
00584 void FBiGeom_getEntNrmlPlXYZ( FBiGeom_Instance instance,
00585                               iBase_EntityHandle entity_handle,
00586                               double x,
00587                               double y,
00588                               double z,
00589                               double* pt_x,
00590                               double* pt_y,
00591                               double* pt_z,
00592                               double* nrml_i,
00593                               double* nrml_j,
00594                               double* nrml_k,
00595                               int* err );
00596 
00597 /**\brief Get the normal vector AND closest point on an entity(ies) at
00598  *        given position(s)
00599  *
00600  * Get the normal vector AND closest point on an entity(ies) at given
00601  * position(s).  If either the number of entities or number of coordinate
00602  * triples is unity, then all points or entities are queried for that entity
00603  * or point, respectively, otherwise each point corresponds to each entity.
00604  * storage_order should be a value in the iBase_StorageOrder enum.
00605  * \param instance FBiGeom instance handle
00606  * \param entity_handles Entity(ies) being queried
00607  * \param entity_handles_size Number of entity(ies) being queried
00608  * \param storage_order Storage order in near_coordinates array
00609  * \param near_coordinates Starting coordinates
00610  * \param near_coordinates_size Number of values in near_coordinates array
00611  * \param on_coordinates Closest point array
00612  * \param on_coordinates_allocated Allocated size of closest point array
00613  * \param on_coordinates_size Occupied size of closest point array
00614  * \param normals Normal array
00615  * \param normals_allocated Allocated size of normal array
00616  * \param normals_size Occupied size of normal array
00617  * \param *err Pointer to error type returned from function
00618  */
00619 void FBiGeom_getArrNrmlPlXYZ( FBiGeom_Instance instance,
00620                               iBase_EntityHandle const* entity_handles,
00621                               int entity_handles_size,
00622                               int storage_order,
00623                               double const* near_coordinates,
00624                               int near_coordinates_size,
00625                               double** on_coordinates,
00626                               int* on_coordinates_allocated,
00627                               int* on_coordinates_size,
00628                               double** normals,
00629                               int* normals_allocated,
00630                               int* normals_size,
00631                               int* err );
00632 
00633 /**\brief  Get the tangent vector on an entity at given position
00634  *
00635  * Get the tangent vector on an entity at a given position.
00636  * \param instance FBiGeom instance handle
00637  * \param entity_handle Entity being queried
00638  * \param x Starting coordinates
00639  * \param y Starting coordinates
00640  * \param z Starting coordinates
00641  * \param tgnt_i Tangent at closest point
00642  * \param tgnt_j Tangent at closest point
00643  * \param tgnt_k Tangent at closest point
00644  * \param *err Pointer to error type returned from function
00645  */
00646 void FBiGeom_getEntTgntXYZ( FBiGeom_Instance instance,
00647                             iBase_EntityHandle entity_handle,
00648                             double x,
00649                             double y,
00650                             double z,
00651                             double* tgnt_i,
00652                             double* tgnt_j,
00653                             double* tgnt_k,
00654                             int* err );
00655 
00656 /**\brief  Get the tangent vector on an entity(ies) at given position(s)
00657  *
00658  * Get the tangent vector on an entity(ies) at given position(s).  If either
00659  * the number of entities or number of coordinate triples is unity, then all
00660  * points or entities are queried for that entity or point, respectively,
00661  * otherwise each point corresponds to each entity.  storage_order should be
00662  * a value in the iBase_StorageOrder enum
00663  * \param instance FBiGeom instance handle
00664  * \param entity_handles Entity(ies) being queried
00665  * \param entity_handles_size Number of entities being queried
00666  * \param storage_order Storage order of coordinates
00667  * \param coordinates Starting coordinates
00668  * \param coordinates_size Number of values in coordinates array
00669  * \param tangents Tangent coordinates
00670  * \param tangents_allocated Allocated size of tangents array
00671  * \param tangents_size Occupied size of tangents array
00672  * \param *err Pointer to error type returned from function
00673  */
00674 void FBiGeom_getArrTgntXYZ( FBiGeom_Instance instance,
00675                             iBase_EntityHandle const* entity_handles,
00676                             int entity_handles_size,
00677                             int storage_order,
00678                             double const* coordinates,
00679                             int coordinates_size,
00680                             double** tangents,
00681                             int* tangents_allocated,
00682                             int* tangents_size,
00683                             int* err );
00684 
00685 /**\brief  Get the two principle curvature vectors for a face at a point
00686  *
00687  * Get the two principle curvature vectors for a face at a point.
00688  * Magnitudes of vectors are curvature, directions are directions of
00689  * principal curvatures.
00690  * \param instance FBiGeom instance handle
00691  * \param face_handle Face being queried
00692  * \param x Position being queried
00693  * \param y Position being queried
00694  * \param z Position being queried
00695  * \param cvtr1_i Maximum curvature vector
00696  * \param cvtr1_j Maximum curvature vector
00697  * \param cvtr1_k Maximum curvature vector
00698  * \param cvtr2_i Minimum curvature vector
00699  * \param cvtr2_j Minimum curvature vector
00700  * \param cvtr2_k Minimum curvature vector
00701  * \param *err Pointer to error type returned from function
00702  */
00703 void FBiGeom_getFcCvtrXYZ( FBiGeom_Instance instance,
00704                            iBase_EntityHandle face_handle,
00705                            double x,
00706                            double y,
00707                            double z,
00708                            double* cvtr1_i,
00709                            double* cvtr1_j,
00710                            double* cvtr1_k,
00711                            double* cvtr2_i,
00712                            double* cvtr2_j,
00713                            double* cvtr2_k,
00714                            int* err );
00715 
00716 /**\brief  Get the principle curvature vector for an edge at a point
00717  *
00718  * Get the principle curvature vector for an edge at a point.  Magnitude of
00719  * vector is the curvature, direction is direction of principal curvature.
00720  * \param instance FBiGeom instance handle
00721  * \param edge_handle Edge being queried
00722  * \param x Position being queried
00723  * \param y Position being queried
00724  * \param z Position being queried
00725  * \param cvtr_i Maximum curvature vector
00726  * \param cvtr_j Maximum curvature vector
00727  * \param cvtr_k Maximum curvature vector
00728  * \param *err Pointer to error type returned from function
00729  */
00730 void FBiGeom_getEgCvtrXYZ( FBiGeom_Instance instance,
00731                            iBase_EntityHandle edge_handle,
00732                            double x,
00733                            double y,
00734                            double z,
00735                            double* cvtr_i,
00736                            double* cvtr_j,
00737                            double* cvtr_k,
00738                            int* err );
00739 
00740 /**\brief  Get the curvature(s) on an entity(ies) at given position(s)
00741  *
00742  * Get the curvature(s) on an entity(ies) at given position(s).  If either
00743  * the number of entities or number of coordinate triples is unity, then all
00744  * points or entities are queried for that entity or point, respectively,
00745  * otherwise each point corresponds to each entity.  storage_order should be
00746  * a value in the iBase_StorageOrder enum.
00747  * \param instance FBiGeom instance handle
00748  * \param entity_handles Entity(ies) being queried
00749  * \param entity_handles_size Number of entities being queried
00750  * \param storage_order Storage order of coordinates
00751  * \param coords Starting coordinates
00752  * \param coords_size Number of values in coordinates array
00753  * \param cvtr_1 First principal curvatures
00754  * \param cvtr_1_allocated Allocated size of first curvature array
00755  * \param cvtr_1_size Occupied size of first curvature array
00756  * \param cvtr_2 Second principal curvatures
00757  * \param cvtr_2_allocated Allocated size of second curvature array
00758  * \param cvtr_2_size Occupied size of second curvature array
00759  * \param *err Pointer to error type returned from function
00760  */
00761 void FBiGeom_getEntArrCvtrXYZ( FBiGeom_Instance instance,
00762                                iBase_EntityHandle const* entity_handles,
00763                                int entity_handles_size,
00764                                int storage_order,
00765                                double const* coords,
00766                                int coords_size,
00767                                double** cvtr_1,
00768                                int* cvtr_1_allocated,
00769                                int* cvtr_1_size,
00770                                double** cvtr_2,
00771                                int* cvtr_2_allocated,
00772                                int* cvtr_2_size,
00773                                int* err );
00774 
00775 /**\brief  Get closest point, tangent, and curvature of edge
00776  *
00777  * Get closest point, tangent, and curvature of edge.
00778  * \param instance FBiGeom instance handle
00779  * \param edge_handle Edge being queried
00780  * \param x Point at which entity is being queried
00781  * \param y Point at which entity is being queried
00782  * \param z Point at which entity is being queried
00783  * \param on_x Closest point at point being queried
00784  * \param on_y Closest point at point being queried
00785  * \param on_z Closest point at point being queried
00786  * \param tgnt_i Tangent at point being queried
00787  * \param tgnt_j Tangent at point being queried
00788  * \param tgnt_k Tangent at point being queried
00789  * \param cvtr_i Curvature at point being queried
00790  * \param cvtr_j Curvature at point being queried
00791  * \param cvtr_k Curvature at point being queried
00792  * \param *err Pointer to error type returned from function
00793  */
00794 void FBiGeom_getEgEvalXYZ( FBiGeom_Instance instance,
00795                            iBase_EntityHandle edge_handle,
00796                            double x,
00797                            double y,
00798                            double z,
00799                            double* on_x,
00800                            double* on_y,
00801                            double* on_z,
00802                            double* tgnt_i,
00803                            double* tgnt_j,
00804                            double* tgnt_k,
00805                            double* cvtr_i,
00806                            double* cvtr_j,
00807                            double* cvtr_k,
00808                            int* err );
00809 
00810 /**\brief  Get closest point, tangent, and curvature of face
00811  *
00812  * Get closest point, tangent, and curvature of face.  If any of input
00813  * coordinate pointers are NULL, that value is not returned.
00814  * \param instance FBiGeom instance handle
00815  * \param face_handle Face being queried
00816  * \param x Point at which entity is being queried
00817  * \param y Point at which entity is being queried
00818  * \param z Point at which entity is being queried
00819  * \param on_x Closest point at point being queried
00820  * \param on_y Closest point at point being queried
00821  * \param on_z Closest point at point being queried
00822  * \param nrml_i Normal at point being queried
00823  * \param nrml_j Normal at point being queried
00824  * \param nrml_k Normal at point being queried
00825  * \param cvtr1_i First principal curvature at point being queried
00826  * \param cvtr1_j First principal curvature at point being queried
00827  * \param cvtr1_k First principal curvature at point being queried
00828  * \param cvtr2_i Second principal curvature at point being queried
00829  * \param cvtr2_j Second principal curvature at point being queried
00830  * \param cvtr2_k Second principal curvature at point being queried
00831  * \param *err Pointer to error type returned from function
00832  */
00833 void FBiGeom_getFcEvalXYZ( FBiGeom_Instance instance,
00834                            iBase_EntityHandle face_handle,
00835                            double x,
00836                            double y,
00837                            double z,
00838                            double* on_x,
00839                            double* on_y,
00840                            double* on_z,
00841                            double* nrml_i,
00842                            double* nrml_j,
00843                            double* nrml_k,
00844                            double* cvtr1_i,
00845                            double* cvtr1_j,
00846                            double* cvtr1_k,
00847                            double* cvtr2_i,
00848                            double* cvtr2_j,
00849                            double* cvtr2_k,
00850                            int* err );
00851 
00852 /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
00853  *         entity(ies) at given position(s)
00854  *
00855  * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
00856  * at given position(s).  If either the number of entities or number of
00857  * coordinate triples is unity, then all points or entities are queried for
00858  * that entity or point, respectively, otherwise each point corresponds to
00859  * each entity.  storage_order should be a value in the iBase_StorageOrder
00860  * enum.
00861  * \param instance FBiGeom instance handle
00862  * \param edge_handles Edge(s) being queried
00863  * \param edge_handles_size Number of edges being queried
00864  * \param storage_order Storage order of coordinates
00865  * \param coords Starting coordinates
00866  * \param coords_size Number of values in coordinates array
00867  * \param on_coords Closest point array
00868  * \param on_coords_allocated Allocated size of closest point array
00869  * \param on_coords_size Occupied size of closest point array
00870  * \param tangent Tangent array
00871  * \param tangent_allocated Allocated size of tangent array
00872  * \param tangent_size Occupied size of tangent array
00873  * \param cvtr First principal curvatures
00874  * \param cvtr_allocated Allocated size of first curvature array
00875  * \param cvtr_size Occupied size of first curvature array
00876  * \param *err Pointer to error type returned from function
00877  */
00878 void FBiGeom_getArrEgEvalXYZ( FBiGeom_Instance instance,
00879                               iBase_EntityHandle const* edge_handles,
00880                               int edge_handles_size,
00881                               int storage_order,
00882                               double const* coords,
00883                               int coords_size,
00884                               double** on_coords,
00885                               int* on_coords_allocated,
00886                               int* on_coords_size,
00887                               double** tangent,
00888                               int* tangent_allocated,
00889                               int* tangent_size,
00890                               double** cvtr,
00891                               int* cvtr_allocated,
00892                               int* cvtr_size,
00893                               int* err );
00894 
00895 /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
00896  *         entity(ies) at given position(s)
00897  *
00898  * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
00899  * at given position(s).  If either the number of entities or number of
00900  * coordinate triples is unity, then all points or entities are queried for
00901  * that entity or point, respectively, otherwise each point corresponds to
00902  * each entity.  storage_order should be a value in the iBase_StorageOrder
00903  * enum.
00904  * \param instance FBiGeom instance handle
00905  * \param edge_handles Edge(s) being queried
00906  * \param edge_handles_size Number of edges being queried
00907  * \param storage_order Storage order of coordinates
00908  * \param coords Starting coordinates
00909  * \param coords_size Number of values in coordinates array
00910  * \param on_coords Closest point array
00911  * \param on_coords_allocated Allocated size of closest point array
00912  * \param on_coords_size Occupied size of closest point array
00913  * \param normal Normal array
00914  * \param normal_allocated Allocated size of normal array
00915  * \param normal_size Occupied size of normal array
00916  * \param cvtr_1 First principal curvatures
00917  * \param cvtr_1_allocated Allocated size of first curvature array
00918  * \param cvtr_1_size Occupied size of first curvature array
00919  * \param cvtr_2 Second principal curvatures
00920  * \param cvtr_2_allocated Allocated size of second curvature array
00921  * \param cvtr_2_size Occupied size of second curvature array
00922  * \param *err Pointer to error type returned from function
00923  */
00924 void FBiGeom_getArrFcEvalXYZ( FBiGeom_Instance instance,
00925                               iBase_EntityHandle const* face_handles,
00926                               int face_handles_size,
00927                               int storage_order,
00928                               double const* coords,
00929                               int coords_size,
00930                               double** on_coords,
00931                               int* on_coords_allocated,
00932                               int* on_coords_size,
00933                               double** normal,
00934                               int* normal_allocated,
00935                               int* normal_size,
00936                               double** cvtr1,
00937                               int* cvtr1_allocated,
00938                               int* cvtr1_size,
00939                               double** cvtr2,
00940                               int* cvtr2_allocated,
00941                               int* cvtr2_size,
00942                               int* err );
00943 
00944 /**\brief  Get the bounding box of the specified entity
00945  *
00946  * Get the bounding box of the specified entity
00947  * \param instance FBiGeom instance handle
00948  * \param entity_handle Entity being queried
00949  * \param min_x Minimum coordinate of bounding box
00950  * \param min_y Minimum coordinate of bounding box
00951  * \param min_z Minimum coordinate of bounding box
00952  * \param max_x Maximum coordinate of bounding box
00953  * \param max_y Maximum coordinate of bounding box
00954  * \param max_z Maximum coordinate of bounding box
00955  * \param *err Pointer to error type returned from function
00956  */
00957 void FBiGeom_getEntBoundBox( FBiGeom_Instance instance,
00958                              iBase_EntityHandle entity_handle,
00959                              double* min_x,
00960                              double* min_y,
00961                              double* min_z,
00962                              double* max_x,
00963                              double* max_y,
00964                              double* max_z,
00965                              int* err );
00966 
00967 /**\brief  Get the bounding box of the specified entities
00968  *
00969  * Get the bounding box of the specified entities.  Storage order passed in
00970  * should be a member of iBase_StorageOrder enum.
00971  * \param instance FBiGeom instance handle
00972  * \param entity_handles Entity handles being queried
00973  * \param enttiy_handles_size Number of entities being queried
00974  * \param storage_order Storage order of coordinates passed back
00975  * \param min_corner Minimum coordinates of bounding boxes
00976  * \param min_corner_allocated Allocated size of minimum coordinates array
00977  * \param min_corner_size Occupied size of minimum coordinates array
00978  * \param max_corner Maximum coordinates of bounding boxes
00979  * \param max_corner_allocated Allocated size of maximum coordinates array
00980  * \param max_corner_size Occupied size of maximum coordinates array
00981  * \param *err Pointer to error type returned from function
00982  */
00983 void FBiGeom_getArrBoundBox( FBiGeom_Instance instance,
00984                              iBase_EntityHandle const* entity_handles,
00985                              int entity_handles_size,
00986                              int storage_order,
00987                              double** min_corner,
00988                              int* min_corner_allocated,
00989                              int* min_corner_size,
00990                              double** max_corner,
00991                              int* max_corner_allocated,
00992                              int* max_corner_size,
00993                              int* err );
00994 
00995 /**\brief  Get coordinates of specified vertex
00996  *
00997  * Get coordinates of specified vertex.
00998  * \param instance FBiGeom instance handle
00999  * \param vertex_handle Geom vertex being queried
01000  * \param *x Pointer to x coordinate returned from function
01001  * \param *y Pointer to y coordinate returned from function
01002  * \param *z Pointer to z coordinate returned from function
01003  * \param *err Pointer to error type returned from function
01004  */
01005 void FBiGeom_getVtxCoord( FBiGeom_Instance instance,
01006                           iBase_EntityHandle vertex_handle,
01007                           double* x,
01008                           double* y,
01009                           double* z,
01010                           int* err );
01011 
01012 /**\brief  Get coordinates of specified vertices
01013  *
01014  * Get coordinates of specified vertices.  If storage order is passed in
01015  * with a value other than iBase_UNDETERMINED, coordinates are returned
01016  * in the specified storage order, otherwise storage order is that native
01017  * to the implementation.  Storage order of returned coordinates is also
01018  * returned.
01019  * \param instance FBiGeom instance handle
01020  * \param vertex_handles Array of geom vertex handles whose coordinates are
01021  *        being requested
01022  * \param vertex_handles_size Number of vertices in vertex_handles array
01023  * \param storage_order Storage order requested for coordinate data
01024  * \param *coords Pointer to array of coordinates returned from function
01025  * \param *coords_allocated Pointer to allocated size of coords array
01026  * \param *coords_size Pointer to occupied size of coords array
01027  * \param *err Pointer to error type returned from function
01028  */
01029 void FBiGeom_getVtxArrCoords( FBiGeom_Instance instance,
01030                               iBase_EntityHandle const* entity_handles,
01031                               int entity_handles_size,
01032                               int storage_order,
01033                               double** coordinates,
01034                               int* coordinates_allocated,
01035                               int* coordinates_size,
01036                               int* err );
01037 
01038 /**\brief  Intersect a ray with the model
01039  *
01040  * Intersect a ray with the model.  Storage orders passed in should be a
01041  * member of the iBase_StorageOrder enumeration.
01042  * \param instance FBiGeom instance handle
01043  * \param x Point from which ray is fired
01044  * \param y Point from which ray is fired
01045  * \param z Point from which ray is fired
01046  * \param dir_x Direction in which ray is fired
01047  * \param dir_y Direction in which ray is fired
01048  * \param dir_z Direction in which ray is fired
01049  * \param intersect_entity_handles Entities intersected by ray
01050  * \param intersect_entity_handles_allocated Allocated size of
01051  *        intersections array
01052  * \param intersect_entity_hangles_size Occupied size of intersections array
01053  * \param storage_order Storage order of coordinates passed back
01054  * \param intersect_coords Coordinates of intersections
01055  * \param intersect_coords_allocated Allocated size of coordinates array
01056  * \param intersect_coords_size Occupied size of coordinates array
01057  * \param param_coords Distances along ray of intersections
01058  * \param param_coords_allocated Allocated size of param_coords array
01059  * \param param_coords_size Occupied size of param_coords array
01060  * \param *err Pointer to error type returned from function
01061  */
01062 void FBiGeom_getPntRayIntsct( FBiGeom_Instance instance,
01063                               double x,
01064                               double y,
01065                               double z,
01066                               double dir_x,
01067                               double dir_y,
01068                               double dir_z,
01069                               iBase_EntityHandle** intersect_entity_handles,
01070                               int* intersect_entity_handles_allocated,
01071                               int* intersect_entity_hangles_size,
01072                               int storage_order,
01073                               double** intersect_coords,
01074                               int* intersect_coords_allocated,
01075                               int* intersect_coords_size,
01076                               double** param_coords,
01077                               int* param_coords_allocated,
01078                               int* param_coords_size,
01079                               int* err );
01080 
01081 /**\brief  Intersect an array of rays with the model
01082  *
01083  * Intersect an array of rays with the model.  Storage order passed in is
01084  * a member of the iBase_StorageOrder enumeration.
01085  * \param instance FBiGeom instance handle
01086  * \param storage_order Storage order of input coordinates
01087  * \param coords Points from which rays are fired
01088  * \param coords_size Number of points from which rays are fired
01089  * \param directions Directions in which rays are fired
01090  * \param directions_size Number of coordinates in directions array
01091  * \param intersect_entity_handles Entities intersected by ray
01092  * \param intersect_entity_handles_allocated Allocated size of intersections
01093  *        array
01094  * \param intersect_entity_hangles_size Occupied size of intersections array
01095  * \param offset Offset[i] is offset into intersect_entity_handles of ith
01096  *        ray
01097  * \param offset_allocated Allocated size of offset array
01098  * \param offset_size Occupied size of offset array
01099  * \param storage_order Storage order of coordinates passed back
01100  * \param intersect_coords Coordinates of intersections
01101  * \param intersect_coords_allocated Allocated size of coordinates array
01102  * \param intersect_coords_size Occupied size of coordinates array
01103  * \param param_coords Distances along ray of intersections
01104  * \param param_coords_allocated Allocated size of param_coords array
01105  * \param param_coords_size Occupied size of param_coords array
01106  * \param *err Pointer to error type returned from function
01107  */
01108 void FBiGeom_getPntArrRayIntsct( FBiGeom_Instance instance,
01109                                  int storage_order,
01110                                  const double* coords,
01111                                  int coords_size,
01112                                  const double* directions,
01113                                  int directions_size,
01114                                  iBase_EntityHandle** intersect_entity_handles,
01115                                  int* intersect_entity_handles_allocated,
01116                                  int* intersect_entity_hangles_size,
01117                                  int** offset,
01118                                  int* offset_allocated,
01119                                  int* offset_size,
01120                                  double** intersect_coords,
01121                                  int* intersect_coords_allocated,
01122                                  int* intersect_coords_size,
01123                                  double** param_coords,
01124                                  int* param_coords_allocated,
01125                                  int* param_coords_size,
01126                                  int* err );
01127 
01128 /**\brief  Get the entity on which a point is located
01129  *
01130  * Get the entity on which a point is located
01131  * \param instance FBiGeom instance handle
01132  * \param x Point being queried
01133  * \param y Point being queried
01134  * \param z Point being queried
01135  * \param entity_handle Entity on which point is located
01136  * \param *err Pointer to error type returned from function
01137  */
01138 void FBiGeom_getPntClsf( FBiGeom_Instance instance,
01139                          double x,
01140                          double y,
01141                          double z,
01142                          iBase_EntityHandle* entity_handle,
01143                          int* err );
01144 
01145 /**\brief  Get the entities on which points are located
01146  *
01147  * Get the entities on which points are located.  Storage orders should be
01148  * members of the iBase_StorageOrder enumeration.
01149  * \param instance FBiGeom instance handle
01150  * \param storage_order Storage order of coordinates in coords
01151  * \param coords Points being queried
01152  * \param coords_size Number of entries in coords array
01153  * \param entity_handles Entities on which points are located
01154  * \param entity_handles_allocated Allocated size of entity_handles array
01155  * \param entity_handles_size Occupied size of entity_handles array
01156  * \param *err Pointer to error type returned from function
01157  */
01158 void FBiGeom_getPntArrClsf( FBiGeom_Instance instance,
01159                             int storage_order,
01160                             double const* coords,
01161                             int coords_size,
01162                             iBase_EntityHandle** entity_handles,
01163                             int* entity_handles_allocated,
01164                             int* entity_handles_size,
01165                             int* err );
01166 
01167 /**\brief  Get the sense of a face with respect to a region
01168  *
01169  * Get the sense of a face with respect to a region.  Sense returned is -1,
01170  * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
01171  * indicates that face bounds the region once with each sense.
01172  * \param instance FBiGeom instance handle
01173  * \param face Face being queried
01174  * \param region Region being queried
01175  * \param sense_out Sense of face with respect to region
01176  * \param *err Pointer to error type returned from function
01177  */
01178 void FBiGeom_getEntNrmlSense( FBiGeom_Instance instance,
01179                               iBase_EntityHandle face,
01180                               iBase_EntityHandle region,
01181                               int* sense_out,
01182                               int* err );
01183 
01184 /**\brief  Get the senses of an array of faces with respect to an array of
01185  *         regions
01186  *
01187  * Get the senses of an array of faces with respect to an array of regions.
01188  * Sense returned is -1, 0, or 1, representing "reversed", "both", or
01189  * "forward".  "both" sense indicates that face bounds the region once with
01190  * each sense.
01191  * \param instance FBiGeom instance handle
01192  * \param face_handles Faces being queried
01193  * \param face_handles_size Size of face handles array
01194  * \param region_handles Regions being queried
01195  * \param region_handles_size Size of region handles array
01196  * \param sense Senses of faces with respect to regions
01197  * \param sense_allocated Allocated size of senses array
01198  * \param sense_size Occupied size of senses array
01199  * \param *err Pointer to error type returned from function
01200  */
01201 void FBiGeom_getArrNrmlSense( FBiGeom_Instance instance,
01202                               iBase_EntityHandle const* face_handles,
01203                               int face_handles_size,
01204                               iBase_EntityHandle const* region_handles,
01205                               int region_handles_size,
01206                               int** sense,
01207                               int* sense_allocated,
01208                               int* sense_size,
01209                               int* err );
01210 
01211 /**\brief  Get the sense of an edge with respect to a face
01212  *
01213  * Get the sense of an edge with respect to a face.  Sense returned is -1,
01214  * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
01215  * indicates that edge bounds the face once with each sense.
01216  * \param instance FBiGeom instance handle
01217  * \param edge Edge being queried
01218  * \param face Face being queried
01219  * \param sense_out Sense of edge with respect to face
01220  * \param *err Pointer to error type returned from function
01221  */
01222 void FBiGeom_getEgFcSense( FBiGeom_Instance,
01223                            iBase_EntityHandle edge,
01224                            iBase_EntityHandle face,
01225                            int* sense_out,
01226                            int* err );
01227 
01228 /**\brief  Get the senses of an array of edges with respect to an array of
01229  *         faces
01230  *
01231  * Get the senses of an array of edges with respect to an array of faces.
01232  * Sense returned is -1, 0, or 1, representing "reversed", "both", or
01233  * "forward".  "both" sense indicates that edge bounds the face once with
01234  * each sense.
01235  * \param instance FBiGeom instance handle
01236  * \param edge_handles Edges being queried
01237  * \param edge_handles_size Size of edge handles array
01238  * \param face_handles Faces being queried
01239  * \param face_handles_size Size of face handles array
01240  * \param sense Senses of faces with respect to regions
01241  * \param sense_allocated Allocated size of senses array
01242  * \param sense_size Occupied size of senses array
01243  * \param *err Pointer to error type returned from function
01244  */
01245 void FBiGeom_getEgFcArrSense( FBiGeom_Instance instance,
01246                               iBase_EntityHandle const* edge_handles,
01247                               int edge_handles_size,
01248                               iBase_EntityHandle const* face_handles,
01249                               int face_handles_size,
01250                               int** sense,
01251                               int* sense_allocated,
01252                               int* sense_size,
01253                               int* err );
01254 
01255 /**\brief  Get the sense of a vertex pair with respect to an edge
01256  *
01257  * Get the sense of a vertex pair with respect to an edge.  Sense returned
01258  * is -1, 0, or 1, representing "reversed", "both", or "forward".  "both"
01259  * sense indicates that vertices are identical and that vertex bounds both
01260  * sides of the edge.
01261  * \param instance FBiGeom instance handle
01262  * \param edge Edge being queried
01263  * \param vertex1 First vertex being queried
01264  * \param vertex2 Second vertex being queried
01265  * \param sense_out Sense of vertex pair with respect to edge
01266  * \param *err Pointer to error type returned from function
01267  */
01268 void FBiGeom_getEgVtxSense( FBiGeom_Instance instance,
01269                             iBase_EntityHandle edge,
01270                             iBase_EntityHandle vertex1,
01271                             iBase_EntityHandle vertex2,
01272                             int* sense_out,
01273                             int* err );
01274 
01275 /**\brief  Get the senses of vertex pair with respect to a edges
01276  *
01277  * Get the senses of vertex pairs with respect to edges.  Sense returned is
01278  * -1, 0, or 1, representing "reversed", "both", or "forward".  "both" sense
01279  * indicates that both vertices in pair are identical and that vertex bounds
01280  * both sides of the edge.
01281  * \param instance FBiGeom instance handle
01282  * \param edge_handles Edges being queried
01283  * \param edge_handles_size Number of edges being queried
01284  * \param vertex_handles_1 First vertex being queried
01285  * \param vertex_handles_1_size Number of vertices in vertices array
01286  * \param vertex_handles_2 Second vertex being queried
01287  * \param vertex_handles_2_size Number of vertices in vertices array
01288  * \param sense Sense of vertex pair with respect to edge
01289  * \param sense_allocated Allocated size of sense array
01290  * \param sense_size Occupied size of sense array
01291  * \param *err Pointer to error type returned from function
01292  */
01293 void FBiGeom_getEgVtxArrSense( FBiGeom_Instance instance,
01294                                iBase_EntityHandle const* edge_handles,
01295                                int edge_handles_size,
01296                                iBase_EntityHandle const* vertex_handles_1,
01297                                int veretx_handles_1_size,
01298                                iBase_EntityHandle const* vertex_handles_2,
01299                                int vertex_handles_2_size,
01300                                int** sense,
01301                                int* sense_allocated,
01302                                int* sense_size,
01303                                int* err );
01304 
01305 /**\brief  Return the measure (length, area, or volume) of entities
01306  *
01307  * Return the measure (length, area, or volume) of entities
01308  * \param instance FBiGeom instance handle
01309  * \param entity_handles Array of entities being queried
01310  * \param entity_handles_size Number of entities in entity array
01311  * \param measures Measures of entities being queried
01312  * \param measures_allocated Allocated size of measures array
01313  * \param measures_size Occupied size of measures array
01314  * \param *err Pointer to error type returned from function
01315  */
01316 void FBiGeom_measure( FBiGeom_Instance instance,
01317                       iBase_EntityHandle const* entity_handles,
01318                       int entity_handles_size,
01319                       double** measures,
01320                       int* measures_allocated,
01321                       int* measures_size,
01322                       int* err );
01323 
01324 /**\brief  Get the geometric type of a face
01325  *
01326  * Get the geometric type of a face.  Specific types depend on
01327  * implementation.
01328  * \param instance FBiGeom instance handle
01329  * \param face_handle Face being queried
01330  * \param face_type Face type
01331  * \param face_type_length Length of face type string
01332  */
01333 void FBiGeom_getFaceType( FBiGeom_Instance instance,
01334                           iBase_EntityHandle face_handle,
01335                           char* face_type,
01336                           int* err,
01337                           int* face_type_length );
01338 
01339 /**\brief  Return whether interface has information about parameterization
01340  *
01341  * Return whether an interface has information about parameterization (!=0)
01342  * or not (0)
01343  * \param instance FBiGeom instance handle
01344  * \param is_parametric If non-zero, interface has information about
01345  *        parameterization
01346  * \param *err Pointer to error type returned from function
01347  */
01348 void FBiGeom_getParametric( FBiGeom_Instance instance, int* is_parametric, int* err );
01349 
01350 /**\brief  Return whether an entity has a parameterization
01351  *
01352  * Return whether an entity has a parameterization (=1) or not (=0)
01353  * \param instance FBiGeom instance handle
01354  * \param entity_handle Entity being queried
01355  * \param is_parametric Entity has a parameterization (=1) or not (=0)
01356  * \param *err Pointer to error type returned from function
01357  */
01358 void FBiGeom_isEntParametric( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* parametric, int* err );
01359 
01360 /**\brief  Return whether entities have parameterizations
01361  *
01362  * Return whether entities have parameterizations (=1) or not (=0)
01363  * \param instance FBiGeom instance handle
01364  * \param entity_handles Entities being queried
01365  * \param entity_handles_size Number of entities being queried
01366  * \param is_parametric entity_handles[i] has a parameterization (=1) or
01367  *        not (=0)
01368  * \param is_parametric_allocated Allocated size of is_parametric array
01369  * \param is_parametric_size Occupied size of is_parametric array
01370  * \param *err Pointer to error type returned from function
01371  */
01372 void FBiGeom_isArrParametric( FBiGeom_Instance instance,
01373                               iBase_EntityHandle const* entity_handles,
01374                               int entity_handles_size,
01375                               int** is_parametric,
01376                               int* is_parametric_allocated,
01377                               int* is_parametric_size,
01378                               int* err );
01379 
01380 /**\brief  Return coordinate position at specified parametric position on
01381  *         entity
01382  *
01383  * Return coordinate position at specified parametric position on entity.
01384  * \param instance FBiGeom instance handle
01385  * \param entity_handle Entity being queried
01386  * \param u Parametric coordinate being queried
01387  * \param v Parametric coordinate being queried
01388  * \param x Spatial coordinate at parametric position being queried
01389  * \param y Spatial coordinate at parametric position being queried
01390  * \param z Spatial coordinate at parametric position being queried
01391  * \param *err Pointer to error type returned from function
01392  */
01393 void FBiGeom_getEntUVtoXYZ( FBiGeom_Instance instance,
01394                             iBase_EntityHandle entity_handle,
01395                             double u,
01396                             double v,
01397                             double* x,
01398                             double* y,
01399                             double* z,
01400                             int* err );
01401 
01402 /**\brief  Return coordinate positions at specified parametric position(s)
01403  *         on entity(ies)
01404  *
01405  * Return coordinate positions at specified parametric position(s) on
01406  * entity(ies).  If either the number of entities or number of parametric
01407  * coordinate pairs is unity, then all points or entities are queried for
01408  * that entity or point, respectively, otherwise each point corresponds to
01409  * each entity.  storage_order should be a value in the iBase_StorageOrder
01410  * enum.
01411  * \param instance FBiGeom instance handle
01412  * \param entity_handles Entities being queried
01413  * \param entity_handles_size Number of entities being queried
01414  * \param storage_order Storage order of uv coordinates input and xyz
01415  *        coordinate output
01416  * \param uv Coordinates being queried
01417  * \param uv_size Number of coordinates in array
01418  * \param coordinates Coordinates of parametric positions
01419  * \param coordinates_allocated Allocated size of coordinates array
01420  * \param coordinates_size Occupied size of coordinates array
01421  * \param *err Pointer to error type returned from function
01422  */
01423 void FBiGeom_getArrUVtoXYZ( FBiGeom_Instance instance,
01424                             iBase_EntityHandle const* entity_handles,
01425                             int entity_handles_size,
01426                             int storage_order,
01427                             double const* uv,
01428                             int uv_size,
01429                             double** coordinates,
01430                             int* coordinates_allocated,
01431                             int* coordinates_size,
01432                             int* err );
01433 
01434 /**\brief  Return coordinate position at specified parametric position on
01435  *         entity
01436  *
01437  * Return coordinate position at specified parametric position on entity.
01438  * \param instance FBiGeom instance handle
01439  * \param entity_handle Entity being queried
01440  * \param u Parametric coordinate being queried
01441  * \param x Spatial coordinate at parametric position being queried
01442  * \param y Spatial coordinate at parametric position being queried
01443  * \param z Spatial coordinate at parametric position being queried
01444  * \param *err Pointer to error type returned from function
01445  */
01446 void FBiGeom_getEntUtoXYZ( FBiGeom_Instance instance,
01447                            iBase_EntityHandle entity_handle,
01448                            double u,
01449                            double* x,
01450                            double* y,
01451                            double* z,
01452                            int* err );
01453 
01454 /**\brief  Return coordinate positions at specified parametric position(s)
01455  *         on entity(ies)
01456  *
01457  * Return coordinate positions at specified parametric position(s) on
01458  * entity(ies). If either the number of entities or number of parametric
01459  * coordinate pairs is unity, then all points or entities are queried for
01460  * that entity or point, respectively, otherwise each point corresponds to
01461  * each entity.  storage_order should be a value in the iBase_StorageOrder
01462  * enum.
01463  * \param instance FBiGeom instance handle
01464  * \param entity_handles Entities being queried
01465  * \param entity_handles_size Number of entities being queried
01466  * \param storage_order Storage order of resulting coordinates
01467  * \param uv Coordinates being queried
01468  * \param uv_size Number of coordinates in array
01469  * \param coordinates Coordinates of parametric positions
01470  * \param coordinates_allocated Allocated size of coordinates array
01471  * \param coordinates_size Occupied size of coordinates array
01472  * \param *err Pointer to error type returned from function
01473  */
01474 void FBiGeom_getArrUtoXYZ( FBiGeom_Instance instance,
01475                            iBase_EntityHandle const* entity_handles,
01476                            int entity_handles_size,
01477                            double const* u,
01478                            int u_size,
01479                            int storage_order,
01480                            double** on_coords,
01481                            int* on_coords_allocated,
01482                            int* on_coords_size,
01483                            int* err );
01484 
01485 /**\brief  Return parametric position at specified spatial position on
01486  *         entity
01487  *
01488  * Return parametric position at specified spatial position on entity
01489  * \param instance FBiGeom instance handle
01490  * \param entity_handle Entity being queried
01491  * \param x Spatial coordinate being queried
01492  * \param y Spatial coordinate being queried
01493  * \param z Spatial coordinate being queried
01494  * \param u Parametric coordinate at spatial position being queried
01495  * \param v Parametric coordinate at spatial position being queried
01496  * \param *err Pointer to error type returned from function
01497  */
01498 void FBiGeom_getEntXYZtoUV( FBiGeom_Instance instance,
01499                             iBase_EntityHandle entity_handle,
01500                             double x,
01501                             double y,
01502                             double z,
01503                             double* u,
01504                             double* v,
01505                             int* err );
01506 
01507 /**\brief  Return parametric position at specified spatial position on
01508  *         entity
01509  *
01510  * Return parametric position at specified spatial position on entity
01511  * \param instance FBiGeom instance handle
01512  * \param entity_handle Entity being queried
01513  * \param x Spatial coordinate being queried
01514  * \param y Spatial coordinate being queried
01515  * \param z Spatial coordinate being queried
01516  * \param u Parametric coordinate at spatial position being queried
01517  * \param *err Pointer to error type returned from function
01518  */
01519 void FBiGeom_getEntXYZtoU( FBiGeom_Instance instance,
01520                            iBase_EntityHandle entity_handle,
01521                            double x,
01522                            double y,
01523                            double z,
01524                            double* u,
01525                            int* err );
01526 
01527 /**\brief  Return parametric positions at specified spatial position(s) on
01528  *         entity(ies)
01529  * Return parametric positions at specified spatial position(s) on
01530  * entity(ies).  If either the number of entities or number of spatial
01531  * coordinate triples is unity, then all points or entities are queried for
01532  * that entity or point, respectively, otherwise each point corresponds to
01533  * each entity.  storage_order should be a value in the iBase_StorageOrder
01534  * enum.
01535  * \param instance FBiGeom instance handle
01536  * \param entity_handles Entities being queried
01537  * \param entity_handles_size Number of entities being queried
01538  * \param storage_order Storage order of spatial coordinates input
01539  * \param coordinates Coordinates being queried
01540  * \param coordinates_size Number of coordinates in array
01541  * \param uv Coordinates of parametric positions
01542  * \param uv_allocated Allocated size of coordinates array
01543  * \param uv_size Occupied size of coordinates array
01544  * \param *err Pointer to error type returned from function
01545  */
01546 void FBiGeom_getArrXYZtoUV( FBiGeom_Instance instance,
01547                             iBase_EntityHandle const* entity_handles,
01548                             int entity_handles_size,
01549                             int storage_order,
01550                             double const* coordinates,
01551                             int coordinates_size,
01552                             double** uv,
01553                             int* uv_allocated,
01554                             int* uv_size,
01555                             int* err );
01556 
01557 /**\brief  Return spatial positions at specified parametric position(s) on
01558  *         entity(ies)
01559  *
01560  * Return spatial positions at specified parametric position(s) on
01561  * entity(ies). If either the number of entities or number of spatial
01562  * coordinate triples is unity, then all points or entities are queried for
01563  * that entity or point, respectively, otherwise each point corresponds to
01564  * each entity.  storage_order should be a value in the iBase_StorageOrder
01565  * enum.
01566  * \param instance FBiGeom instance handle
01567  * \param entity_handles Entities being queried
01568  * \param entity_handles_size Number of entities being queried
01569  * \param storage_order Storage order of spatial coordinates input
01570  * \param coordinates Coordinates being queried
01571  * \param coordinates_size Number of coordinates in array
01572  * \param u Coordinates of parametric positions
01573  * \param u_allocated Allocated size of coordinates array
01574  * \param u_size Occupied size of coordinates array
01575  * \param *err Pointer to error type returned from function
01576  */
01577 void FBiGeom_getArrXYZtoU( FBiGeom_Instance instance,
01578                            iBase_EntityHandle const* entity_handles,
01579                            int entity_handles_size,
01580                            int storage_order,
01581                            double const* coordinates,
01582                            int coordinates_size,
01583                            double** u,
01584                            int* u_allocated,
01585                            int* u_size,
01586                            int* err );
01587 
01588 /**\brief  Return parametric position at specified spatial position on
01589  *         entity, based on parametric position hint
01590  *
01591  * Return parametric position at specified spatial position on entity,
01592  * based on parametric position hint.  For this function, u and v are input
01593  * with parameters from which to start search. Typically this will reduce
01594  * the search time for new parametric coordinates.
01595  * \param instance FBiGeom instance handle
01596  * \param entity_handle Entity being queried
01597  * \param x Spatial coordinate being queried
01598  * \param y Spatial coordinate being queried
01599  * \param z Spatial coordinate being queried
01600  * \param u Parametric coordinate at spatial position being queried
01601  * \param v Parametric coordinate at spatial position being queried
01602  * \param *err Pointer to error type returned from function
01603  */
01604 void FBiGeom_getEntXYZtoUVHint( FBiGeom_Instance instance,
01605                                 iBase_EntityHandle entity_handle,
01606                                 double x,
01607                                 double y,
01608                                 double z,
01609                                 double* u,
01610                                 double* v,
01611                                 int* err );
01612 
01613 /**\brief  Return parametric positions at specified spatial position(s) on
01614  *         entity(ies), based on parametric position hints
01615  * Return parametric positions at specified spatial position(s) on
01616  * entity(ies), based on parametric position hints.  If either the number of
01617  * entities or number of spatial coordinate triples is unity, then all
01618  * points or entities are queried for that entity or point, respectively,
01619  * otherwise each point corresponds to each entity.  storage_order should be
01620  * a value in the iBase_StorageOrder enum.
01621  * \param instance FBiGeom instance handle
01622  * \param entity_handles Entities being queried
01623  * \param entity_handles_size Number of entities being queried
01624  * \param storage_order Storage order of spatial coordinates input
01625  * \param coordinates Coordinates being queried
01626  * \param coordinates_size Number of coordinates in array
01627  * \param uv Coordinates of parametric positions
01628  * \param uv_allocated Allocated size of coordinates array
01629  * \param uv_size Occupied size of coordinates array
01630  * \param *err Pointer to error type returned from function
01631  */
01632 void FBiGeom_getArrXYZtoUVHint( FBiGeom_Instance instance,
01633                                 iBase_EntityHandle const* entity_handles,
01634                                 int entity_handles_size,
01635                                 int storage_order,
01636                                 double const* coords,
01637                                 int coords_size,
01638                                 double** uv,
01639                                 int* uv_allocated,
01640                                 int* uv_size,
01641                                 int* err );
01642 
01643 /**\brief  Get parametric range of entity
01644  *
01645  * Get parametric range of entity
01646  * \param instance FBiGeom instance handle
01647  * \param entity_handle Entity being queried
01648  * \param u_min Minimum parametric coordinate for entity
01649  * \param v_min Minimum parametric coordinate for entity
01650  * \param u_max Maximum parametric coordinate for entity
01651  * \param v_max Maximum parametric coordinate for entity
01652  * \param *err Pointer to error type returned from function
01653  */
01654 void FBiGeom_getEntUVRange( FBiGeom_Instance instance,
01655                             iBase_EntityHandle entity_handle,
01656                             double* u_min,
01657                             double* v_min,
01658                             double* u_max,
01659                             double* v_max,
01660                             int* err );
01661 
01662 /**\brief  Get parametric range of entity
01663  *
01664  * Get parametric range of entity
01665  * \param instance FBiGeom instance handle
01666  * \param entity_handle Entity being queried
01667  * \param u_min Minimum parametric coordinate for entity
01668  * \param u_max Maximum parametric coordinate for entity
01669  * \param *err Pointer to error type returned from function
01670  */
01671 void FBiGeom_getEntURange( FBiGeom_Instance instance,
01672                            iBase_EntityHandle entity_handle,
01673                            double* u_min,
01674                            double* u_max,
01675                            int* err );
01676 
01677 /**\brief  Get parametric range of entities
01678  *
01679  * Get parametric range of entities
01680  * \param instance FBiGeom instance handle
01681  * \param entity_handles Entities being queried
01682  * \param entity_handles_size Number of entities being queried
01683  * \param storage_order Storage order of parametric coordinates being
01684  *        returned
01685  * \param uv_min Minimum parametric coordinate for entities
01686  * \param uv_min_allocated Allocated size of minimum parametric coordinate
01687  *        array
01688  * \param uv_min_size Occupied size of minimum parametric coordinate array
01689  * \param uv_max Maximum parametric coordinate for entities
01690  * \param uv_max_allocated Allocated size of maximum parametric coordinate
01691  *        array
01692  * \param uv_max_size Occupied size of maximum parametric coordinate array
01693  * \param *err Pointer to error type returned from function
01694  */
01695 void FBiGeom_getArrUVRange( FBiGeom_Instance instance,
01696                             iBase_EntityHandle const* entity_handles,
01697                             int entity_handles_size,
01698                             int storage_order,
01699                             double** uv_min,
01700                             int* uv_min_allocated,
01701                             int* uv_min_size,
01702                             double** uv_max,
01703                             int* uv_max_allocated,
01704                             int* uv_max_size,
01705                             int* err );
01706 
01707 /**\brief  Get parametric range of entities
01708  *
01709  * Get parametric range of entities
01710  * \param instance FBiGeom instance handle
01711  * \param entity_handles Entities being queried
01712  * \param entity_handles_size Number of entities being queried
01713  * \param storage_order Storage order of parametric coordinates being
01714  *        returned
01715  * \param u_min Minimum parametric coordinate for entities
01716  * \param u_min_allocated Allocated size of minimum parametric coordinate
01717  *        array
01718  * \param u_min_size Occupied size of minimum parametric coordinate array
01719  * \param u_max Maximum parametric coordinate for entities
01720  * \param u_max_allocated Allocated size of maximum parametric coordinate
01721  *        array
01722  * \param u_max_size Occupied size of maximum parametric coordinate array
01723  * \param *err Pointer to error type returned from function
01724  */
01725 void FBiGeom_getArrURange( FBiGeom_Instance instance,
01726                            iBase_EntityHandle const* entity_handles,
01727                            int entity_handles_size,
01728                            double** u_min,
01729                            int* u_min_allocated,
01730                            int* u_min_size,
01731                            double** u_max,
01732                            int* u_max_allocated,
01733                            int* u_max_size,
01734                            int* err );
01735 
01736 /**\brief  Return the face parametric coordinates for a parametric position
01737  *         on a bounding edge
01738  *
01739  * Return the face parametric coordinates for a parametric position on a
01740  * bounding edge
01741  * \param instance FBiGeom instance handle
01742  * \param edge_handle Edge being queried
01743  * \param face_handle Face being queried
01744  * \param in_u Parametric position on edge
01745  * \param u Corresponding parametric position on face
01746  * \param v Corresponding parametric position on face
01747  * \param *err Pointer to error type returned from function
01748  */
01749 void FBiGeom_getEntUtoUV( FBiGeom_Instance instance,
01750                           iBase_EntityHandle edge_handle,
01751                           iBase_EntityHandle face_handle,
01752                           double in_u,
01753                           double* u,
01754                           double* v,
01755                           int* err );
01756 
01757 /**\brief  Return parametric coordinates on face of vertex position
01758  *
01759  * Return parametric coordinates on face of vertex position
01760  * \param instance FBiGeom instance handle
01761  * \param vertex_handle Vertex being queried
01762  * \param face_handle Face being queried
01763  * \param u Corresponding parametric position on face
01764  * \param v Corresponding parametric position on face
01765  * \param *err Pointer to error type returned from function
01766  */
01767 void FBiGeom_getVtxToUV( FBiGeom_Instance instance,
01768                          iBase_EntityHandle vertex_handle,
01769                          iBase_EntityHandle face_handle,
01770                          double* u,
01771                          double* v,
01772                          int* err );
01773 
01774 /**\brief  Return parametric coordinates on edge of vertex position
01775  *
01776  * Return parametric coordinates on edge of vertex position
01777  * \param instance FBiGeom instance handle
01778  * \param vertex_handle Vertex being queried
01779  * \param edge_handle Edge being queried
01780  * \param u Corresponding parametric position on face
01781  * \param *err Pointer to error type returned from function
01782  */
01783 void FBiGeom_getVtxToU( FBiGeom_Instance instance,
01784                         iBase_EntityHandle vertex_handle,
01785                         iBase_EntityHandle edge_handle,
01786                         double* u,
01787                         int* err );
01788 
01789 /**\brief  Return the face parametric coordinates for a parametric position
01790  *         on bounding edges
01791  *
01792  * Return the face parametric coordinates for a parametric position on
01793  * bounding edges
01794  * \param instance FBiGeom instance handle
01795  * \param edge_handles Edges being queried
01796  * \param edge_handles_size Number of edges being queried
01797  * \param face_handles Faces being queried
01798  * \param face_handles_size Number of faces being queried
01799  * \param u_in Parametric positions on edges
01800  * \param u_in_size Number of parametric positions on edges
01801  * \param storage_order Storage order of coordinates returned
01802  * \param uv Corresponding parametric positions on faces
01803  * \param uv_allocated Allocated size of parameter array
01804  * \param uv_size Occupied size of parameter array
01805  * \param *err Pointer to error type returned from function
01806  */
01807 void FBiGeom_getArrUtoUV( FBiGeom_Instance instance,
01808                           iBase_EntityHandle const* edge_handles,
01809                           int edge_handles_size,
01810                           iBase_EntityHandle const* face_handles,
01811                           int face_handles_size,
01812                           double const* u_in,
01813                           int u_in_size,
01814                           int storage_order,
01815                           double** uv,
01816                           int* uv_allocated,
01817                           int* uv_size,
01818                           int* err );
01819 
01820 /**\brief  Return parametric coordinates on faces of vertex positions
01821  *
01822  * Return parametric coordinates on faces of vertex positions
01823  * \param instance FBiGeom instance handle
01824  * \param vertex_handles Vertices being queried
01825  * \param vertex_handles_size Number of vertices being queried
01826  * \param face_handles Faces being queried
01827  * \param face_handles_size Number of faces being queried
01828  * \param storage_order Storage order of coordinates returned
01829  * \param uv Corresponding parametric positions on faces
01830  * \param uv_allocated Allocated size of positions array
01831  * \param uv_size Occupied size of positions array
01832  * \param *err Pointer to error type returned from function
01833  */
01834 void FBiGeom_getVtxArrToUV( FBiGeom_Instance instance,
01835                             iBase_EntityHandle const* vertex_handles,
01836                             int vertex_handles_size,
01837                             iBase_EntityHandle const* face_handles,
01838                             int face_handles_size,
01839                             int storage_order,
01840                             double** uv,
01841                             int* uv_allocated,
01842                             int* uv_size,
01843                             int* err );
01844 
01845 /**\brief  Return parametric coordinates on edges of vertex positions
01846  *
01847  * Return parametric coordinates on edges of vertex positions
01848  * \param instance FBiGeom instance handle
01849  * \param vertex_handles Vertices being queried
01850  * \param vertex_handles_size Number of vertices being queried
01851  * \param edge_handles Edges being queried
01852  * \param edge_handles_size Number of edges being queried
01853  * \param u Corresponding parametric positions on faces
01854  * \param u_allocated Allocated size of positions array
01855  * \param u_size Occupied size of positions array
01856  * \param *err Pointer to error type returned from function
01857  */
01858 void FBiGeom_getVtxArrToU( FBiGeom_Instance instance,
01859                            iBase_EntityHandle const* vertex_handles,
01860                            int vertex_handles_size,
01861                            iBase_EntityHandle const* edge_handles,
01862                            int edge_handles_size,
01863                            double** u,
01864                            int* u_allocated,
01865                            int* u_size,
01866                            int* err );
01867 
01868 /**\brief  Return the normal at a specified parametric position
01869  *
01870  * Return the normal at a specified parametric position
01871  * \param instance FBiGeom instance handle
01872  * \param entity_handle Entity being queried
01873  * \param u Parametric position being queried
01874  * \param v Parametric position being queried
01875  * \param nrml_i Normal at specified position
01876  * \param nrml_j Normal at specified position
01877  * \param nrml_k Normal at specified position
01878  * \param *err Pointer to error type returned from functino
01879  */
01880 void FBiGeom_getEntNrmlUV( FBiGeom_Instance instance,
01881                            iBase_EntityHandle entity_handle,
01882                            double u,
01883                            double v,
01884                            double* nrml_i,
01885                            double* nrml_j,
01886                            double* nrml_k,
01887                            int* err );
01888 
01889 /**\brief  Return the normals at specified parametric positions
01890  *
01891  * Return the normals at specified parametric positions.  If either the
01892  * number of entities or number of spatial coordinate pairs is unity, then
01893  * all points or entities are queried for that entity or point,
01894  * respectively, otherwise each point corresponds to each entity.
01895  * storage_order should be a value in the iBase_StorageOrder enum.
01896  * \param instance FBiGeom instance handle
01897  * \param face_handle Faces being queried
01898  * \param face_handles_size Number of faces being queried
01899  * \param storage_order Storage order of coordinates input and output
01900  * \param parameters Parametric coordinates being queried
01901  * \param parameters_size Number of coordinates in array
01902  * \param normals Coordinates of normals at specified positions
01903  * \param normals_allocated Allocated size of normals array
01904  * \param normals_size Occupied size of normals array
01905  * \param *err Pointer to error type returned from function
01906  */
01907 void FBiGeom_getArrNrmlUV( FBiGeom_Instance instance,
01908                            iBase_EntityHandle const* face_handles,
01909                            int face_handles_size,
01910                            int storage_order,
01911                            double const* parameters,
01912                            int parameters_size,
01913                            double** normals,
01914                            int* normals_allocated,
01915                            int* normals_size,
01916                            int* err );
01917 
01918 /**\brief  Return the tangent at a specified parametric position
01919  *
01920  * Return the tangent at a specified parametric position
01921  * \param instance FBiGeom instance handle
01922  * \param entity_handle Entity being queried
01923  * \param u Parametric position being queried
01924  * \param tgnt_i Tangent at specified position
01925  * \param tgnt_j Tangent at specified position
01926  * \param tgnt_k Tangent at specified position
01927  * \param *err Pointer to error type returned from function
01928  */
01929 void FBiGeom_getEntTgntU( FBiGeom_Instance instance,
01930                           iBase_EntityHandle entity_handle,
01931                           double u,
01932                           double* tgnt_i,
01933                           double* tgnt_j,
01934                           double* tgnt_k,
01935                           int* err );
01936 
01937 /**\brief  Return the tangents at specified parametric positions
01938  *
01939  * Return the tangents at specified parametric positions.  If either the
01940  * number of entities or number of spatial coordinates is unity, then all
01941  * points or entities are queried for that entity or point, respectively,
01942  * otherwise each point corresponds to each entity.  storage_order should be
01943  * a value in the iBase_StorageOrder enum.
01944  * \param instance FBiGeom instance handle
01945  * \param edge_handle Edges being queried
01946  * \param edge_handles_size Number of faces being queried
01947  * \param storage_order Storage order of coordinates output
01948  * \param parameters Parametric coordinates being queried
01949  * \param parameters_size Number of coordinates in array
01950  * \param tangents Coordinates of tangents at specified positions
01951  * \param tangents_allocated Allocated size of tangents array
01952  * \param tangents_size Occupied size of tangents array
01953  * \param *err Pointer to error type returned from function
01954  */
01955 void FBiGeom_getArrTgntU( FBiGeom_Instance instance,
01956                           iBase_EntityHandle const* edge_handles,
01957                           int edge_handles_size,
01958                           int storage_order,
01959                           double const* parameters,
01960                           int parameters_size,
01961                           double** tangents,
01962                           int* tangents_allocated,
01963                           int* tangents_size,
01964                           int* err );
01965 
01966 /**\brief  Get the first derivative of a face at specified parametric
01967  *         position
01968  *
01969  * Get the first derivative of a face at specified parametric position.
01970  * \param instance FBiGeom instance handle
01971  * \param entity_handle Entity being queried
01972  * \param u Parametric position being queried
01973  * \param v Parametric position being queried
01974  * \param dvrt_u Pointer to coordinates of derivative with respect to u at
01975  *        specified position returned from function
01976  * \param dvrt_u_allocated Allocated size of dvrt_u array
01977  * \param dvrt_u_size Occupied size of dvrt_u array
01978  * \param dvrt_v Pointer to coordinates of derivative with respect to v at
01979  *        specified position returned from function
01980  * \param dvrt_v_allocated Allocated size of dvrt_v array
01981  * \param dvrt_v_size Occupied size of dvrt_v array
01982  * \param *err Pointer to error type returned from function
01983  */
01984 void FBiGeom_getEnt1stDrvt( FBiGeom_Instance instance,
01985                             iBase_EntityHandle entity_handle,
01986                             double u,
01987                             double v,
01988                             double** drvt_u,
01989                             int* drvt_u_allocated,
01990                             int* drvt_u_size,
01991                             double** drvt_v,
01992                             int* dvrt_v_allocated,
01993                             int* dvrt_v_size,
01994                             int* err );
01995 
01996 /**\brief  Get the first derivatives of faces at specified parametric
01997  *         positions
01998  *
01999  * Get the first derivatives of faces at specified parametric positions.
02000  * storage_order should be a value in the iBase_StorageOrder enum.
02001  * \param instance FBiGeom instance handle
02002  * \param entity_handles Array of entity handles being queried
02003  * \param entity_handles_size Number of entities in entity_handles array
02004  * \param storage_order Storage order of coordinates input and output
02005  * \param uv Parametric coordinates being queried
02006  * \param uv_size Number of coordinates in array
02007  * \param dvrt_u Pointer to array of coordinates of derivative with respect
02008  *        to u at specified position returned from function
02009  * \param dvrt_u_allocated Allocated size of dvrt_u array
02010  * \param dvrt_u_size Occupied size of dvrt_u array
02011  * \param u_offset Pointer to array of offsets for dvrt_u returned from
02012  *        function
02013  * \param u_offset_allocated Pointer to allocated size of u_offset array
02014  * \param u_offset_size Pointer to occupied size of u_offset array
02015  * \param dvrt_v Pointer to array of coordinates of derivative with respect
02016  *        to v at specified position returned from function
02017  * \param dvrt_v_allocated Allocated size of dvrt_v array
02018  * \param dvrt_v_size Occupied size of dvrt_v array
02019  * \param v_offset Pointer to array of offsets for dvrt_v returned from
02020  *        function
02021  * \param v_offset_allocated Pointer to allocated size of v_offset array
02022  * \param v_offset_size Pointer to occupied size of v_offset array
02023  * \param *err Pointer to error type returned from function
02024  */
02025 void FBiGeom_getArr1stDrvt( FBiGeom_Instance instance,
02026                             iBase_EntityHandle const* entity_handles,
02027                             int entity_handles_size,
02028                             int storage_order,
02029                             double const* uv,
02030                             int uv_size,
02031                             double** dvrt_u,
02032                             int* dvrt_u_allocated,
02033                             int* dvrt_u_size,
02034                             int** u_offset,
02035                             int* u_offset_allocated,
02036                             int* u_offset_size,
02037                             double** dvrt_v,
02038                             int* dvrt_v_allocated,
02039                             int* dvrt_v_size,
02040                             int** v_offset,
02041                             int* v_offset_allocated,
02042                             int* v_offset_size,
02043                             int* err );
02044 
02045 /**\brief  Get the second derivative of a face at specified parametric
02046  *         position
02047  *
02048  * Get the second derivative of a face at specified parametric position.
02049  * \param instance FBiGeom instance handle
02050  * \param entity_handle Entity being queried
02051  * \param u Parametric position being queried
02052  * \param v Parametric position being queried
02053  * \param dvrt_uu Pointer to coordinates of derivative with respect to u at
02054  *        specified position returned from function
02055  * \param dvrt_uu_allocated Allocated size of dvrt_uu array
02056  * \param dvrt_uu_size Occupied size of dvrt_uu array
02057  * \param dvrt_vv Pointer to coordinates of derivative with respect to v at
02058  *        specified position returned from function
02059  * \param dvrt_vv_allocated Allocated size of dvrt_vv array
02060  * \param dvrt_vv_size Occupied size of dvrt_vv array
02061  * \param dvrt_uv Pointer to coordinates of derivative with respect to u and
02062  *        v at specified position returned from function
02063  * \param dvrt_uv_allocated Allocated size of dvrt_uv array
02064  * \param dvrt_uv_size Occupied size of dvrt_uv array
02065  * \param *err Pointer to error type returned from function
02066  */
02067 void FBiGeom_getEnt2ndDrvt( FBiGeom_Instance instance,
02068                             iBase_EntityHandle entity_handle,
02069                             double u,
02070                             double v,
02071                             double** drvt_uu,
02072                             int* drvt_uu_allocated,
02073                             int* drvt_uu_size,
02074                             double** drvt_vv,
02075                             int* dvrt_vv_allocated,
02076                             int* dvrt_vv_size,
02077                             double** drvt_uv,
02078                             int* dvrt_uv_allocated,
02079                             int* dvrt_uv_size,
02080                             int* err );
02081 
02082 /**\brief  Get the second derivatives of faces at specified parametric
02083  *         positions
02084  *
02085  * Get the second derivatives of faces at specified parametric positions.
02086  * storage_order should be a value in the iBase_StorageOrder enum.
02087  * \param instance FBiGeom instance handle
02088  * \param entity_handles Array of entity handles being queried
02089  * \param entity_handles_size Number of entities in entity_handles array
02090  * \param storage_order Storage order of coordinates input and output
02091  * \param uv Parametric coordinates being queried
02092  * \param uv_size Number of coordinates in array
02093  * \param dvrt_uu Pointer to array of coordinates of derivative with respect
02094  *        to u at specified position returned from function
02095  * \param dvrt_uu_allocated Allocated size of dvrt_uu array
02096  * \param dvrt_uu_size Occupied size of dvrt_uu array
02097  * \param uu_offset Pointer to array of offsets for dvrt_uu returned from
02098  *        function
02099  * \param uu_offset_allocated Pointer to allocated size of uu_offset array
02100  * \param uu_offset_size Pointer to occupied size of uu_offset array
02101  * \param dvrt_vv Pointer to array of coordinates of derivative with respect
02102  *        to v at specified position returned from function
02103  * \param dvrt_vv_allocated Allocated size of dvrt_vv array
02104  * \param dvrt_vv_size Occupied size of dvrt_vv array
02105  * \param vv_offset Pointer to array of offsets for dvrt_vv returned from
02106  *        function
02107  * \param vv_offset_allocated Pointer to allocated size of vv_offset array
02108  * \param vv_offset_size Pointer to occupied size of vv_offset array
02109  * \param dvrt_uv Pointer to array of coordinates of derivative with respect
02110  *        to u and v at specified position returned from function
02111  * \param dvrt_uv_allocated Allocated size of dvrt_uv array
02112  * \param dvrt_uv_size Occupied size of dvrt_uv array
02113  * \param uv_offset Pointer to array of offsets for dvrt_uv returned from
02114  *        function
02115  * \param uv_offset_allocated Pointer to allocated size of uv_offset array
02116  * \param uv_offset_size Pointer to occupied size of uv_offset array
02117  * \param *err Pointer to error type returned from function
02118  */
02119 void FBiGeom_getArr2ndDrvt( FBiGeom_Instance instance,
02120                             iBase_EntityHandle const* entity_handles,
02121                             int entity_handles_size,
02122                             int storage_order,
02123                             double const* uv,
02124                             int uv_size,
02125                             double** dvtr_uu,
02126                             int* dvrt_uu_allocated,
02127                             int* dvrt_uu_size,
02128                             int** uu_offset,
02129                             int* uu_offset_allocated,
02130                             int* uu_offset_size,
02131                             double** dvtr_vv,
02132                             int* dvrt_vv_allocated,
02133                             int* dvrt_vv_size,
02134                             int** vv_offset,
02135                             int* vv_offset_allocated,
02136                             int* vv_offset_size,
02137                             double** dvrt_uv,
02138                             int* dvrt_uv_allocated,
02139                             int* dvrt_uv_size,
02140                             int** uv_offset,
02141                             int* uv_offset_allocated,
02142                             int* uv_offset_size,
02143                             int* err );
02144 
02145 /**\brief  Get the two principle curvature vectors for a face at a
02146  *         parametric position
02147  *
02148  * Get the two principle curvature vectors for a face at a parametric
02149  * position.  Magnitudes of vectors are curvature, directions are
02150  * directions of principal curvatures.
02151  * \param instance FBiGeom instance handle
02152  * \param face_handle Face being queried
02153  * \param u Parametric position being queried
02154  * \param v Parametric position being queried
02155  * \param cvtr1_i Maximum curvature vector
02156  * \param cvtr1_j Maximum curvature vector
02157  * \param cvtr1_k Maximum curvature vector
02158  * \param cvtr2_i Minimum curvature vector
02159  * \param cvtr2_j Minimum curvature vector
02160  * \param cvtr2_k Minimum curvature vector
02161  * \param *err Pointer to error type returned from function
02162  */
02163 void FBiGeom_getFcCvtrUV( FBiGeom_Instance instance,
02164                           iBase_EntityHandle face_handle,
02165                           double u,
02166                           double v,
02167                           double* cvtr1_i,
02168                           double* cvtr1_j,
02169                           double* cvtr1_k,
02170                           double* cvtr2_i,
02171                           double* cvtr2_j,
02172                           double* cvtr2_k,
02173                           int* err );
02174 
02175 /**\brief  Get the curvature(s) on face(s) at given parametric position(s)
02176  *
02177  * Get the curvature(s) on face(s) at given parametric position(s).  If
02178  * either the number of faces or number of coordinate pairs is unity, then
02179  * all points or entities are queried for that entity or point,
02180  * respectively, otherwise each point corresponds to each entity.
02181  * storage_order should be a value in the iBase_StorageOrder enum.
02182  * \param instance FBiGeom instance handle
02183  * \param face_handles Face(s) being queried
02184  * \param face_handles_size Number of entities being queried
02185  * \param storage_order Storage order of uv coordinates
02186  * \param uv Starting parametric coordinates
02187  * \param uv_size Number of values in uv array
02188  * \param cvtr_1 First principal curvatures
02189  * \param cvtr_1_allocated Allocated size of first curvature array
02190  * \param cvtr_1_size Occupied size of first curvature array
02191  * \param cvtr_2 Second principal curvatures
02192  * \param cvtr_2_allocated Allocated size of second curvature array
02193  * \param cvtr_2_size Occupied size of second curvature array
02194  * \param *err Pointer to error type returned from function
02195  */
02196 void FBiGeom_getFcArrCvtrUV( FBiGeom_Instance instance,
02197                              iBase_EntityHandle const* face_handles,
02198                              int face_handles_size,
02199                              int storage_order,
02200                              double const* uv,
02201                              int uv_size,
02202                              double** cvtr_1,
02203                              int* cvtr_1_allocated,
02204                              int* cvtr_1_size,
02205                              double** cvtr_2,
02206                              int* cvtr_2_allocated,
02207                              int* cvtr_2_size,
02208                              int* err );
02209 
02210 /**\brief  Return whether an entity is periodic
02211  *
02212  * Return whether an entity is periodic (=1) or not (=0) in the u and v
02213  * directions.
02214  * \param instance FBiGeom instance handle
02215  * \param entity_handle Entity being queried
02216  * \param in_u Entity is periodic in u direction (=1) or not (=0)
02217  * \param in_v Entity is periodic in v direction (=1) or not (=0)
02218  * \param *err Pointer to error type returned from function
02219  */
02220 void FBiGeom_isEntPeriodic( FBiGeom_Instance instance,
02221                             iBase_EntityHandle entity_handle,
02222                             int* in_u,
02223                             int* in_v,
02224                             int* err );
02225 
02226 /**\brief  Return whether entities are periodic
02227  *
02228  * Return whether entities are periodic (=1) or not (=0) in the u and v
02229  * directions.
02230  * \param instance FBiGeom instance handle
02231  * \param entity_handles Entities being queried
02232  * \param entity_handles_size Number of entities being queried
02233  * \param in_uv Array of pairs of integers representing whether
02234  *        entity_handles[i] is periodic (=1) or not (=0) in u and v
02235  *        directions
02236  * \param in_uv_allocated Allocated size of in_uv array
02237  * \param in_uv_size Occupied size of in_uv array
02238  * \param *err Pointer to error type returned from function
02239  */
02240 void FBiGeom_isArrPeriodic( FBiGeom_Instance instance,
02241                             iBase_EntityHandle const* entity_handles,
02242                             int entity_handles_size,
02243                             int** in_uv,
02244                             int* in_uv_allocated,
02245                             int* in_uv_size,
02246                             int* err );
02247 
02248 /**\brief  Return whether a face is degenerate
02249  *
02250  * Return whether a face is degenerate (=1) or not (=0).
02251  * \param instance FBiGeom instance handle
02252  * \param face_handle Face being queried
02253  * \param is_degenerate Face is degenerate (=1) or not (=0)
02254  * \param *err Pointer to error type returned from function
02255  */
02256 void FBiGeom_isFcDegenerate( FBiGeom_Instance instance, iBase_EntityHandle face_handle, int* is_degenerate, int* err );
02257 
02258 /**\brief  Return whether faces are degenerate
02259  *
02260  * Return whether faces are degenerate (=1) or not (=0).
02261  * \param instance FBiGeom instance handle
02262  * \param face_handles Faces being queried
02263  * \param face_handles_size Number of faces being queried
02264  * \param degenerate face_handles[i] is degenerate (=1) or not (=0)
02265  * \param degenerate_allocated Allocated size of degenerate array
02266  * \param degenerate_size Occupied size of degenerate array
02267  * \param *err Pointer to error type returned from function
02268  */
02269 void FBiGeom_isFcArrDegenerate( FBiGeom_Instance instance,
02270                                 iBase_EntityHandle const* face_handles,
02271                                 int face_handles_size,
02272                                 int** degenerate,
02273                                 int* degenerate_allocated,
02274                                 int* degenerate_size,
02275                                 int* err );
02276 
02277 /**\brief  Get the tolerance of the instance
02278  *
02279  * Get the tolerance at the modeler level.  type is an integer representing
02280  * the type of the tolerance, where 0 = no tolerance information,
02281  * 1 = modeler-level tolerance, 2 = entity-level tolerances.  If type is 1,
02282  * tolerance returns the modeler-level tolerance.  If type is 2, use
02283  * FBiGeom_getEntTolerance to query the tolerance on a per-entity basis.
02284  * \param instance FBiGeom instance handle
02285  * \param type Type of tolerance used by the modeler
02286  * \param tolerance Modeler-level tolerance, if any
02287  * \param *err Pointer to error type returned from function
02288  */
02289 void FBiGeom_getTolerance( FBiGeom_Instance instance, int* type, double* tolerance, int* err );
02290 
02291 /**\brief  Get the tolerance of the specified entity
02292  *
02293  * Get the tolerance of the specified entity.
02294  * \param instance FBiGeom instance handle
02295  * \param entity_handle Entity handle being queried
02296  * \param tolerance Pointer to tolerance returned from function
02297  * \param *err Pointer to error type returned from function
02298  */
02299 void FBiGeom_getEntTolerance( FBiGeom_Instance instance,
02300                               iBase_EntityHandle entity_handle,
02301                               double* tolerance,
02302                               int* err );
02303 
02304 /**\brief  Get the tolerances of the specified entities
02305  *
02306  * Get the tolerances of the specified entities.
02307  * \param instance FBiGeom instance handle
02308  * \param entity_handles Array of entity handles being queried
02309  * \param entity_handles_size Number of entities in entity_handles array
02310  * \param tolerance Pointer to array of tolerances returned from function
02311  * \param tolerance_allocated Pointer to allocated size of tolerance array
02312  * \param tololerance_size Pointer to occupied size of tolerance array
02313  * \param *err Pointer to error type returned from function
02314  */
02315 void FBiGeom_getArrTolerance( FBiGeom_Instance instance,
02316                               iBase_EntityHandle const* entity_handles,
02317                               int entity_handles_size,
02318                               double** tolerances,
02319                               int* tolerances_allocated,
02320                               int* tolerances_size,
02321                               int* err );
02322 
02323 /**\brief  Initialize an iterator over specified entity type
02324  *
02325  * Initialize an iterator over specified entity type for a specified set or
02326  * instance.  Iterator returned can be used as input to functions returning
02327  * the entity for the iterator.  If all entities of a specified type are to
02328  * be iterated, specify iBase_ALL_TYPES.  Specified type must be a value in
02329  * the iBase_EntityType enumeration.
02330  * \param instance FBiGeom instance handle
02331  * \param entity_set_handle Entity set being iterated
02332  * \param requested_entity_type Type of entity to iterate
02333  * \param entity_iterator Pointer to iterator returned from function
02334  * \param *err Pointer to error type returned from function
02335  */
02336 void FBiGeom_initEntIter( FBiGeom_Instance instance,
02337                           iBase_EntitySetHandle entity_set_handle,
02338                           int requested_entity_type,
02339                           iBase_EntityIterator* entity_iterator,
02340                           int* err );
02341 
02342 /**\brief  Initialize an array iterator over specified entity type and size
02343  *
02344  * Initialize an array iterator over specified entity type and size for a
02345  * specified set or instance.  Iterator returned can be used as input to
02346  * functions returning entities for the iterator.  If all entities of a
02347  * specified type are to be iterated, specify iBase_ALL_TYPES. Specified
02348  * type must be a value in the iBase_EntityType enumerations.
02349  * \param instance FBiGeom instance handle
02350  * \param entity_set_handle Entity set being iterated
02351  * \param requested_entity_type Type of entity to iterate
02352  * \param requested_array_size Size of chunks of handles returned for each
02353  *        value of the iterator
02354  * \param entArr_iterator Pointer to iterator returned from function
02355  * \param *err Pointer to error type returned from function
02356  */
02357 void FBiGeom_initEntArrIter( FBiGeom_Instance instance,
02358                              iBase_EntitySetHandle entity_set_handle,
02359                              int requested_entity_type,
02360                              int requested_array_size,
02361                              iBase_EntityArrIterator* entArr_iterator,
02362                              int* err );
02363 
02364 /**\brief  Get entity corresponding to an iterator and increment iterator
02365  *
02366  * Get the entity corresponding to an array iterator, and increment the
02367  * iterator.  Also return whether the next value of the iterator has
02368  * an entity (if non-zero, next iterator value is the end of the
02369  * iteration).
02370  * \param instance FBiGeom instance handle
02371  * \param entity_iterator Iterator being queried
02372  * \param entity_handle Pointer to an entity handle corresponding to the
02373  *        current value of iterator
02374  * \param has_data Pointer to a flag indicating if the value returned
02375  *        in entity_handle is valid. A non-zero value indicates the value
02376  *        is valid. A zero value indicates the value is NOT valid.
02377  * \param *err Pointer to error type returned from function
02378  */
02379 void FBiGeom_getNextEntIter( FBiGeom_Instance instance,
02380                              iBase_EntityIterator entity_iterator,
02381                              iBase_EntityHandle* entity_handle,
02382                              int* has_data,
02383                              int* err );
02384 
02385 /**\brief  Get entities contained in array iterator and increment iterator
02386  *
02387  * Get the entities contained in an array iterator, and increment the
02388  * iterator.  Also return whether the next value of the iterator has
02389  * any entities (if non-zero, next iterator value is the end of the
02390  * iteration).
02391  * \param instance FBiGeom instance handle
02392  * \param entArr_iterator Iterator being queried
02393  * \param *entity_handles Pointer to array of entity handles contained in
02394  *        current value of iterator
02395  * \param *entity_handles_allocated Pointer to allocated size of
02396  *        entity_handles array
02397  * \param *entity_handles_size Pointer to occupied size of entity_handles
02398  *        array
02399  * \param has_data Pointer to a flag indicating if the value(s) returned
02400  *        in entity_handles are valid. A non-zero value indicates the
02401  *        value(s) are valid. A zero value indicates the value(s) are NOT
02402  *        valid.
02403  * \param *err Pointer to error type returned from function
02404  */
02405 void FBiGeom_getNextEntArrIter( FBiGeom_Instance instance,
02406                                 iBase_EntityArrIterator entArr_iterator,
02407                                 iBase_EntityHandle** entity_handles,
02408                                 int* entity_handles_allocated,
02409                                 int* entity_handles_size,
02410                                 int* has_data,
02411                                 int* err );
02412 
02413 /**\brief  Reset the iterator
02414  *
02415  * Reset the iterator
02416  * \param instance FBiGeom instance handle
02417  * \param entity_iterator Iterator to reset
02418  * \param *err Pointer to error type returned from function
02419  */
02420 void FBiGeom_resetEntIter( FBiGeom_Instance instance, iBase_EntityIterator entity_iterator, int* err );
02421 
02422 /**\brief  Reset the array iterator
02423  *
02424  * Reset the array iterator
02425  * \param instance FBiGeom instance handle
02426  * \param entArr_iterator Iterator to reset
02427  * \param *err Pointer to error type returned from function
02428  */
02429 void FBiGeom_resetEntArrIter( FBiGeom_Instance instance, iBase_EntityArrIterator entArr_iterator, int* err );
02430 
02431 /**\brief  Destroy the specified iterator
02432  *
02433  * Destroy the specified iterator
02434  * \param instance FBiGeom instance handle
02435  * \param entity_iterator Iterator which gets destroyed
02436  * \param *err Pointer to error type returned from function
02437  */
02438 void FBiGeom_endEntIter( FBiGeom_Instance instance, iBase_EntityIterator entity_iterator, int* err );
02439 
02440 /**\brief  Destroy the specified array iterator
02441  *
02442  * Destroy the specified array iterator
02443  * \param instance FBiGeom instance handle
02444  * \param entArr_iterator Iterator which gets destroyed
02445  * \param *err Pointer to error type returned from function
02446  */
02447 void FBiGeom_endEntArrIter( FBiGeom_Instance instance, iBase_EntityArrIterator entArr_iterator, int* err );
02448 
02449 /**\brief  Make a copy of the specified entity
02450  *
02451  * Make a copy of the specified entity
02452  * \param instance FBiGeom instance handle
02453  * \param source entity to be copied
02454  * \param copy the newly-created entity
02455  * \param *err Pointer to error type returned from function
02456  */
02457 void FBiGeom_copyEnt( FBiGeom_Instance instance, iBase_EntityHandle source, iBase_EntityHandle* copy, int* err );
02458 
02459 /**\brief  Sweep (extrude) an entity about an axis
02460  *
02461  * Sweep (extrude) an entity by the given angle about the given axis.
02462  *
02463  * \param instance FBiGeom instance handle
02464  * \param geom_entity the entity to rotate
02465  * \param angle the rotational angle, in degrees
02466  * \param axis_x x coordinate of the axis
02467  * \param axis_y y coordinate of the axis
02468  * \param axis_z z coordinate of the axis
02469  * \param geom_entity2 Pointer to new entity handle returned from function
02470  * \param *err Pointer to error type returned from function
02471  */
02472 void FBiGeom_sweepEntAboutAxis( FBiGeom_Instance instance,
02473                                 iBase_EntityHandle geom_entity,
02474                                 double angle,
02475                                 double axis_x,
02476                                 double axis_y,
02477                                 double axis_z,
02478                                 iBase_EntityHandle* geom_entity2,
02479                                 int* err );
02480 
02481 /**\brief  Delete all entities and sets
02482  *
02483  * Delete all entities and sets
02484  * \param instance FBiGeom instance handle
02485  * \param *err Pointer to error type returned from function
02486  */
02487 void FBiGeom_deleteAll( FBiGeom_Instance instance, int* err );
02488 
02489 /**\brief  Delete specified entity
02490  *
02491  * Delete specified entity
02492  * \param instance FBiGeom instance handle
02493  * \param entity_handle Entity to be deleted
02494  * \param *err Pointer to error type returned from function
02495  */
02496 void FBiGeom_deleteEnt( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* err );
02497 
02498 /**\brief Create a sphere
02499  *
02500  * Create a sphere of the specified radius centered on the origin.
02501  * \param instance FBiGeom instance handle
02502  * \param radius radius of the sphere
02503  * \param geom_entity Pointer to new entity handle returned from function
02504  * \param *err Pointer to error type returned from function
02505  */
02506 void FBiGeom_createSphere( FBiGeom_Instance instance, double radius, iBase_EntityHandle* geom_entity, int* err );
02507 
02508 /**\brief  Create a prism
02509  *
02510  * Create a prism parallel to the z-axis and centered at the origin (so
02511  * that its z-coordinate extents are +height/2 and -height/2).
02512  * \param instance FBiGeom instance handle
02513  * \param height height of new prism
02514  * \param n_sides number of sides of new prism
02515  * \param major_rad major radius of new prism
02516  * \param minor_rad minor radius of new prism
02517  * \param geom_entity Pointer to new entity handle returned from function
02518  * \param *err Pointer to error type returned from function
02519  */
02520 void FBiGeom_createPrism( FBiGeom_Instance instance,
02521                           double height,
02522                           int n_sides,
02523                           double major_rad,
02524                           double minor_rad,
02525                           iBase_EntityHandle* geom_entity,
02526                           int* err );
02527 
02528 /**\brief  Create an axis-oriented box
02529  *
02530  * Create an axis-oriented box of the given dimensions, centered at the
02531  * origin.
02532  * \param instance FBiGeom instance handle
02533  * \param x x dimension of new box
02534  * \param y y dimension of new box
02535  * \param z z dimension of new box
02536  * \param geom_entity Pointer to new entity handle returned from function
02537  * \param *err Pointer to error type returned from function
02538  */
02539 void FBiGeom_createBrick( FBiGeom_Instance instance,
02540                           double x,
02541                           double y,
02542                           double z,
02543                           iBase_EntityHandle* geom_entity,
02544                           int* err );
02545 
02546 /**\brief  Create a cylinder
02547  *
02548  * Create a cylinder parallel to the z-axis and centered at the origin (so
02549  * that its z-coordinate extents are +height/2 and -height/2).
02550  * \param instance FBiGeom instance handle
02551  * \param height The height of the cylinder.
02552  * \param major_rad The x-axis radius
02553  * \param minor_rad The y-axis radius. If minor_rad is 0, the cylinder will
02554  *        be circular (as if minor_rad == major_rad).
02555  * \param geom_entity Pointer to new entity handle returned from function
02556  * \param *err Pointer to error type returned from function
02557  */
02558 void FBiGeom_createCylinder( FBiGeom_Instance instance,
02559                              double height,
02560                              double major_rad,
02561                              double minor_rad,
02562                              iBase_EntityHandle* geom_entity,
02563                              int* err );
02564 
02565 /**\brief  Create a cone or tapered cylinder
02566  *
02567  * Create a cone parallel to the z-axis and centered at the origin (so that
02568  * its z-coordinate extents are +height/2 and -height/2). The 'base' of the
02569  * cylinder is at z = -height/2, and the top is at +height/2.
02570  * \param instance FBiGeom instance handle
02571  * \param height The height of the cone.
02572  * \param major_rad_base The x-axis radius at the base of the cylinder
02573  * \param minor_rad_base The y-axis radius at the base.  If minor_rad_base
02574  *        is 0, the cylinder will be circular (as if minor_rad_base ==
02575  *        major_rad_base)
02576  * \param rad_top The x-axis radius at the top of the cone.  The y-axis
02577  *        radius at the top of the cone will be inferred to keep the aspect
02578  *        ratio of the top of the cone the same as the bottom. If rad_top is
02579  *        0, the cone terminates at a point.
02580  * \param geom_entity Pointer to new entity handle returned from function
02581  * \param *err Pointer to error type returned from function
02582  */
02583 void FBiGeom_createCone( FBiGeom_Instance instance,
02584                          double height,
02585                          double major_rad_base,
02586                          double minor_rad_base,
02587                          double rad_top,
02588                          iBase_EntityHandle* geom_entity,
02589                          int* err );
02590 
02591 /**\brief  Create a torus
02592  *
02593  * Create a torus centered on the origin and encircling the z-axis.
02594  * \param instance FBiGeom instance handle
02595  * \param major_rad The distance from the origin to the center of the
02596  *        torus's circular cross-section.
02597  * \param minor_rad The radius of the cross-section.
02598  * \param geom_entity Pointer to new entity handle returned from function
02599  * \param *err Pointer to error type returned from function
02600  */
02601 void FBiGeom_createTorus( FBiGeom_Instance instance,
02602                           double major_rad,
02603                           double minor_rad,
02604                           iBase_EntityHandle* geom_entity,
02605                           int* err );
02606 
02607 /**\brief  Move an entity by the given vector
02608  *
02609  * Move an entity by translating it along the given vector.
02610  * \param instance FBiGeom instance handle
02611  * \param geom_entity the entity to move
02612  * \param x x coordinate of the vector
02613  * \param y y coordinate of the vector
02614  * \param z z coordinate of the vector
02615  * \param *err Pointer to error type returned from function
02616  */
02617 void FBiGeom_moveEnt( FBiGeom_Instance instance,
02618                       iBase_EntityHandle geom_entity,
02619                       double x,
02620                       double y,
02621                       double z,
02622                       int* err );
02623 
02624 /**\brief  Rotate an entity about an axis
02625  *
02626  * Rotate an entity by the given angle about the given axis.
02627  * \param instance FBiGeom instance handle
02628  * \param geom_entity the entity to rotate
02629  * \param angle the rotational angle, in degrees
02630  * \param axis_x x coordinate of the axis
02631  * \param axis_y y coordinate of the axis
02632  * \param axis_z z coordinate of the axis
02633  * \param *err Pointer to error type returned from function
02634  */
02635 void FBiGeom_rotateEnt( FBiGeom_Instance instance,
02636                         iBase_EntityHandle geom_entity,
02637                         double angle,
02638                         double axis_x,
02639                         double axis_y,
02640                         double axis_z,
02641                         int* err );
02642 
02643 /**\brief  Reflect an entity across a plane
02644  *
02645  * Reflect an entity across the given plane
02646  * \param instance FBiGeom instance handle
02647  * \param geom_entity the entity to reflect,
02648  * \param point_x  x coordinate of the point that the reflecting plane goes though
02649  * \param point_y  y coordinate of the point that the reflecting plane goes though
02650  * \param point_z  z coordinate of the point that the reflecting plane goes though
02651  * \param plane_normal_x x coordinate of the plane's normal
02652  * \param plane_normal_y y coordinate of the plane's normal
02653  * \param plane_normal_z z coordinate of the plane's normal
02654  * \param *err Pointer to error type returned from function
02655  */
02656 void FBiGeom_reflectEnt( FBiGeom_Instance instance,
02657                          iBase_EntityHandle geom_entity,
02658                          double x,
02659                          double y,
02660                          double z,
02661                          double plane_normal_x,
02662                          double plane_normal_y,
02663                          double plane_normal_z,
02664                          int* err );
02665 
02666 /**\brief  Scale an entity in the x, y, and z directions
02667  *
02668  * Scale an entity in the x, y, and z directions.
02669  * \param instance FBiGeom instance handle
02670  * \param geom_entity the entity to scale,
02671  * \param point_x  x coordinate of the scaling center
02672  * \param point_y  y coordinate of the scaling center
02673  * \param point_z  z coordinate of the scaling center
02674  * \param scale_x factor to scale by in the x direction
02675  * \param scale_y factor to scale by in the y direction
02676  * \param scale_z factor to scale by in the z direction
02677  * \param *err Pointer to error type returned from function
02678  */
02679 void FBiGeom_scaleEnt( FBiGeom_Instance instance,
02680                        iBase_EntityHandle geom_entity,
02681                        double x,
02682                        double y,
02683                        double z,
02684                        double scale_x,
02685                        double scale_y,
02686                        double scale_z,
02687                        int* err );
02688 
02689 /**\brief  Geometrically unite entities
02690  *
02691  * Geometrically unite the specified entities.
02692  * \param instance FBiGeom instance handle
02693  * \param geom_entities Array of entity handles being united
02694  * \param geom_entities_size Number of entities in geom_entities array
02695  * \param geom_entity Pointer to new entity handle returned from function
02696  * \param *err Pointer to error type returned from function
02697  */
02698 void FBiGeom_uniteEnts( FBiGeom_Instance instace,
02699                         iBase_EntityHandle const* geom_entities,
02700                         int geom_entities_size,
02701                         iBase_EntityHandle* geom_entity,
02702                         int* err );
02703 
02704 /**\brief  Geometrically subtract one entity from another
02705  *
02706  * Geometrically subtract the entity tool from the entity blank.
02707  * \param instance FBiGeom instance handle
02708  * \param blank The entity to subtract from
02709  * \param tool The entity to subtract
02710  * \param geom_entity Pointer to new entity handle returned from function
02711  * \param *err Pointer to error type returned from function
02712  */
02713 void FBiGeom_subtractEnts( FBiGeom_Instance instance,
02714                            iBase_EntityHandle blank,
02715                            iBase_EntityHandle tool,
02716                            iBase_EntityHandle* geom_entity,
02717                            int* err );
02718 
02719 /**\brief  Geometrically intersect a pair of entities
02720  *
02721  * Geometrically intersect a pair of entities.
02722  * \param instance FBiGeom instance handle
02723  * \param entity1 The entity to intersect
02724  * \param entity2 The entity to intersect
02725  * \param geom_entity Pointer to new entity handle returned from function
02726  * \param *err Pointer to error type returned from function
02727  */
02728 void FBiGeom_intersectEnts( FBiGeom_Instance instance,
02729                             iBase_EntityHandle entity2,
02730                             iBase_EntityHandle entity1,
02731                             iBase_EntityHandle* geom_entity,
02732                             int* err );
02733 
02734 /**\brief  Section (cut) a region with a plane
02735  *
02736  * Section (cut) a region with a plane, retaining one of the pieces and
02737  * discarding the other.
02738  * \param instance FBiGeom instance handle
02739  * \param geom_entity The entity to section
02740  * \param plane_normal_x x coordinate of the plane's normal
02741  * \param plane_normal_y y coordinate of the plane's normal
02742  * \param plane_normal_z z coordinate of the plane's normal
02743  * \param offset Distance of the plane from the origin
02744  * \param reverse Keep the piece on the normal's side (=0) or not (=1)
02745  * \param geom_entity2 Pointer to new entity handle returned from function
02746  * \param *err Pointer to error type returned from function
02747  */
02748 void FBiGeom_sectionEnt( FBiGeom_Instance instance,
02749                          iBase_EntityHandle geom_entity,
02750                          double plane_normal_x,
02751                          double plane_normal_y,
02752                          double plane_normal_z,
02753                          double offset,
02754                          int reverse,
02755                          iBase_EntityHandle* geom_entity2,
02756                          int* err );
02757 
02758 /**\brief  Imprint entities
02759  *
02760  * Imprint entities by merging coincident surfaces.
02761  * \param instance FBiGeom instance handle
02762  * \param geom_entities Array of entity handles being imprinted
02763  * \param geom_entities_size Number of entities in geom_entities array
02764  * \param *err Pointer to error type returned from function
02765  */
02766 void FBiGeom_imprintEnts( FBiGeom_Instance instance,
02767                           iBase_EntityHandle const* geom_entities,
02768                           int geom_entities_size,
02769                           int* err );
02770 
02771 /**\brief  Merge ents
02772  *
02773  * Merge entities of corresponding topology/geometry within the specified
02774  * tolerance.
02775  * \param instance FBiGeom instance handle
02776  * \param geom_entities Array of entity handles being imprinted
02777  * \param geom_entities_size Number of entities in geom_entities array
02778  * \param tolerance Tolerance within which entities are considered the same
02779  * \param *err Pointer to error type returned from function
02780  */
02781 void FBiGeom_mergeEnts( FBiGeom_Instance instance,
02782                         iBase_EntityHandle const* geom_entities,
02783                         int geom_entities_size,
02784                         double tolerance,
02785                         int* err );
02786 
02787 /**\brief  Create an entity set
02788  *
02789  * Create an entity set, either ordered (isList=1) or unordered
02790  * (isList=0).  Unordered entity sets can contain a given entity or
02791  * set only once.
02792  * \param instance FBiGeom instance handle
02793  * \param isList If non-zero, an ordered list is created, otherwise an
02794  *        unordered set is created.
02795  * \param entity_set_created Entity set created by function
02796  * \param *err Pointer to error type returned from function
02797  */
02798 void FBiGeom_createEntSet( FBiGeom_Instance instance, int isList, iBase_EntitySetHandle* entity_set_created, int* err );
02799 
02800 /**\brief  Destroy an entity set
02801  *
02802  * Destroy an entity set
02803  * \param instance FBiGeom instance handle
02804  * \param entity_set Entity set to be destroyed
02805  * \param *err Pointer to error type returned from function
02806  */
02807 void FBiGeom_destroyEntSet( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int* err );
02808 
02809 /**\brief  Return whether a specified set is ordered or unordered
02810  *
02811  * Return whether a specified set is ordered (*is_list=1) or
02812  * unordered (*is_list=0)
02813  * \param instance FBiGeom instance handle
02814  * \param entity_set Entity set being queried
02815  * \param is_list Pointer to flag returned from function
02816  * \param *err Pointer to error type returned from function
02817  */
02818 void FBiGeom_isList( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int* is_list, int* err );
02819 
02820 /**\brief  Get the number of entity sets contained in a set or interface
02821  *
02822  * Get the number of entity sets contained in a set or interface.  If
02823  * a set is input which is not the root set, num_hops indicates the
02824  * maximum number of contained sets from entity_set_handle to one of the
02825  * contained sets, not inclusive of the contained set.
02826  * \param instance FBiGeom instance handle
02827  * \param entity_set_handle Entity set being queried
02828  * \param num_hops Maximum hops from entity_set_handle to contained set,
02829  *        not inclusive of the contained set
02830  * \param num_sets Pointer to the number of sets returned from function
02831  * \param *err Pointer to error type returned from function
02832  */
02833 void FBiGeom_getNumEntSets( FBiGeom_Instance instance,
02834                             iBase_EntitySetHandle entity_set_handle,
02835                             int num_hops,
02836                             int* num_sets,
02837                             int* err );
02838 
02839 /**\brief  Get the entity sets contained in a set or interface
02840  *
02841  * Get the entity sets contained in a set or interface.  If
02842  * a set is input which is not the root set, num_hops indicates the
02843  * maximum number of contained sets from entity_set_handle to one of the
02844  * contained sets, not inclusive of the contained set.
02845  * \param instance FBiGeom instance handle
02846  * \param entity_set_handle Entity set being queried
02847  * \param num_hops Maximum hops from entity_set_handle to contained set,
02848  *        not inclusive of the contained set
02849  * \param *contained_set_handles Pointer to array of set handles returned
02850  *        from function
02851  * \param contained_set_handles_allocated Pointer to allocated length of
02852  *        contained_set_handles array
02853  * \param contained_set_handles_size Pointer to occupied length of
02854  *        contained_set_handles array
02855  * \param *err Pointer to error type returned from function
02856  */
02857 void FBiGeom_getEntSets( FBiGeom_Instance instance,
02858                          iBase_EntitySetHandle entity_set_handle,
02859                          int num_hops,
02860                          iBase_EntitySetHandle** contained_set_handles,
02861                          int* contained_set_handles_allocated,
02862                          int* contained_set_handles_size,
02863                          int* err );
02864 
02865 /**\brief  Add an entity to a set
02866  *
02867  * Add an entity to a set
02868  * \param instance FBiGeom instance handle
02869  * \param entity_handle The entity being added
02870  * \param entity_set Pointer to the set being added to
02871  * \param *err Pointer to error type returned from function
02872  */
02873 void FBiGeom_addEntToSet( FBiGeom_Instance instance,
02874                           iBase_EntityHandle entity_handle,
02875                           iBase_EntitySetHandle entity_set,
02876                           int* err );
02877 
02878 /**\brief  Remove an entity from a set
02879  *
02880  * Remove an entity from a set
02881  *
02882  * \param instance FBiGeom instance handle
02883  * \param entity_handle The entity being removed
02884  * \param entity_set Pointer to the set being removed from
02885  * \param *err Pointer to error type returned from function
02886  */
02887 void FBiGeom_rmvEntFromSet( FBiGeom_Instance instance,
02888                             iBase_EntityHandle entity_handle,
02889                             iBase_EntitySetHandle entity_set,
02890                             int* err );
02891 
02892 /**\brief  Add an array of entities to a set
02893  *
02894  * Add an array of entities to a set
02895  * \param instance FBiGeom instance handle
02896  * \param entity_handles Array of entities being added
02897  * \param entity_handles_size Number of entities in entity_handles array
02898  * \param entity_set Pointer to the set being added to
02899  * \param *err Pointer to error type returned from function
02900  */
02901 void FBiGeom_addEntArrToSet( FBiGeom_Instance instance,
02902                              const iBase_EntityHandle* entity_handles,
02903                              int entity_handles_size,
02904                              iBase_EntitySetHandle entity_set,
02905                              int* err );
02906 
02907 /**\brief  Remove an array of entities from a set
02908  *
02909  * Remove an array of entities from a set
02910  * \param instance FBiGeom instance handle
02911  * \param entity_handles Array of entities being remove
02912  * \param entity_handles_size Number of entities in entity_handles array
02913  * \param entity_set Pointer to the set being removed from
02914  * \param *err Pointer to error type returned from function
02915  */
02916 void FBiGeom_rmvEntArrFromSet( FBiGeom_Instance instance,
02917                                const iBase_EntityHandle* entity_handles,
02918                                int entity_handles_size,
02919                                iBase_EntitySetHandle entity_set,
02920                                int* err );
02921 
02922 /**\brief  Add an entity set to a set
02923  *
02924  * Add an entity set to a set
02925  * \param instance FBiGeom instance handle
02926  * \param entity_set_to_add The entity set being added
02927  * \param entity_set_handle Pointer to the set being added to
02928  * \param *err Pointer to error type returned from function
02929  */
02930 void FBiGeom_addEntSet( FBiGeom_Instance instance,
02931                         iBase_EntitySetHandle entity_set_to_add,
02932                         iBase_EntitySetHandle entity_set_handle,
02933                         int* err );
02934 
02935 /**\brief  Remove an entity set from a set
02936  *
02937  * Remove an entity set from a set
02938  * \param instance FBiGeom instance handle
02939  * \param entity_set_to_remove The entity set being removed
02940  * \param entity_set_handle Pointer to the set being removed from
02941  * \param *err Pointer to error type returned from function
02942  */
02943 void FBiGeom_rmvEntSet( FBiGeom_Instance instance,
02944                         iBase_EntitySetHandle entity_set_to_remove,
02945                         iBase_EntitySetHandle entity_set_handle,
02946                         int* err );
02947 
02948 /**\brief  Return whether an entity is contained in another set
02949  *
02950  * Return whether an entity is contained (*is_contained=1) or not
02951  * contained (*is_contained=0) in another set
02952  * \param instance FBiGeom instance handle
02953  * \param containing_entity_set Entity set being queried
02954  * \param contained_entity Entity potentially contained in
02955  *        containing_entity_set
02956  * \param is_contained Pointer to flag returned from function
02957  * \param *err Pointer to error type returned from function
02958  */
02959 void FBiGeom_isEntContained( FBiGeom_Instance instance,
02960                              iBase_EntitySetHandle containing_entity_set,
02961                              iBase_EntityHandle contained_entity,
02962                              int* is_contained,
02963                              int* err );
02964 
02965 /**\brief  Return whether entities are contained in a set
02966  *
02967  * Return whether each entity is contained in the set.
02968  * \param instance iMesh instance handle
02969  * \param containing_entity_set Entity set being queried
02970  * \param entity_handles List of entities for which to check containment.
02971  * \param is_contained One value for each input entity, 1 if contained
02972  *          in set, zero otherwise.
02973  * \param *err Pointer to error type returned from function
02974  */
02975 void FBiGeom_isEntArrContained( FBiGeom_Instance instance,
02976                                 /*in*/ iBase_EntitySetHandle containing_set,
02977                                 /*in*/ const iBase_EntityHandle* entity_handles,
02978                                 /*in*/ int num_entity_handles,
02979                                 /*inout*/ int** is_contained,
02980                                 /*inout*/ int* is_contained_allocated,
02981                                 /*out*/ int* is_contained_size,
02982                                 /*out*/ int* err );
02983 
02984 /**\brief  Return whether an entity set is contained in another set
02985  *
02986  * Return whether a set is contained (*is_contained=1) or not contained
02987  * (*is_contained=0) in another set
02988  * \param instance FBiGeom instance handle
02989  * \param containing_entity_set Entity set being queried
02990  * \param contained_entity_set Entity set potentially contained in
02991  *        containing_entity_set
02992  * \param is_contained Pointer to flag returned from function
02993  * \param *err Pointer to error type returned from function
02994  */
02995 void FBiGeom_isEntSetContained( FBiGeom_Instance instance,
02996                                 iBase_EntitySetHandle containing_entity_set,
02997                                 iBase_EntitySetHandle contained_entity_set,
02998                                 int* is_contained,
02999                                 int* err );
03000 
03001 /**\brief  Add parent/child links between two sets
03002  *
03003  * Add parent/child links between two sets.  Makes parent point to child
03004  * and child point to parent.
03005  * \param instance FBiGeom instance handle
03006  * \param parent_entity_set Pointer to parent set
03007  * \param child_entity_set Pointer to child set
03008  * \param *err Pointer to error type returned from function
03009  */
03010 void FBiGeom_addPrntChld( FBiGeom_Instance instance,
03011                           iBase_EntitySetHandle parent_entity_set,
03012                           iBase_EntitySetHandle child_entity_set,
03013                           int* err );
03014 
03015 /**\brief  Remove parent/child links between two sets
03016  *
03017  * Remove parent/child links between two sets.
03018  * \param instance FBiGeom instance handle
03019  * \param parent_entity_set Pointer to parent set
03020  * \param child_entity_set Pointer to child set
03021  * \param *err Pointer to error type returned from function
03022  */
03023 void FBiGeom_rmvPrntChld( FBiGeom_Instance instance,
03024                           iBase_EntitySetHandle parent_entity_set,
03025                           iBase_EntitySetHandle child_entity_set,
03026                           int* err );
03027 
03028 /**\brief  Return whether two sets are related by parent/child links
03029  *
03030  * Return whether two sets are related (*is_child=1) or not (*is_child=0)
03031  * by parent/child links
03032  * \param instance FBiGeom instance handle
03033  * \param parent_entity_set Pointer to parent set
03034  * \param child_entity_set Pointer to child set
03035  * \param is_child Pointer to flag returned from function
03036  * \param *err Pointer to error type returned from function
03037  */
03038 void FBiGeom_isChildOf( FBiGeom_Instance instance,
03039                         iBase_EntitySetHandle parent_entity_set,
03040                         iBase_EntitySetHandle child_entity_set,
03041                         int* is_child,
03042                         int* err );
03043 
03044 /**\brief  Get the number of child sets linked from a specified set
03045  *
03046  * Get the number of child sets linked from a specified set.  If num_hops
03047  * is not -1, this represents the maximum hops from entity_set to any
03048  * child in the count.
03049  * \param instance FBiGeom instance handle
03050  * \param entity_set Entity set being queried
03051  * \param num_hops Maximum hops from entity_set_handle to child set,
03052  *        not inclusive of the child set
03053  * \param num_child Pointer to number of children returned from function
03054  * \param *err Pointer to error type returned from function
03055  */
03056 void FBiGeom_getNumChld( FBiGeom_Instance instance,
03057                          iBase_EntitySetHandle entity_set,
03058                          int num_hops,
03059                          int* num_child,
03060                          int* err );
03061 
03062 /**\brief  Get the number of parent sets linked from a specified set
03063  *
03064  * Get the number of parent sets linked from a specified set.  If num_hops
03065  * is not -1, this represents the maximum hops from entity_set to any
03066  * parent in the count.
03067  * \param instance FBiGeom instance handle
03068  * \param entity_set Entity set being queried
03069  * \param num_hops Maximum hops from entity_set_handle to parent set,
03070  *        not inclusive of the parent set
03071  * \param num_parent Pointer to number of parents returned from function
03072  * \param *err Pointer to error type returned from function
03073  */
03074 void FBiGeom_getNumPrnt( FBiGeom_Instance instance,
03075                          iBase_EntitySetHandle entity_set,
03076                          int num_hops,
03077                          int* num_parent,
03078                          int* err );
03079 
03080 /**\brief  Get the child sets linked from a specified set
03081  *
03082  * Get the child sets linked from a specified set.  If num_hops
03083  * is not -1, this represents the maximum hops from entity_set to any
03084  * child.
03085  * \param instance FBiGeom instance handle
03086  * \param from_entity_set Entity set being queried
03087  * \param num_hops Maximum hops from entity_set_handle to child set,
03088  *        not inclusive of the child set
03089  * \param *entity_set_handles Pointer to array of child sets
03090  *        returned from function
03091  * \param *entity_set_handles_allocated Pointer to allocated size of
03092  *        entity_set_handles array
03093  * \param *entity_set_handles_size Pointer to occupied size of
03094  *        entity_set_handles array
03095  * \param *err Pointer to error type returned from function
03096  */
03097 void FBiGeom_getChldn( FBiGeom_Instance instance,
03098                        iBase_EntitySetHandle from_entity_set,
03099                        int num_hops,
03100                        iBase_EntitySetHandle** entity_set_handles,
03101                        int* entity_set_handles_allocated,
03102                        int* entity_set_handles_size,
03103                        int* err );
03104 
03105 /**\brief  Get the parent sets linked from a specified set
03106  *
03107  * Get the parent sets linked from a specified set.  If num_hops
03108  * is not -1, this represents the maximum hops from entity_set to any
03109  * parent.
03110  * \param instance FBiGeom instance handle
03111  * \param from_entity_set Entity set being queried
03112  * \param num_hops Maximum hops from entity_set_handle to parent set,
03113  *        not inclusive of the parent set
03114  * \param *entity_set_handles Pointer to array of parent sets
03115  *        returned from function
03116  * \param *entity_set_handles_allocated Pointer to allocated size of
03117  *        entity_set_handles array
03118  * \param *entity_set_handles_size Pointer to occupied size of
03119  *        entity_set_handles array
03120  * \param *err Pointer to error type returned from function
03121  */
03122 void FBiGeom_getPrnts( FBiGeom_Instance instance,
03123                        iBase_EntitySetHandle from_entity_set,
03124                        int num_hops,
03125                        iBase_EntitySetHandle** entity_set_handles,
03126                        int* entity_set_handles_allocated,
03127                        int* entity_set_handles_size,
03128                        int* err );
03129 
03130 /**\brief  Create a tag with specified name, size, and type
03131  *
03132  * Create a tag with specified name, size, and type.  Tag size is in
03133  * units of size of tag_type data types.  Value input for tag type must be
03134  * value in iBase_TagType enumeration.
03135  * \param instance FBiGeom instance handle
03136  * \param tag_name Character string indicating tag name
03137  * \param tag_size Size of each tag value, in units of number of tag_type
03138  *        entities
03139  * \param tag_type Data type for data stored in this tag
03140  * \param tag_handle Pointer to tag handle returned from function
03141  * \param *err Pointer to error type returned from function
03142  * \param tag_name_len Length of tag name string
03143  */
03144 void FBiGeom_createTag( FBiGeom_Instance instance,
03145                         const char* tag_name,
03146                         int tag_size,
03147                         int tag_type,
03148                         iBase_TagHandle* tag_handle,
03149                         int* err,
03150                         int tag_name_len );
03151 
03152 /**\brief  Destroy a tag
03153  *
03154  * Destroy a tag.  If forced is non-zero and entities still have values
03155  * set for this tag, tag is deleted anyway and those values disappear,
03156  * otherwise tag is not deleted.
03157  * \param instance FBiGeom instance handle
03158  * \param tag_handle Handle of tag to be deleted
03159  * \param forced If non-zero, delete the tag even if entities have values
03160  *        set for that tag
03161  * \param *err Pointer to error type returned from function
03162  */
03163 void FBiGeom_destroyTag( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int forced, int* err );
03164 
03165 /**\brief  Get the name for a given tag handle
03166  *
03167  * Get the name for a given tag handle
03168  * \param instance FBiGeom instance handle
03169  * \param tag_handle Tag handle being queried
03170  * \param name Pointer to character string to store name returned from
03171  *        function
03172  * \param *err Pointer to error type returned from function
03173  * \param name_len Length of character string input to function
03174  */
03175 void FBiGeom_getTagName( FBiGeom_Instance instance, iBase_TagHandle tag_handle, char* name, int* err, int name_len );
03176 
03177 /**\brief  Get size of a tag in units of numbers of tag data type
03178  *
03179  * Get size of a tag in units of numbers of tag data type
03180  * \param instance FBiGeom instance handle
03181  * \param tag_handle Handle of tag being queried
03182  * \param tag_size Pointer to tag size returned from function
03183  * \param *err Pointer to error type returned from function
03184  */
03185 void FBiGeom_getTagSizeValues( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_size, int* err );
03186 
03187 /**\brief  Get size of a tag in units of bytes
03188  *
03189  * Get size of a tag in units of bytes
03190  * \param instance FBiGeom instance handle
03191  * \param tag_handle Handle of tag being queried
03192  * \param tag_size Pointer to tag size returned from function
03193  * \param *err Pointer to error type returned from function
03194  */
03195 void FBiGeom_getTagSizeBytes( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_size, int* err );
03196 
03197 /**\brief  Get a the handle of an existing tag with the specified name
03198  *
03199  * Get a the handle of an existing tag with the specified name
03200  * \param instance FBiGeom instance handle
03201  * \param tag_name Name of tag being queried
03202  * \param tag_handle Pointer to tag handle returned from function
03203  * \param *err Pointer to error type returned from function
03204  * \param tag_name_len Length of tag name string
03205  */
03206 void FBiGeom_getTagHandle( FBiGeom_Instance instance,
03207                            const char* tag_name,
03208                            iBase_TagHandle* tag_handle,
03209                            int* err,
03210                            int tag_name_len );
03211 
03212 /**\brief  Get the data type of the specified tag handle
03213  *
03214  * Get the data type of the specified tag handle.  Tag type is a value in
03215  * the iBase_TagType enumeration.
03216  * \param instance FBiGeom instance handle
03217  * \param tag_handle Handle for the tag being queried
03218  * \param tag_type Pointer to tag type returned from function
03219  * \param *err Pointer to error type returned from function
03220  */
03221 void FBiGeom_getTagType( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_type, int* err );
03222 
03223 /**\brief  Set a tag value of arbitrary type on an entity set
03224  *
03225  * Set a tag value of arbitrary type on an entity set. The tag data
03226  * is passed as void*. tag_value_size specifies the size of the memory
03227  * pointed to by tag_value in terms of bytes. Applications are free to
03228  * use this function to set data of any type, not just iBase_BYTES.
03229  * However, in all cases, the size specified by tag_value_size is
03230  * always in terms of bytes.
03231  *
03232  * \param instance FBiGeom instance handle
03233  * \param entity_set_handle Entity set on which tag is being set
03234  * \param tag_handle Tag being set on an entity set
03235  * \param tag_value Pointer to tag data being set on entity set
03236  * \param tag_value_size Size in bytes of tag data
03237  * \param *err Pointer to error type returned from function
03238  */
03239 void FBiGeom_setEntSetData( FBiGeom_Instance instance,
03240                             iBase_EntitySetHandle entity_set_handle,
03241                             const iBase_TagHandle tag_handle,
03242                             const void* tag_value,
03243                             const int tag_value_size,
03244                             int* err );
03245 
03246 /**\brief  Set a tag value of integer type on an entity set
03247  *
03248  * Set a tag value of integer type on an entity set.
03249  * \param instance FBiGeom instance handle
03250  * \param entity_set Entity set on which tag is being set
03251  * \param tag_handle Tag being set on an entity set
03252  * \param tag_value Tag value being set on entity set
03253  * \param *err Pointer to error type returned from function
03254  */
03255 void FBiGeom_setEntSetIntData( FBiGeom_Instance instance,
03256                                iBase_EntitySetHandle entity_set,
03257                                iBase_TagHandle tag_handle,
03258                                int tag_value,
03259                                int* err );
03260 
03261 /**\brief  Set a tag value of double type on an entity set
03262  *
03263  * Set a tag value of double type on an entity set.
03264  * \param instance FBiGeom instance handle
03265  * \param entity_set Entity set on which tag is being set
03266  * \param tag_handle Tag being set on an entity set
03267  * \param tag_value Tag value being set on entity set
03268  * \param *err Pointer to error type returned from function
03269  */
03270 void FBiGeom_setEntSetDblData( FBiGeom_Instance instance,
03271                                iBase_EntitySetHandle entity_set,
03272                                iBase_TagHandle tag_handle,
03273                                double tag_value,
03274                                int* err );
03275 
03276 /**\brief  Set a tag value of entity handle type on an entity set
03277  *
03278  * Set a tag value of entity handle type on an entity set.
03279  * \param instance FBiGeom instance handle
03280  * \param entity_set Entity set on which tag is being set
03281  * \param tag_handle Tag being set on an entity set
03282  * \param tag_value Tag value being set on entity set
03283  * \param *err Pointer to error type returned from function
03284  */
03285 void FBiGeom_setEntSetEHData( FBiGeom_Instance instance,
03286                               iBase_EntitySetHandle entity_set,
03287                               iBase_TagHandle tag_handle,
03288                               iBase_EntityHandle tag_value,
03289                               int* err );
03290 
03291 /**\brief  Set a tag value of entity set handle type on an entity set
03292  *
03293  * Set a tag value of entity set handle type on an entity set.
03294  * \param instance FBiGeom instance handle
03295  * \param entity_set Entity set on which tag is being set
03296  * \param tag_handle Tag being set on an entity set
03297  * \param tag_value Tag value being set on entity set
03298  * \param *err Pointer to error type returned from function
03299  */
03300 void FBiGeom_setEntSetESHData( FBiGeom_Instance instance,
03301                                iBase_EntitySetHandle entity_set,
03302                                iBase_TagHandle tag_handle,
03303                                iBase_EntitySetHandle tag_value,
03304                                int* err );
03305 
03306 /**\brief  Get the value of a tag of arbitrary type on an entity set
03307  *
03308  * Get the value of a tag of arbitrary type on an entity set.  Tag data
03309  * is returned back as void*. tag_value_size specifies the size of the
03310  * memory pointed to by tag_value in terms of bytes. Applications may
03311  * use this function to get data of any type, not just iBase_BYTES.
03312  * However because this function supports data of arbitrary type,
03313  * in all cases the size specified by tag_value_size is always in terms
03314  * of bytes.
03315  *
03316  * \param instance FBiGeom instance handle
03317  * \param entity_set_handle Entity set on which tag is being set
03318  * \param tag_handle Tag being set on an entity set
03319  * \param *tag_value Pointer to tag data array being queried
03320  * \param *tag_value_allocated Pointer to tag data array allocated size
03321  * \param *tag_value_size Pointer to occupied size in bytes of tag data
03322  *        array
03323  * \param *err Pointer to error type returned from function
03324  */
03325 void FBiGeom_getEntSetData( FBiGeom_Instance instance,
03326                             iBase_EntitySetHandle entity_set_handle,
03327                             iBase_TagHandle tag_handle,
03328                             void** tag_value,
03329                             int* tag_value_allocated,
03330                             int* tag_value_size,
03331                             int* err );
03332 
03333 /**\brief  Get the value of a tag of integer type on an entity set
03334  *
03335  * Get the value of a tag of integer type on an entity set.
03336  * \param instance FBiGeom instance handle
03337  * \param entity_set Entity set on which tag is being set
03338  * \param tag_handle Tag being set on an entity set
03339  * \param *out_data Pointer to tag value returned from function
03340  * \param *err Pointer to error type returned from function
03341  */
03342 void FBiGeom_getEntSetIntData( FBiGeom_Instance instance,
03343                                iBase_EntitySetHandle entity_set,
03344                                iBase_TagHandle tag_handle,
03345                                int* out_data,
03346                                int* err );
03347 
03348 /**\brief  Get the value of a tag of double type on an entity set
03349  *
03350  * Get the value of a tag of double type on an entity set.
03351  * \param instance FBiGeom instance handle
03352  * \param entity_set Entity set on which tag is being set
03353  * \param tag_handle Tag being set on an entity set
03354  * \param *out_data Pointer to tag value returned from function
03355  * \param *err Pointer to error type returned from function
03356  */
03357 void FBiGeom_getEntSetDblData( FBiGeom_Instance instance,
03358                                iBase_EntitySetHandle entity_set,
03359                                iBase_TagHandle tag_handle,
03360                                double* out_data,
03361                                int* err );
03362 
03363 /**\brief  Get the value of a tag of entity handle type on an entity set
03364  *
03365  * Get the value of a tag of entity handle type on an entity set.
03366  * \param instance FBiGeom instance handle
03367  * \param entity_set Entity set on which tag is being set
03368  * \param tag_handle Tag being set on an entity set
03369  * \param *out_data Pointer to tag value returned from function
03370  * \param *err Pointer to error type returned from function
03371  */
03372 void FBiGeom_getEntSetEHData( FBiGeom_Instance instance,
03373                               iBase_EntitySetHandle entity_set,
03374                               iBase_TagHandle tag_handle,
03375                               iBase_EntityHandle* out_data,
03376                               int* err );
03377 
03378 /**\brief  Get the value of a tag of entity set handle type on an entity set
03379  *
03380  * Get the value of a tag of entity set handle type on an entity set.
03381  * \param instance FBiGeom instance handle
03382  * \param entity_set Entity set on which tag is being set
03383  * \param tag_handle Tag being set on an entity set
03384  * \param *out_data Pointer to tag value returned from function
03385  * \param *err Pointer to error type returned from function
03386  */
03387 void FBiGeom_getEntSetESHData( FBiGeom_Instance instance,
03388                                iBase_EntitySetHandle entity_set,
03389                                iBase_TagHandle tag_handle,
03390                                iBase_EntitySetHandle* out_data,
03391                                int* err );
03392 
03393 /**\brief  Get all the tags associated with a specified entity set
03394  *
03395  * Get all the tags associated with a specified entity set
03396  * \param instance FBiGeom instance handle
03397  * \param entity_set_handle Entity being queried
03398  * \param *tag_handles Pointer to array of tag_handles returned from
03399  *        function
03400  * \param *tag_handles_allocated Pointer to allocated size of tag_handles
03401  *        array
03402  * \param *tag_handles_size Pointer to occupied size of tag_handles array
03403  * \param *err Pointer to error type returned from function
03404  */
03405 void FBiGeom_getAllEntSetTags( FBiGeom_Instance instance,
03406                                iBase_EntitySetHandle entity_set_handle,
03407                                iBase_TagHandle** tag_handles,
03408                                int* tag_handles_allocated,
03409                                int* tag_handles_size,
03410                                int* err );
03411 
03412 /**\brief  Remove a tag value from an entity set
03413  *
03414  * Remove a tag value from an entity set
03415  * \param instance FBiGeom instance handle
03416  * \param entity_set_handle Entity set from which tag is being removed
03417  * \param tag_handle Tag handle of tag being removed
03418  * \param *err Pointer to error type returned from function
03419  */
03420 void FBiGeom_rmvEntSetTag( FBiGeom_Instance instance,
03421                            iBase_EntitySetHandle entity_set_handle,
03422                            iBase_TagHandle tag_handle,
03423                            int* err );
03424 
03425 /**\brief  Get tag values of arbitrary type for an array of entities
03426  *
03427  * Get tag values of arbitrary type for an array of entities.  Tag data
03428  * is returned as void*. tag_values_size specifies the size of the
03429  * memory pointed to by tag_values in terms of bytes. Applications may
03430  * use this function to get data of any type, not just iBase_BYTES.
03431  * However, because this function supports data of arbitrary type, in
03432  * all cases the size specified by tag_values_size always in terms of
03433  * bytes.
03434  *
03435  * \param instance FBiGeom instance handle
03436  * \param entity_handles Entity array on which tag is being set
03437  * \param entity_handles_size Number of entities in array
03438  * \param tag_handle Tag being set on an entity
03439  * \param *tag_values Pointer to tag data array being returned from
03440  *        function. Note that the implicit INTERLEAVED storage
03441  *        order rule applies (see section ITAPS Storage Orders)
03442  * \param tag_values_allocated Pointer to allocated size of tag data array
03443  * \param tag_values_size Pointer to occupied size in bytes of tag data
03444  *        array
03445  * \param *err Pointer to error type returned from function
03446  */
03447 void FBiGeom_getArrData( FBiGeom_Instance instance,
03448                          const iBase_EntityHandle* entity_handles,
03449                          int entity_handles_size,
03450                          iBase_TagHandle tag_handle,
03451                          void** tag_values,
03452                          int* tag_values_allocated,
03453                          int* tag_values_size,
03454                          int* err );
03455 
03456 /**\brief  Get tag values of integer type for an array of entities
03457  *
03458  * Get tag values of integer type for an array of entities.
03459  * \param instance FBiGeom instance handle
03460  * \param entity_handles Entity array on which tag is being set
03461  * \param entity_handles_size Number of entities in array
03462  * \param tag_handle Tag being set on an entity
03463  * \param *tag_values Pointer to tag data array being returned from
03464  *        function
03465  * \param tag_values_allocated Pointer to allocated size of tag data array
03466  * \param tag_values_size Pointer to occupied size of tag data array
03467  * \param *err Pointer to error type returned from function
03468  */
03469 void FBiGeom_getIntArrData( FBiGeom_Instance instance,
03470                             const iBase_EntityHandle* entity_handles,
03471                             int entity_handles_size,
03472                             iBase_TagHandle tag_handle,
03473                             int** tag_values,
03474                             int* tag_values_allocated,
03475                             int* tag_values_size,
03476                             int* err );
03477 
03478 /**\brief  Get tag values of double type for an array of entities
03479  *
03480  * Get tag values of double type for an array of entities.
03481  * \param instance FBiGeom instance handle
03482  * \param entity_handles Entity array on which tag is being set
03483  * \param entity_handles_size Number of entities in array
03484  * \param tag_handle Tag being set on an entity
03485  * \param *tag_values Pointer to tag data array being returned from
03486  *        function
03487  * \param tag_values_allocated Pointer to allocated size of tag data array
03488  * \param tag_values_size Pointer to occupied size of tag data array
03489  * \param *err Pointer to error type returned from function
03490  */
03491 void FBiGeom_getDblArrData( FBiGeom_Instance instance,
03492                             const iBase_EntityHandle* entity_handles,
03493                             int entity_handles_size,
03494                             iBase_TagHandle tag_handle,
03495                             double** tag_values,
03496                             int* tag_values_allocated,
03497                             int* tag_values_size,
03498                             int* err );
03499 
03500 /**\brief  Get tag values of entity handle type for an array of entities
03501  *
03502  * Get tag values of entity handle type for an array of entities.
03503  * \param instance FBiGeom instance handle
03504  * \param entity_handles Entity array on which tag is being set
03505  * \param entity_handles_size Number of entities in array
03506  * \param tag_handle Tag being set on an entity
03507  * \param *tag_value Pointer to tag data array being returned from
03508  *        function
03509  * \param tag_value_allocated Pointer to allocated size of tag data array
03510  * \param tag_value_size Pointer to occupied size of tag data array
03511  * \param *err Pointer to error type returned from function
03512  */
03513 void FBiGeom_getEHArrData( FBiGeom_Instance instance,
03514                            const iBase_EntityHandle* entity_handles,
03515                            int entity_handles_size,
03516                            iBase_TagHandle tag_handle,
03517                            iBase_EntityHandle** tag_value,
03518                            int* tag_value_allocated,
03519                            int* tag_value_size,
03520                            int* err );
03521 
03522 /**\brief  Get tag values of entity set handle type for an array of entities
03523  *
03524  * Get tag values of entity set handle type for an array of entities.
03525  * \param instance FBiGeom instance handle
03526  * \param entity_handles Entity array on which tag is being set
03527  * \param entity_handles_size Number of entities in array
03528  * \param tag_handle Tag being set on an entity
03529  * \param *tag_value Pointer to tag data array being returned from
03530  *        function
03531  * \param tag_value_allocated Pointer to allocated size of tag data array
03532  * \param tag_value_size Pointer to occupied size of tag data array
03533  * \param *err Pointer to error type returned from function
03534  */
03535 void FBiGeom_getESHArrData( FBiGeom_Instance instance,
03536                             const iBase_EntityHandle* entity_handles,
03537                             int entity_handles_size,
03538                             iBase_TagHandle tag_handle,
03539                             iBase_EntitySetHandle** tag_value,
03540                             int* tag_value_allocated,
03541                             int* tag_value_size,
03542                             int* err );
03543 
03544 /**\brief  Set tag values of arbitrary type on an array of entities
03545  *
03546  * Set tag values of arbitrary type on an array of entities.  Tag data
03547  * is passed as void*. tag_values_size specifies the size of the
03548  * memory pointed to by tag_values in terms of bytes. Applications may
03549  * use this function to set data of any type, not just iBase_BYTES.
03550  * However, because this function supports data of arbitrary type, in all
03551  * cases the size specified by tag_values_size is always in terms of
03552  * bytes.
03553  *
03554  * \param instance FBiGeom instance handle
03555  * \param entity_handles Entity array on which tag is being set
03556  * \param entity_handles_size Number of entities in array
03557  * \param tag_handle Tag being set on an entity
03558  * \param tag_values Pointer to tag data being set on entity. Note that
03559  *        the implicit INTERLEAVED storage order rule applies (see section
03560  *        ITAPS Storage Orders)
03561  * \param tag_values_size Size in bytes of tag data
03562  * \param *err Pointer to error type returned from function
03563  */
03564 void FBiGeom_setArrData( FBiGeom_Instance instance,
03565                          const iBase_EntityHandle* entity_handles,
03566                          int entity_handles_size,
03567                          iBase_TagHandle tag_handle,
03568                          const void* tag_values,
03569                          int tag_values_size,
03570                          int* err );
03571 
03572 /**\brief  Set tag values of integer type on an array of entities
03573  *
03574  * Set tag values of integer type on an array of entities.
03575  * \param instance FBiGeom instance handle
03576  * \param entity_handles Entity array on which tag is being set
03577  * \param entity_handles_size Number of entities in array
03578  * \param tag_handle Tag being set on an entity
03579  * \param tag_values Pointer to tag data being set on entities
03580  * \param tag_values_size Size in total number of integers of tag data
03581  * \param *err Pointer to error type returned from function
03582  */
03583 void FBiGeom_setIntArrData( FBiGeom_Instance instance,
03584                             const iBase_EntityHandle* entity_handles,
03585                             int entity_handles_size,
03586                             iBase_TagHandle tag_handle,
03587                             const int* tag_values,
03588                             int tag_values_size,
03589                             int* err );
03590 
03591 /**\brief  Set tag values of double type on an array of entities
03592  *
03593  * Set tag values of double type on an array of entities.
03594  * \param instance FBiGeom instance handle
03595  * \param entity_handles Entity array on which tag is being set
03596  * \param entity_handles_size Number of entities in array
03597  * \param tag_handle Tag being set on an entity
03598  * \param tag_values Pointer to tag data being set on entities
03599  * \param tag_values_size Size in total number of doubles of tag data
03600  * \param *err Pointer to error type returned from function
03601  */
03602 void FBiGeom_setDblArrData( FBiGeom_Instance instance,
03603                             const iBase_EntityHandle* entity_handles,
03604                             int entity_handles_size,
03605                             iBase_TagHandle tag_handle,
03606                             const double* tag_values,
03607                             const int tag_values_size,
03608                             int* err );
03609 
03610 /**\brief  Set tag values of entity handle type on an array of entities
03611  *
03612  * Set tag values of entity handle type on an array of entities.
03613  * \param instance FBiGeom instance handle
03614  * \param entity_handles Entity array on which tag is being set
03615  * \param entity_handles_size Number of entities in array
03616  * \param tag_handle Tag being set on an entity
03617  * \param tag_values Pointer to tag data being set on entities
03618  * \param tag_values_size Size in total number of entity handles of tag
03619  *        data
03620  * \param *err Pointer to error type returned from function
03621  */
03622 void FBiGeom_setEHArrData( FBiGeom_Instance instance,
03623                            const iBase_EntityHandle* entity_handles,
03624                            int entity_handles_size,
03625                            iBase_TagHandle tag_handle,
03626                            const iBase_EntityHandle* tag_values,
03627                            int tag_values_size,
03628                            int* err );
03629 
03630 /**\brief  Set tag values of entity set handle type on an array of entities
03631  *
03632  * Set tag values of entity set handle type on an array of entities.
03633  * \param instance FBiGeom instance handle
03634  * \param entity_handles Entity array on which tag is being set
03635  * \param entity_handles_size Number of entities in array
03636  * \param tag_handle Tag being set on an entity
03637  * \param tag_values Pointer to tag data being set on entities
03638  * \param tag_values_size Size in total number of entity handles of tag
03639  *        data
03640  * \param *err Pointer to error type returned from function
03641  */
03642 void FBiGeom_setESHArrData( FBiGeom_Instance instance,
03643                             const iBase_EntityHandle* entity_handles,
03644                             int entity_handles_size,
03645                             iBase_TagHandle tag_handle,
03646                             const iBase_EntitySetHandle* tag_values,
03647                             int tag_values_size,
03648                             int* err );
03649 
03650 /**\brief  Remove a tag value from an array of entities
03651  *
03652  * Remove a tag value from an array of entities
03653  * \param instance FBiGeom instance handle
03654  * \param entity_handles Entity from which tag is being removed
03655  * \param entity_handles_size Number of entities in entity array
03656  * \param tag_handle Tag handle of tag being removed
03657  * \param *err Pointer to error type returned from function
03658  */
03659 void FBiGeom_rmvArrTag( FBiGeom_Instance instance,
03660                         const iBase_EntityHandle* entity_handles,
03661                         int entity_handles_size,
03662                         iBase_TagHandle tag_handle,
03663                         int* err );
03664 
03665 /**\brief  Get the value of a tag of arbitrary type on an entity
03666  *
03667  * Get the value of a tag of arbitrary type on an entity.  Tag data
03668  * is passed back as void*. tag_value_size specifies the size of the
03669  * memory pointed to by tag_value in terms of bytes. Applications may
03670  * use this function to get data of any type, not just iBase_BYTES.
03671  * However, because this function supports arbitrary type, in all
03672  * cases the size specified by tag_value_size is always in terms of
03673  * bytes.
03674  *
03675  * \param instance FBiGeom instance handle
03676  * \param entity_handle Entity on which tag is being set
03677  * \param tag_handle Tag being set on an entity
03678  * \param *tag_value Pointer to tag data array being queried
03679  * \param *tag_value_allocated Pointer to tag data array allocated size
03680  * \param *tag_value_size Pointer to occupied size in bytes of tag data
03681  *        array
03682  * \param *err Pointer to error type returned from function
03683  */
03684 void FBiGeom_getData( FBiGeom_Instance instance,
03685                       iBase_EntityHandle entity_handle,
03686                       iBase_TagHandle tag_handle,
03687                       void** tag_value,
03688                       int* tag_value_allocated,
03689                       int* tag_value_size,
03690                       int* err );
03691 
03692 /**\brief  Get the value of a tag of integer type on an entity
03693  *
03694  * Get the value of a tag of integer type on an entity.
03695  * \param instance FBiGeom instance handle
03696  * \param entity_handle Entity on which tag is being set
03697  * \param tag_handle Tag being set on an entity
03698  * \param *out_data Pointer to tag value returned from function
03699  * \param *err Pointer to error type returned from function
03700  */
03701 void FBiGeom_getIntData( FBiGeom_Instance instance,
03702                          iBase_EntityHandle entity_handle,
03703                          iBase_TagHandle tag_handle,
03704                          int* out_data,
03705                          int* err );
03706 
03707 /**\brief  Get the value of a tag of double type on an entity
03708  *
03709  * Get the value of a tag of double type on an entity.
03710  * \param instance FBiGeom instance handle
03711  * \param entity_handle Entity on which tag is being set
03712  * \param tag_handle Tag being set on an entity
03713  * \param *out_data Pointer to tag value returned from function
03714  * \param *err Pointer to error type returned from function
03715  */
03716 void FBiGeom_getDblData( FBiGeom_Instance instance,
03717                          /*in*/ const iBase_EntityHandle entity_handle,
03718                          /*in*/ const iBase_TagHandle tag_handle,
03719                          double* out_data,
03720                          int* err );
03721 
03722 /**\brief  Get the value of a tag of entity handle type on an entity
03723  *
03724  * Get the value of a tag of entity handle type on an entity.
03725  * \param instance FBiGeom instance handle
03726  * \param entity_handle Entity on which tag is being set
03727  * \param tag_handle Tag being set on an entity
03728  * \param *out_data Pointer to tag value returned from function
03729  * \param *err Pointer to error type returned from function
03730  */
03731 void FBiGeom_getEHData( FBiGeom_Instance instance,
03732                         iBase_EntityHandle entity_handle,
03733                         iBase_TagHandle tag_handle,
03734                         iBase_EntityHandle* out_data,
03735                         int* err );
03736 
03737 /**\brief  Get the value of a tag of entity set handle type on an entity
03738  *
03739  * Get the value of a tag of entity set handle type on an entity.
03740  * \param instance FBiGeom instance handle
03741  * \param entity_handle Entity on which tag is being set
03742  * \param tag_handle Tag being set on an entity
03743  * \param *out_data Pointer to tag value returned from function
03744  * \param *err Pointer to error type returned from function
03745  */
03746 void FBiGeom_getESHData( FBiGeom_Instance instance,
03747                          iBase_EntityHandle entity_handle,
03748                          iBase_TagHandle tag_handle,
03749                          iBase_EntitySetHandle* out_data,
03750                          int* err );
03751 
03752 /**\brief  Set a tag value of arbitrary type on an entity
03753  *
03754  * Set a tag value of arbitrary type on an entity.  Tag data
03755  * is passed as void*. tag_value_size specifies the size of the
03756  * memory pointed to by tag_value in terms of bytes. Applications may
03757  * use this function to set data of any type, not just iBase_BYTES.
03758  * However, because this function supports data of arbitrary type, in
03759  * all cases the size specified by tag_value_size is always in terms
03760  * of bytes.
03761  *
03762  * \param instance FBiGeom instance handle
03763  * \param entity_handle Entity on which tag is being set
03764  * \param tag_handle Tag being set on an entity
03765  * \param tag_value Pointer to tag data being set on entity
03766  * \param tag_value_size Size in bytes of tag data
03767  * \param *err Pointer to error type returned from function
03768  */
03769 void FBiGeom_setData( FBiGeom_Instance instance,
03770                       iBase_EntityHandle entity_handle,
03771                       iBase_TagHandle tag_handle,
03772                       const void* tag_value,
03773                       int tag_value_size,
03774                       int* err );
03775 
03776 /**\brief  Set a tag value of integer type on an entity
03777  *
03778  * Set a tag value of integer type on an entity.
03779  * \param instance FBiGeom instance handle
03780  * \param entity_handle Entity on which tag is being set
03781  * \param tag_handle Tag being set on an entity
03782  * \param tag_value Tag value being set on entity
03783  * \param *err Pointer to error type returned from function
03784  */
03785 void FBiGeom_setIntData( FBiGeom_Instance instance,
03786                          iBase_EntityHandle entity_handle,
03787                          iBase_TagHandle tag_handle,
03788                          int tag_value,
03789                          int* err );
03790 
03791 /**\brief  Set a tag value of double type on an entity
03792  *
03793  * Set a tag value of double type on an entity.
03794  * \param instance FBiGeom instance handle
03795  * \param entity_handle Entity on which tag is being set
03796  * \param tag_handle Tag being set on an entity
03797  * \param tag_value Tag value being set on entity
03798  * \param *err Pointer to error type returned from function
03799  */
03800 void FBiGeom_setDblData( FBiGeom_Instance instance,
03801                          iBase_EntityHandle entity_handle,
03802                          iBase_TagHandle tag_handle,
03803                          double tag_value,
03804                          int* err );
03805 
03806 /**\brief  Set a tag value of entity handle type on an entity
03807  *
03808  * Set a tag value of entity handle type on an entity.
03809  * \param instance FBiGeom instance handle
03810  * \param entity_handle Entity on which tag is being set
03811  * \param tag_handle Tag being set on an entity
03812  * \param tag_value Tag value being set on entity
03813  * \param *err Pointer to error type returned from function
03814  */
03815 void FBiGeom_setEHData( FBiGeom_Instance instance,
03816                         iBase_EntityHandle entity_handle,
03817                         iBase_TagHandle tag_handle,
03818                         iBase_EntityHandle tag_value,
03819                         int* err );
03820 
03821 /**\brief  Set a tag value of entity set handle type on an entity
03822  *
03823  * Set a tag value of entity set handle type on an entity.
03824  * \param instance FBiGeom instance handle
03825  * \param entity_handle Entity on which tag is being set
03826  * \param tag_handle Tag being set on an entity
03827  * \param tag_value Tag value being set on entity
03828  * \param *err Pointer to error type returned from function
03829  */
03830 void FBiGeom_setESHData( FBiGeom_Instance instance,
03831                          iBase_EntityHandle entity_handle,
03832                          iBase_TagHandle tag_handle,
03833                          iBase_EntitySetHandle tag_value,
03834                          int* err );
03835 
03836 /**\brief  Get all the tags associated with a specified entity handle
03837  *
03838  * Get all the tags associated with a specified entity handle
03839  * \param instance FBiGeom instance handle
03840  * \param entity_handle Entity being queried
03841  * \param *tag_handles Pointer to array of tag_handles returned from
03842  *        function
03843  * \param *tag_handles_allocated Pointer to allocated size of tag_handles
03844  *        array
03845  * \param *tag_handles_size Pointer to occupied size of tag_handles array
03846  * \param *err Pointer to error type returned from function
03847  */
03848 void FBiGeom_getAllTags( FBiGeom_Instance instance,
03849                          iBase_EntityHandle entity_handle,
03850                          iBase_TagHandle** tag_handles,
03851                          int* tag_handles_allocated,
03852                          int* tag_handles_size,
03853                          int* err );
03854 
03855 /**\brief  Remove a tag value from an entity
03856  *
03857  * Remove a tag value from an entity
03858  * \param instance FBiGeom instance handle
03859  * \param entity_handle Entity from which tag is being removed
03860  * \param tag_handle Tag handle of tag being removed
03861  * \param *err Pointer to error type returned from function
03862  */
03863 void FBiGeom_rmvTag( FBiGeom_Instance instance,
03864                      iBase_EntityHandle entity_handle,
03865                      iBase_TagHandle tag_handle,
03866                      int* err );
03867 
03868 /**\brief  Subtract contents of one entity set from another
03869  *
03870  * Subtract contents of one entity set from another
03871  * \param instance FBiGeom instance handle
03872  * \param entity_set_1 Entity set from which other set is being subtracted
03873  * \param entity_set_2 Entity set being subtracted from other set
03874  * \param result_entity_set Pointer to entity set returned from function
03875  * \param *err Pointer to error type returned from function
03876  */
03877 void FBiGeom_subtract( FBiGeom_Instance instance,
03878                        iBase_EntitySetHandle entity_set_1,
03879                        iBase_EntitySetHandle entity_set_2,
03880                        iBase_EntitySetHandle* result_entity_set,
03881                        int* err );
03882 
03883 /**\brief  Intersect contents of one entity set with another
03884  *
03885  * Intersect contents of one entity set with another
03886  * \param instance FBiGeom instance handle
03887  * \param entity_set_1 Entity set being intersected with another
03888  * \param entity_set_2 Entity set being intersected with another
03889  * \param result_entity_set Pointer to entity set returned from function
03890  * \param *err Pointer to error type returned from function
03891  */
03892 void FBiGeom_intersect( FBiGeom_Instance instance,
03893                         iBase_EntitySetHandle entity_set_1,
03894                         iBase_EntitySetHandle entity_set_2,
03895                         iBase_EntitySetHandle* result_entity_set,
03896                         int* err );
03897 
03898 /**\brief  Unite contents of one entity set with another
03899  *
03900  * Unite contents of one entity set with another
03901  * \param instance FBiGeom instance handle
03902  * \param entity_set_1 Entity set being united with another
03903  * \param entity_set_2 Entity set being united with another
03904  * \param result_entity_set Pointer to entity set returned from function
03905  * \param *err Pointer to error type returned from function
03906  */
03907 void FBiGeom_unite( FBiGeom_Instance instance,
03908                     iBase_EntitySetHandle entity_set_1,
03909                     iBase_EntitySetHandle entity_set_2,
03910                     iBase_EntitySetHandle* result_entity_set,
03911                     int* err );
03912 
03913 /**\brief  Return facet information from solid modeling engine
03914  *
03915  * Return facet information from solid modeling engine
03916  * \param instance FBiGeom instance handle
03917  * \param entity_handle Entity being queried
03918  * \param dist_tolerance Tolerance guidance for faceting engine
03919  * \param points List of vertices in faceting of curve or surface
03920  * \param points_allocated Allocated size of vertex list array
03921  * \param points_size Occupied size of vertex list array
03922  * \param facets List of facets in faceting of surface
03923  * \param facets_allocated Allocated size of facet list array
03924  * \param facets_size Occupied size of facet list array
03925  * \param *err Pointer to error type returned from function
03926  */
03927 void FBiGeom_getFacets( FBiGeom_Instance instance,
03928                         iBase_EntityHandle entity,
03929                         double dist_tolerance,
03930                         double** points,
03931                         int* points_allocated,
03932                         int* points_size,
03933                         int** facets,
03934                         int* facets_allocated,
03935                         int* facets_size,
03936                         int* err );
03937 
03938 #ifdef __cplusplus
03939 } /* extern "C" */
03940 #endif
03941 
03942 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines