MOAB: Mesh Oriented datABase  (version 5.2.1)
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, char const* name, char const* options, int* err, int name_len,
00140                    int options_len );
00141 
00142 /**\brief  Save a geom to a file
00143  *
00144  * Save a geom to a file.  If entity set is specified, save only the
00145  * geom contained in that set.
00146  * \param instance FBiGeom instance handle
00147  * \param entity_set_handle Entity set being saved
00148  * \param name File name to which geom is to be saved
00149  * \param options Pointer to implementation-specific options string
00150  * \param *err Pointer to error type returned from function
00151  * \param name_len Length of the file name character string
00152  * \param options_len Length of the options character string
00153  */
00154 void FBiGeom_save( FBiGeom_Instance instance, char const* name, char const* options, int* err, int name_len,
00155                    int options_len );
00156 
00157 /**\brief  Get handle of the root set for this instance
00158  *
00159  * Get handle of the root set for this instance.  All geom in
00160  * this instance can be accessed from this set.
00161  * \param instance FBiGeom instance handle
00162  * \param root_set Pointer to set handle returned from function
00163  * \param *err Pointer to error type returned from function
00164  */
00165 void FBiGeom_getRootSet( FBiGeom_Instance instance, iBase_EntitySetHandle* root_set, int* err );
00166 
00167 /**\brief Get the bounding box of the entire model
00168  *
00169  * Get the bounding box of the entire model
00170  * \param instance FBiGeom instance handle
00171  * \param min_x Minimum coordinate of bounding box
00172  * \param min_y Minimum coordinate of bounding box
00173  * \param min_z Minimum coordinate of bounding box
00174  * \param max_x Maximum coordinate of bounding box
00175  * \param max_y Maximum coordinate of bounding box
00176  * \param max_z Maximum coordinate of bounding box
00177  * \param *err Pointer to error type returned from function
00178  */
00179 void FBiGeom_getBoundBox( FBiGeom_Instance instance, double* min_x, double* min_y, double* min_z, double* max_x,
00180                           double* max_y, double* max_z, int* err );
00181 
00182 /**\brief  Get entities of specific type in set or instance
00183  *
00184  * Get entities of specific type in set or instance.  All entities are
00185  * requested by specifying iBase_ALL_TYPES.  Specified type must be a value
00186  * in the iBase_EntityType enumeration.
00187  * \param instance FBiGeom instance handle
00188  * \param entity_set_handle Entity set being queried
00189  * \param entity_type Type of entities being requested
00190  * \param entity_topology Topology of entities being requested
00191  * \param *entity_handles Pointer to array of entity handles returned
00192  *        from function
00193  * \param *entity_handles_allocated Pointer to allocated size of
00194  *        entity_handles array
00195  * \param *entity_handles_size Pointer to occupied size of entity_handles
00196  *        array
00197  * \param *err Pointer to error type returned from function
00198  */
00199 void FBiGeom_getEntities( FBiGeom_Instance instance, iBase_EntitySetHandle set_handle, int entity_type,
00200                           iBase_EntityHandle** entity_handles, int* entity_handles_allococated,
00201                           int* entity_handles_size, int* err );
00202 
00203 /**\brief  Get the number of entities with the specified type in the
00204  *         instance or set
00205  *
00206  * Get the number of entities with the specified type in the instance
00207  * or set.  If entity set handle is zero, return information for instance,
00208  * otherwise for set.  Value of entity type must be from the
00209  * iBase_EntityType enumeration.  If iBase_ALL_TYPES is specified, total
00210  * number of entities (excluding entity sets) is returned.
00211  * \param instance FBiGeom instance handle
00212  * \param entity_set_handle Entity set being queried
00213  * \param entity_type Type of entity requested
00214  * \param num_type Pointer to number of entities, returned from function
00215  * \param *err Pointer to error type returned from function
00216  */
00217 void FBiGeom_getNumOfType( FBiGeom_Instance instance, iBase_EntitySetHandle set_handle, int entity_type, int* num_out,
00218                            int* err );
00219 
00220 /**\brief  Get the entity type for the specified entity
00221  *
00222  * Get the entity type for the specified entity.  Type returned is a value
00223  * in the iBase_EntityType enumeration.
00224  * \param instance FBiGeom instance handle
00225  * \param entity_handle entity handle being queried
00226  * \param *type Pointer to location at which to store the returned type
00227  * \param *err Pointer to error type returned from function
00228  */
00229 void FBiGeom_getEntType( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* type, int* err );
00230 
00231 /**\brief  Get the entity type for the specified entities
00232  *
00233  * Get the entity type for the specified entities.  Types returned are
00234  * values in the iBase_EntityType enumeration.
00235  * \param instance FBiGeom instance handle
00236  * \param entity_handles Array of entity handles being queried
00237  * \param entity_handles_size Number of entities in entity_handles array
00238  * \param *type Pointer to array of types returned from function
00239  * \param *type_allocated Pointer to allocated size of type array
00240  * \param *type_size Pointer to occupied size of type array
00241  * \param *err Pointer to error type returned from function
00242  */
00243 void FBiGeom_getArrType( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
00244                          int** type, int* type_allocated, int* type_size, int* err );
00245 
00246 /**\brief  Get entities of specified type adjacent to an entity
00247  *
00248  * Get entities of specified type adjacent to an entity.  Specified type
00249  * must be value in the iBase_EntityType enumeration.
00250  * \param instance FBiGeom instance handle
00251  * \param entity_handle Entity handle being queried
00252  * \param entity_type_requested Type of adjacent entities requested
00253  * \param *adj_entity_handles Pointer to array of adjacent entities
00254  *        returned from function
00255  * \param *adj_entity_handles_allocated Pointer to allocated size of
00256  *        adj_entity_handles array
00257  * \param *adj_entity_handles_size Pointer to occupied size of
00258  *        adj_entity_handles array
00259  * \param *err Pointer to error type returned from function
00260  */
00261 void FBiGeom_getEntAdj( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int to_dimension,
00262                         iBase_EntityHandle** adj_entities, int* adj_entities_allocated, int* adj_entities_size,
00263                         int* err );
00264 
00265 /**\brief  Get entities of specified type adjacent to entities
00266  *
00267  * Get entities of specified type adjacent to entities.  Specified type
00268  * must be value in the iBase_EntityType enumeration.  \em offset(i) is
00269  * index of first entity in adjacentEntityHandles array adjacent to
00270  * entity_handles[i].
00271  * \param instance FBiGeom instance handle
00272  * \param entity_handles Array of entity handles being queried
00273  * \param entity_handles_size Number of entities in entity_handles array
00274  * \param entity_type_requested Type of adjacent entities requested
00275  * \param *adjacentEntityHandles Pointer to array of adjacentEntityHandles
00276  *        returned from function
00277  * \param *adjacentEntityHandles_allocated Pointer to allocated size of
00278  *        adjacentEntityHandles array
00279  * \param *adj_entity_handles_size Pointer to occupied size of
00280  *        adjacentEntityHandles array
00281  * \param *offset Pointer to array of offsets returned from function
00282  * \param *offset_allocated Pointer to allocated size of offset array
00283  * \param *offset_size Pointer to occupied size of offset array
00284  * \param *err Pointer to error type returned from function
00285  */
00286 void FBiGeom_getArrAdj( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
00287                         int requested_entity_type, iBase_EntityHandle** adj_entity_handles,
00288                         int* adj_entity_handles_allocated, int* adj_entity_handles_size, int** offset,
00289                         int* offset_allocated, int* offset_size, int* err );
00290 
00291 /**\brief  Get "2nd order" adjacencies to an entity
00292  *
00293  * Get "2nd order" adjacencies to an entity, that is, from an entity,
00294  * through other entities of a specified "bridge" dimension, to other
00295  * entities of another specified "to" dimension.
00296  * \param instance FBiGeom instance handle
00297  * \param entity_handle Entity from which adjacencies are requested
00298  * \param bridge_dimension Bridge dimension for 2nd order adjacencies
00299  * \param to_dimension Dimension of adjacent entities returned
00300  * \param adjacent_entities Adjacent entities
00301  * \param adjacent_entities_allocated Allocated size of returned array
00302  * \param adjacent_entities_size Occupied size of returned array
00303  * \param *err Pointer to error type returned from function
00304  */
00305 void FBiGeom_getEnt2ndAdj( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int bridge_dimension,
00306                            int to_dimension, iBase_EntityHandle** adjacent_entities, int* adjacent_entities_allocated,
00307                            int* adjacent_entities_size, int* err );
00308 
00309 /**\brief  Get "2nd order" adjacencies to an array of entities
00310  *
00311  * Get "2nd order" adjacencies to an array of entities, that is, from each
00312  * entity, through other entities of a specified "bridge" dimension, to
00313  * other entities of another specified "to" dimension.
00314  * \param instance FBiGeom instance handle
00315  * \param entity_handles Entities from which adjacencies are requested
00316  * \param entity_handles_size Number of entities whose adjacencies are
00317  *        requested
00318  * \param bridge_dimension Bridge dimension for 2nd order adjacencies
00319  * \param to_dimension Dimension of adjacent entities returned
00320  * \param adj_entity_handles Adjacent entities
00321  * \param adj_entity_handles_allocated Allocated size of returned array
00322  * \param adj_entity_handles_size Occupied size of returned array
00323  * \param offset Offset[i] is offset into adj_entity_handles of 2nd order
00324  *        adjacencies of ith entity in entity_handles
00325  * \param offset_allocated Allocated size of offset array
00326  * \param offset_size Occupied size of offset array
00327  * \param *err Pointer to error type returned from function
00328  */
00329 void FBiGeom_getArr2ndAdj( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
00330                            int order_adjacent_key, int requested_entity_type, iBase_EntityHandle** adj_entity_handles,
00331                            int* adj_entity_handles_allocated, int* adj_entity_handles_size, int** offset,
00332                            int* offset_allocated, int* offset_size, int* err );
00333 
00334 /**\brief  Return whether two entities are adjacent
00335  *
00336  * Return whether two entities are adjacent.
00337  * \param instance FBiGeom instance handle
00338  * \param entity_handle1 First entity queried
00339  * \param entity_handle2 Second entity queried
00340  * \param are_adjacent If returned non-zero, entities are adjacent,
00341  *        otherwise they are not
00342  * \param *err Pointer to error type returned from function
00343  */
00344 void FBiGeom_isEntAdj( FBiGeom_Instance instance, iBase_EntityHandle entity_handle1, iBase_EntityHandle entity_handle2,
00345                        int* are_adjacent, int* err );
00346 
00347 /**\brief  Return whether entity pairs are adjacent
00348  *
00349  * Return whether entity pairs are adjacent, i.e. if entity_handles_1[i] is
00350  * adjacent to entity_handles_2[i].  This function requires
00351  * entity_handles_1_size and entity_handles_2_size to be equal.
00352  * \param instance FBiGeom instance handle
00353  * \param entity_handles_1 First array of entities
00354  * \param entity_handles_1_size Number of entities in first array
00355  * \param entity_handles_2 Second array of entities
00356  * \param entity_handles_2_size Number of entities in second array
00357  * \param is_adjacent_info Array of flags returned from function
00358  * \param is_adjacent_info_allocated Allocated size of flags array
00359  * \param is_adjacent_info_size Occupied size of flags array
00360  * \param *err Pointer to error type returned from function
00361  */
00362 void FBiGeom_isArrAdj( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles_1, int entity_handles_1_size,
00363                        iBase_EntityHandle const* entity_handles_2, int entity_handles_2_size, int** is_adjacent_info,
00364                        int* is_adjacent_info_allocated, int* is_adjacent_info_size, int* err );
00365 
00366 /**\brief  Return the topology level of the geometry
00367  *
00368  * Return the topology level of the geometry as an integer, where 0 = basic
00369  * entities only, 1 = manifold entities, 2 = non-manifold entities.
00370  * \param instance FBiGeom instance handle
00371  * \param topo_level_out The topology level
00372  * \param *err Pointer to error type returned from function
00373  */
00374 void FBiGeom_getTopoLevel( FBiGeom_Instance instance, int* topo_level_out, int* err );
00375 
00376 /**\brief  Get closest point to an entity
00377  *
00378  * Get closest point to a specified position on an entity
00379  * \param instance FBiGeom instance handle
00380  * \param entity_handle Entity being queried
00381  * \param near_x Coordinates of starting point
00382  * \param near_y Coordinates of starting point
00383  * \param near_z Coordinates of starting point
00384  * \param on_x Closest point on entity
00385  * \param on_y Closest point on entity
00386  * \param on_z Closest point on entity
00387  * \param *err Pointer to error type returned from function
00388  */
00389 void FBiGeom_getEntClosestPt( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double near_x, double near_y,
00390                               double near_z, double* on_x, double* on_y, double* on_z, int* err );
00391 
00392 /**\brief  Get closest point for an array of entities and points
00393  * For surfaces, closest point could be on the void space inside it.
00394  * Get closest point for an array of entities and points.  If either the
00395  * number of entities or number of coordinate triples is unity, then all
00396  * points or entities are queried for that entity or point, respectively,
00397  * otherwise each point corresponds to each entity.  storage_order should be
00398  * a value in the iBase_StorageOrder enum.
00399  * \param instance FBiGeom instance handle
00400  * \param entity_handles Entity(ies) being queried
00401  * \param entity_handles_size Number of entities being queried
00402  * \param storage_order Storage order of input points
00403  * \param near_coordinates Coordinates of starting point(s)
00404  * \param near_coordinates_size Number of values in near_coordinates array
00405  * \param on_coordinates Coordinates of closest points
00406  * \param on_coordinates_allocated Allocated size of closest point array
00407  * \param on_coordinates_size Occupied size of closest point array
00408  * \param *err Pointer to error type returned from function
00409  */
00410 
00411 void FBiGeom_getEntClosestPtTrimmed( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double near_x,
00412                                      double near_y, double near_z, double* on_x, double* on_y, double* on_z, int* err );
00413 
00414 /**\brief  Get closest point for an array of entities and points
00415  * For surfaces, it made sure the closest point in on surface.
00416  * Get closest point for an array of entities and points.  If either the
00417  * number of entities or number of coordinate triples is unity, then all
00418  * points or entities are queried for that entity or point, respectively,
00419  * otherwise each point corresponds to each entity.  storage_order should be
00420  * a value in the iBase_StorageOrder enum.
00421  * \param instance FBiGeom instance handle
00422  * \param entity_handles Entity(ies) being queried
00423  * \param entity_handles_size Number of entities being queried
00424  * \param storage_order Storage order of input points
00425  * \param near_coordinates Coordinates of starting point(s)
00426  * \param near_coordinates_size Number of values in near_coordinates array
00427  * \param on_coordinates Coordinates of closest points
00428  * \param on_coordinates_allocated Allocated size of closest point array
00429  * \param on_coordinates_size Occupied size of closest point array
00430  * \param *err Pointer to error type returned from function
00431  */
00432 void FBiGeom_getArrClosestPt( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00433                               int entity_handles_size, int storage_order, double const* near_coordinates,
00434                               int near_coordinates_size, double** on_coordinates, int* on_coordinates_allocated,
00435                               int* on_coordinates_size, int* err );
00436 
00437 /**\brief  Get the normal vector on an entity at the given position
00438  * Get the normal vector on an entity at the given position.
00439  * \param instance FBiGeom instance handle
00440  * \param entity_handle Entity being queried
00441  * \param x Coordinates of starting point
00442  * \param y Coordinates of starting point
00443  * \param z Coordinates of starting point
00444  * \param nrml_i Normal vector at starting point
00445  * \param nrml_j Normal vector at starting point
00446  * \param nrml_k Normal vector at starting point
00447  * \param *err Pointer to error type returned from function
00448  */
00449 void FBiGeom_getEntNrmlXYZ( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y, double z,
00450                             double* nrml_i, double* nrml_j, double* nrml_k, int* err );
00451 
00452 /**\brief  Get the normal vector on an entity(ies) at given position(s)
00453  *
00454  * Get the normal vector on an entity(ies) at given position(s).  If either
00455  * the number of entities or number of coordinate triples is unity, then all
00456  * points or entities are queried for that entity or point, respectively,
00457  * otherwise each point corresponds to each entity.  storage_order should be
00458  * a value in the iBase_StorageOrder enum.
00459  * \param instance FBiGeom instance handle
00460  * \param entity_handles Entity(ies) being queried
00461  * \param entity_handles_size Number of entities being queried
00462  * \param storage_order Storage order of coordinates
00463  * \param coordinates Starting coordinates
00464  * \param coordinates_size Number of values in coordinates array
00465  * \param normals Normal coordinates
00466  * \param normals_allocated Allocated size of normals array
00467  * \param normals_size Occupied size of normals array
00468  * \param *err Pointer to error type returned from function
00469  */
00470 void FBiGeom_getArrNrmlXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00471                             int entity_handles_size, int storage_order, double const* coordinates, int coordinates_size,
00472                             double** normals, int* normals_allocated, int* normals_size, int* err );
00473 
00474 /**\brief  Get the normal vector AND closest point on an entity at given
00475  *         position
00476  *
00477  * Get the normal vector AND closest point on an entity at a given position.
00478  * \param entity_handle Entity being queried
00479  * \param instance FBiGeom instance handle
00480  * \param x Starting coordinates
00481  * \param y Starting coordinates
00482  * \param z Starting coordinates
00483  * \param pt_x Closest point
00484  * \param pt_y Closest point
00485  * \param pt_z Closest point
00486  * \param nrml_i Normal at closest point
00487  * \param nrml_j Normal at closest point
00488  * \param nrml_k Normal at closest point
00489  * \param *err Pointer to error type returned from function
00490  */
00491 void FBiGeom_getEntNrmlPlXYZ( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y, double z,
00492                               double* pt_x, double* pt_y, double* pt_z, double* nrml_i, double* nrml_j, double* nrml_k,
00493                               int* err );
00494 
00495 /**\brief Get the normal vector AND closest point on an entity(ies) at
00496  *        given position(s)
00497  *
00498  * Get the normal vector AND closest point on an entity(ies) at given
00499  * position(s).  If either the number of entities or number of coordinate
00500  * triples is unity, then all points or entities are queried for that entity
00501  * or point, respectively, otherwise each point corresponds to each entity.
00502  * storage_order should be a value in the iBase_StorageOrder enum.
00503  * \param instance FBiGeom instance handle
00504  * \param entity_handles Entity(ies) being queried
00505  * \param entity_handles_size Number of entity(ies) being queried
00506  * \param storage_order Storage order in near_coordinates array
00507  * \param near_coordinates Starting coordinates
00508  * \param near_coordinates_size Number of values in near_coordinates array
00509  * \param on_coordinates Closest point array
00510  * \param on_coordinates_allocated Allocated size of closest point array
00511  * \param on_coordinates_size Occupied size of closest point array
00512  * \param normals Normal array
00513  * \param normals_allocated Allocated size of normal array
00514  * \param normals_size Occupied size of normal array
00515  * \param *err Pointer to error type returned from function
00516  */
00517 void FBiGeom_getArrNrmlPlXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00518                               int entity_handles_size, int storage_order, double const* near_coordinates,
00519                               int near_coordinates_size, double** on_coordinates, int* on_coordinates_allocated,
00520                               int* on_coordinates_size, double** normals, int* normals_allocated, int* normals_size,
00521                               int* err );
00522 
00523 /**\brief  Get the tangent vector on an entity at given position
00524  *
00525  * Get the tangent vector on an entity at a given position.
00526  * \param instance FBiGeom instance handle
00527  * \param entity_handle Entity being queried
00528  * \param x Starting coordinates
00529  * \param y Starting coordinates
00530  * \param z Starting coordinates
00531  * \param tgnt_i Tangent at closest point
00532  * \param tgnt_j Tangent at closest point
00533  * \param tgnt_k Tangent at closest point
00534  * \param *err Pointer to error type returned from function
00535  */
00536 void FBiGeom_getEntTgntXYZ( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y, double z,
00537                             double* tgnt_i, double* tgnt_j, double* tgnt_k, int* err );
00538 
00539 /**\brief  Get the tangent vector on an entity(ies) at given position(s)
00540  *
00541  * Get the tangent vector on an entity(ies) at given position(s).  If either
00542  * the number of entities or number of coordinate triples is unity, then all
00543  * points or entities are queried for that entity or point, respectively,
00544  * otherwise each point corresponds to each entity.  storage_order should be
00545  * a value in the iBase_StorageOrder enum
00546  * \param instance FBiGeom instance handle
00547  * \param entity_handles Entity(ies) being queried
00548  * \param entity_handles_size Number of entities being queried
00549  * \param storage_order Storage order of coordinates
00550  * \param coordinates Starting coordinates
00551  * \param coordinates_size Number of values in coordinates array
00552  * \param tangents Tangent coordinates
00553  * \param tangents_allocated Allocated size of tangents array
00554  * \param tangents_size Occupied size of tangents array
00555  * \param *err Pointer to error type returned from function
00556  */
00557 void FBiGeom_getArrTgntXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00558                             int entity_handles_size, int storage_order, double const* coordinates, int coordinates_size,
00559                             double** tangents, int* tangents_allocated, int* tangents_size, int* err );
00560 
00561 /**\brief  Get the two principle curvature vectors for a face at a point
00562  *
00563  * Get the two principle curvature vectors for a face at a point.
00564  * Magnitudes of vectors are curvature, directions are directions of
00565  * principal curvatures.
00566  * \param instance FBiGeom instance handle
00567  * \param face_handle Face being queried
00568  * \param x Position being queried
00569  * \param y Position being queried
00570  * \param z Position being queried
00571  * \param cvtr1_i Maximum curvature vector
00572  * \param cvtr1_j Maximum curvature vector
00573  * \param cvtr1_k Maximum curvature vector
00574  * \param cvtr2_i Minimum curvature vector
00575  * \param cvtr2_j Minimum curvature vector
00576  * \param cvtr2_k Minimum curvature vector
00577  * \param *err Pointer to error type returned from function
00578  */
00579 void FBiGeom_getFcCvtrXYZ( FBiGeom_Instance instance, iBase_EntityHandle face_handle, double x, double y, double z,
00580                            double* cvtr1_i, double* cvtr1_j, double* cvtr1_k, double* cvtr2_i, double* cvtr2_j,
00581                            double* cvtr2_k, int* err );
00582 
00583 /**\brief  Get the principle curvature vector for an edge at a point
00584  *
00585  * Get the principle curvature vector for an edge at a point.  Magnitude of
00586  * vector is the curvature, direction is direction of principal curvature.
00587  * \param instance FBiGeom instance handle
00588  * \param edge_handle Edge being queried
00589  * \param x Position being queried
00590  * \param y Position being queried
00591  * \param z Position being queried
00592  * \param cvtr_i Maximum curvature vector
00593  * \param cvtr_j Maximum curvature vector
00594  * \param cvtr_k Maximum curvature vector
00595  * \param *err Pointer to error type returned from function
00596  */
00597 void FBiGeom_getEgCvtrXYZ( FBiGeom_Instance instance, iBase_EntityHandle edge_handle, double x, double y, double z,
00598                            double* cvtr_i, double* cvtr_j, double* cvtr_k, int* err );
00599 
00600 /**\brief  Get the curvature(s) on an entity(ies) at given position(s)
00601  *
00602  * Get the curvature(s) on an entity(ies) at given position(s).  If either
00603  * the number of entities or number of coordinate triples is unity, then all
00604  * points or entities are queried for that entity or point, respectively,
00605  * otherwise each point corresponds to each entity.  storage_order should be
00606  * a value in the iBase_StorageOrder enum.
00607  * \param instance FBiGeom instance handle
00608  * \param entity_handles Entity(ies) being queried
00609  * \param entity_handles_size Number of entities being queried
00610  * \param storage_order Storage order of coordinates
00611  * \param coords Starting coordinates
00612  * \param coords_size Number of values in coordinates array
00613  * \param cvtr_1 First principal curvatures
00614  * \param cvtr_1_allocated Allocated size of first curvature array
00615  * \param cvtr_1_size Occupied size of first curvature array
00616  * \param cvtr_2 Second principal curvatures
00617  * \param cvtr_2_allocated Allocated size of second curvature array
00618  * \param cvtr_2_size Occupied size of second curvature array
00619  * \param *err Pointer to error type returned from function
00620  */
00621 void FBiGeom_getEntArrCvtrXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00622                                int entity_handles_size, int storage_order, double const* coords, int coords_size,
00623                                double** cvtr_1, int* cvtr_1_allocated, int* cvtr_1_size, double** cvtr_2,
00624                                int* cvtr_2_allocated, int* cvtr_2_size, int* err );
00625 
00626 /**\brief  Get closest point, tangent, and curvature of edge
00627  *
00628  * Get closest point, tangent, and curvature of edge.
00629  * \param instance FBiGeom instance handle
00630  * \param edge_handle Edge being queried
00631  * \param x Point at which entity is being queried
00632  * \param y Point at which entity is being queried
00633  * \param z Point at which entity is being queried
00634  * \param on_x Closest point at point being queried
00635  * \param on_y Closest point at point being queried
00636  * \param on_z Closest point at point being queried
00637  * \param tgnt_i Tangent at point being queried
00638  * \param tgnt_j Tangent at point being queried
00639  * \param tgnt_k Tangent at point being queried
00640  * \param cvtr_i Curvature at point being queried
00641  * \param cvtr_j Curvature at point being queried
00642  * \param cvtr_k Curvature at point being queried
00643  * \param *err Pointer to error type returned from function
00644  */
00645 void FBiGeom_getEgEvalXYZ( FBiGeom_Instance instance, iBase_EntityHandle edge_handle, double x, double y, double z,
00646                            double* on_x, double* on_y, double* on_z, double* tgnt_i, double* tgnt_j, double* tgnt_k,
00647                            double* cvtr_i, double* cvtr_j, double* cvtr_k, int* err );
00648 
00649 /**\brief  Get closest point, tangent, and curvature of face
00650  *
00651  * Get closest point, tangent, and curvature of face.  If any of input
00652  * coordinate pointers are NULL, that value is not returned.
00653  * \param instance FBiGeom instance handle
00654  * \param face_handle Face being queried
00655  * \param x Point at which entity is being queried
00656  * \param y Point at which entity is being queried
00657  * \param z Point at which entity is being queried
00658  * \param on_x Closest point at point being queried
00659  * \param on_y Closest point at point being queried
00660  * \param on_z Closest point at point being queried
00661  * \param nrml_i Normal at point being queried
00662  * \param nrml_j Normal at point being queried
00663  * \param nrml_k Normal at point being queried
00664  * \param cvtr1_i First principal curvature at point being queried
00665  * \param cvtr1_j First principal curvature at point being queried
00666  * \param cvtr1_k First principal curvature at point being queried
00667  * \param cvtr2_i Second principal curvature at point being queried
00668  * \param cvtr2_j Second principal curvature at point being queried
00669  * \param cvtr2_k Second principal curvature at point being queried
00670  * \param *err Pointer to error type returned from function
00671  */
00672 void FBiGeom_getFcEvalXYZ( FBiGeom_Instance instance, iBase_EntityHandle face_handle, double x, double y, double z,
00673                            double* on_x, double* on_y, double* on_z, double* nrml_i, double* nrml_j, double* nrml_k,
00674                            double* cvtr1_i, double* cvtr1_j, double* cvtr1_k, double* cvtr2_i, double* cvtr2_j,
00675                            double* cvtr2_k, int* err );
00676 
00677 /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
00678  *         entity(ies) at given position(s)
00679  *
00680  * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
00681  * at given position(s).  If either the number of entities or number of
00682  * coordinate triples is unity, then all points or entities are queried for
00683  * that entity or point, respectively, otherwise each point corresponds to
00684  * each entity.  storage_order should be a value in the iBase_StorageOrder
00685  * enum.
00686  * \param instance FBiGeom instance handle
00687  * \param edge_handles Edge(s) being queried
00688  * \param edge_handles_size Number of edges being queried
00689  * \param storage_order Storage order of coordinates
00690  * \param coords Starting coordinates
00691  * \param coords_size Number of values in coordinates array
00692  * \param on_coords Closest point array
00693  * \param on_coords_allocated Allocated size of closest point array
00694  * \param on_coords_size Occupied size of closest point array
00695  * \param tangent Tangent array
00696  * \param tangent_allocated Allocated size of tangent array
00697  * \param tangent_size Occupied size of tangent array
00698  * \param cvtr First principal curvatures
00699  * \param cvtr_allocated Allocated size of first curvature array
00700  * \param cvtr_size Occupied size of first curvature array
00701  * \param *err Pointer to error type returned from function
00702  */
00703 void FBiGeom_getArrEgEvalXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* edge_handles, int edge_handles_size,
00704                               int storage_order, double const* coords, int coords_size, double** on_coords,
00705                               int* on_coords_allocated, int* on_coords_size, double** tangent, int* tangent_allocated,
00706                               int* tangent_size, double** cvtr, int* cvtr_allocated, int* cvtr_size, int* err );
00707 
00708 /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
00709  *         entity(ies) at given position(s)
00710  *
00711  * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
00712  * at given position(s).  If either the number of entities or number of
00713  * coordinate triples is unity, then all points or entities are queried for
00714  * that entity or point, respectively, otherwise each point corresponds to
00715  * each entity.  storage_order should be a value in the iBase_StorageOrder
00716  * enum.
00717  * \param instance FBiGeom instance handle
00718  * \param edge_handles Edge(s) being queried
00719  * \param edge_handles_size Number of edges being queried
00720  * \param storage_order Storage order of coordinates
00721  * \param coords Starting coordinates
00722  * \param coords_size Number of values in coordinates array
00723  * \param on_coords Closest point array
00724  * \param on_coords_allocated Allocated size of closest point array
00725  * \param on_coords_size Occupied size of closest point array
00726  * \param normal Normal array
00727  * \param normal_allocated Allocated size of normal array
00728  * \param normal_size Occupied size of normal array
00729  * \param cvtr_1 First principal curvatures
00730  * \param cvtr_1_allocated Allocated size of first curvature array
00731  * \param cvtr_1_size Occupied size of first curvature array
00732  * \param cvtr_2 Second principal curvatures
00733  * \param cvtr_2_allocated Allocated size of second curvature array
00734  * \param cvtr_2_size Occupied size of second curvature array
00735  * \param *err Pointer to error type returned from function
00736  */
00737 void FBiGeom_getArrFcEvalXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* face_handles, int face_handles_size,
00738                               int storage_order, double const* coords, int coords_size, double** on_coords,
00739                               int* on_coords_allocated, int* on_coords_size, double** normal, int* normal_allocated,
00740                               int* normal_size, double** cvtr1, int* cvtr1_allocated, int* cvtr1_size, double** cvtr2,
00741                               int* cvtr2_allocated, int* cvtr2_size, int* err );
00742 
00743 /**\brief  Get the bounding box of the specified entity
00744  *
00745  * Get the bounding box of the specified entity
00746  * \param instance FBiGeom instance handle
00747  * \param entity_handle Entity being queried
00748  * \param min_x Minimum coordinate of bounding box
00749  * \param min_y Minimum coordinate of bounding box
00750  * \param min_z Minimum coordinate of bounding box
00751  * \param max_x Maximum coordinate of bounding box
00752  * \param max_y Maximum coordinate of bounding box
00753  * \param max_z Maximum coordinate of bounding box
00754  * \param *err Pointer to error type returned from function
00755  */
00756 void FBiGeom_getEntBoundBox( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double* min_x, double* min_y,
00757                              double* min_z, double* max_x, double* max_y, double* max_z, int* err );
00758 
00759 /**\brief  Get the bounding box of the specified entities
00760  *
00761  * Get the bounding box of the specified entities.  Storage order passed in
00762  * should be a member of iBase_StorageOrder enum.
00763  * \param instance FBiGeom instance handle
00764  * \param entity_handles Entity handles being queried
00765  * \param enttiy_handles_size Number of entities being queried
00766  * \param storage_order Storage order of coordinates passed back
00767  * \param min_corner Minimum coordinates of bounding boxes
00768  * \param min_corner_allocated Allocated size of minimum coordinates array
00769  * \param min_corner_size Occupied size of minimum coordinates array
00770  * \param max_corner Maximum coordinates of bounding boxes
00771  * \param max_corner_allocated Allocated size of maximum coordinates array
00772  * \param max_corner_size Occupied size of maximum coordinates array
00773  * \param *err Pointer to error type returned from function
00774  */
00775 void FBiGeom_getArrBoundBox( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00776                              int entity_handles_size, int storage_order, double** min_corner, int* min_corner_allocated,
00777                              int* min_corner_size, double** max_corner, int* max_corner_allocated, int* max_corner_size,
00778                              int* err );
00779 
00780 /**\brief  Get coordinates of specified vertex
00781  *
00782  * Get coordinates of specified vertex.
00783  * \param instance FBiGeom instance handle
00784  * \param vertex_handle Geom vertex being queried
00785  * \param *x Pointer to x coordinate returned from function
00786  * \param *y Pointer to y coordinate returned from function
00787  * \param *z Pointer to z coordinate returned from function
00788  * \param *err Pointer to error type returned from function
00789  */
00790 void FBiGeom_getVtxCoord( FBiGeom_Instance instance, iBase_EntityHandle vertex_handle, double* x, double* y, double* z,
00791                           int* err );
00792 
00793 /**\brief  Get coordinates of specified vertices
00794  *
00795  * Get coordinates of specified vertices.  If storage order is passed in
00796  * with a value other than iBase_UNDETERMINED, coordinates are returned
00797  * in the specified storage order, otherwise storage order is that native
00798  * to the implementation.  Storage order of returned coordinates is also
00799  * returned.
00800  * \param instance FBiGeom instance handle
00801  * \param vertex_handles Array of geom vertex handles whose coordinates are
00802  *        being requested
00803  * \param vertex_handles_size Number of vertices in vertex_handles array
00804  * \param storage_order Storage order requested for coordinate data
00805  * \param *coords Pointer to array of coordinates returned from function
00806  * \param *coords_allocated Pointer to allocated size of coords array
00807  * \param *coords_size Pointer to occupied size of coords array
00808  * \param *err Pointer to error type returned from function
00809  */
00810 void FBiGeom_getVtxArrCoords( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
00811                               int entity_handles_size, int storage_order, double** coordinates,
00812                               int* coordinates_allocated, int* coordinates_size, int* err );
00813 
00814 /**\brief  Intersect a ray with the model
00815  *
00816  * Intersect a ray with the model.  Storage orders passed in should be a
00817  * member of the iBase_StorageOrder enumeration.
00818  * \param instance FBiGeom instance handle
00819  * \param x Point from which ray is fired
00820  * \param y Point from which ray is fired
00821  * \param z Point from which ray is fired
00822  * \param dir_x Direction in which ray is fired
00823  * \param dir_y Direction in which ray is fired
00824  * \param dir_z Direction in which ray is fired
00825  * \param intersect_entity_handles Entities intersected by ray
00826  * \param intersect_entity_handles_allocated Allocated size of
00827  *        intersections array
00828  * \param intersect_entity_hangles_size Occupied size of intersections array
00829  * \param storage_order Storage order of coordinates passed back
00830  * \param intersect_coords Coordinates of intersections
00831  * \param intersect_coords_allocated Allocated size of coordinates array
00832  * \param intersect_coords_size Occupied size of coordinates array
00833  * \param param_coords Distances along ray of intersections
00834  * \param param_coords_allocated Allocated size of param_coords array
00835  * \param param_coords_size Occupied size of param_coords array
00836  * \param *err Pointer to error type returned from function
00837  */
00838 void FBiGeom_getPntRayIntsct( FBiGeom_Instance instance, double x, double y, double z, double dir_x, double dir_y,
00839                               double dir_z, iBase_EntityHandle** intersect_entity_handles,
00840                               int* intersect_entity_handles_allocated, int* intersect_entity_hangles_size,
00841                               int storage_order, double** intersect_coords, int* intersect_coords_allocated,
00842                               int* intersect_coords_size, double** param_coords, int* param_coords_allocated,
00843                               int* param_coords_size, int* err );
00844 
00845 /**\brief  Intersect an array of rays with the model
00846  *
00847  * Intersect an array of rays with the model.  Storage order passed in is
00848  * a member of the iBase_StorageOrder enumeration.
00849  * \param instance FBiGeom instance handle
00850  * \param storage_order Storage order of input coordinates
00851  * \param coords Points from which rays are fired
00852  * \param coords_size Number of points from which rays are fired
00853  * \param directions Directions in which rays are fired
00854  * \param directions_size Number of coordinates in directions array
00855  * \param intersect_entity_handles Entities intersected by ray
00856  * \param intersect_entity_handles_allocated Allocated size of intersections
00857  *        array
00858  * \param intersect_entity_hangles_size Occupied size of intersections array
00859  * \param offset Offset[i] is offset into intersect_entity_handles of ith
00860  *        ray
00861  * \param offset_allocated Allocated size of offset array
00862  * \param offset_size Occupied size of offset array
00863  * \param storage_order Storage order of coordinates passed back
00864  * \param intersect_coords Coordinates of intersections
00865  * \param intersect_coords_allocated Allocated size of coordinates array
00866  * \param intersect_coords_size Occupied size of coordinates array
00867  * \param param_coords Distances along ray of intersections
00868  * \param param_coords_allocated Allocated size of param_coords array
00869  * \param param_coords_size Occupied size of param_coords array
00870  * \param *err Pointer to error type returned from function
00871  */
00872 void FBiGeom_getPntArrRayIntsct( FBiGeom_Instance instance, int storage_order, const double* coords, int coords_size,
00873                                  const double* directions, int directions_size,
00874                                  iBase_EntityHandle** intersect_entity_handles, int* intersect_entity_handles_allocated,
00875                                  int* intersect_entity_hangles_size, int** offset, int* offset_allocated,
00876                                  int* offset_size, double** intersect_coords, int* intersect_coords_allocated,
00877                                  int* intersect_coords_size, double** param_coords, int* param_coords_allocated,
00878                                  int* param_coords_size, int* err );
00879 
00880 /**\brief  Get the entity on which a point is located
00881  *
00882  * Get the entity on which a point is located
00883  * \param instance FBiGeom instance handle
00884  * \param x Point being queried
00885  * \param y Point being queried
00886  * \param z Point being queried
00887  * \param entity_handle Entity on which point is located
00888  * \param *err Pointer to error type returned from function
00889  */
00890 void FBiGeom_getPntClsf( FBiGeom_Instance instance, double x, double y, double z, iBase_EntityHandle* entity_handle,
00891                          int* err );
00892 
00893 /**\brief  Get the entities on which points are located
00894  *
00895  * Get the entities on which points are located.  Storage orders should be
00896  * members of the iBase_StorageOrder enumeration.
00897  * \param instance FBiGeom instance handle
00898  * \param storage_order Storage order of coordinates in coords
00899  * \param coords Points being queried
00900  * \param coords_size Number of entries in coords array
00901  * \param entity_handles Entities on which points are located
00902  * \param entity_handles_allocated Allocated size of entity_handles array
00903  * \param entity_handles_size Occupied size of entity_handles array
00904  * \param *err Pointer to error type returned from function
00905  */
00906 void FBiGeom_getPntArrClsf( FBiGeom_Instance instance, int storage_order, double const* coords, int coords_size,
00907                             iBase_EntityHandle** entity_handles, int* entity_handles_allocated,
00908                             int* entity_handles_size, int* err );
00909 
00910 /**\brief  Get the sense of a face with respect to a region
00911  *
00912  * Get the sense of a face with respect to a region.  Sense returned is -1,
00913  * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
00914  * indicates that face bounds the region once with each sense.
00915  * \param instance FBiGeom instance handle
00916  * \param face Face being queried
00917  * \param region Region being queried
00918  * \param sense_out Sense of face with respect to region
00919  * \param *err Pointer to error type returned from function
00920  */
00921 void FBiGeom_getEntNrmlSense( FBiGeom_Instance instance, iBase_EntityHandle face, iBase_EntityHandle region,
00922                               int* sense_out, int* err );
00923 
00924 /**\brief  Get the senses of an array of faces with respect to an array of
00925  *         regions
00926  *
00927  * Get the senses of an array of faces with respect to an array of regions.
00928  * Sense returned is -1, 0, or 1, representing "reversed", "both", or
00929  * "forward".  "both" sense indicates that face bounds the region once with
00930  * each sense.
00931  * \param instance FBiGeom instance handle
00932  * \param face_handles Faces being queried
00933  * \param face_handles_size Size of face handles array
00934  * \param region_handles Regions being queried
00935  * \param region_handles_size Size of region handles array
00936  * \param sense Senses of faces with respect to regions
00937  * \param sense_allocated Allocated size of senses array
00938  * \param sense_size Occupied size of senses array
00939  * \param *err Pointer to error type returned from function
00940  */
00941 void FBiGeom_getArrNrmlSense( FBiGeom_Instance instance, iBase_EntityHandle const* face_handles, int face_handles_size,
00942                               iBase_EntityHandle const* region_handles, int region_handles_size, int** sense,
00943                               int* sense_allocated, int* sense_size, int* err );
00944 
00945 /**\brief  Get the sense of an edge with respect to a face
00946  *
00947  * Get the sense of an edge with respect to a face.  Sense returned is -1,
00948  * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
00949  * indicates that edge bounds the face once with each sense.
00950  * \param instance FBiGeom instance handle
00951  * \param edge Edge being queried
00952  * \param face Face being queried
00953  * \param sense_out Sense of edge with respect to face
00954  * \param *err Pointer to error type returned from function
00955  */
00956 void FBiGeom_getEgFcSense( FBiGeom_Instance, iBase_EntityHandle edge, iBase_EntityHandle face, int* sense_out,
00957                            int* err );
00958 
00959 /**\brief  Get the senses of an array of edges with respect to an array of
00960  *         faces
00961  *
00962  * Get the senses of an array of edges with respect to an array of faces.
00963  * Sense returned is -1, 0, or 1, representing "reversed", "both", or
00964  * "forward".  "both" sense indicates that edge bounds the face once with
00965  * each sense.
00966  * \param instance FBiGeom instance handle
00967  * \param edge_handles Edges being queried
00968  * \param edge_handles_size Size of edge handles array
00969  * \param face_handles Faces being queried
00970  * \param face_handles_size Size of face handles array
00971  * \param sense Senses of faces with respect to regions
00972  * \param sense_allocated Allocated size of senses array
00973  * \param sense_size Occupied size of senses array
00974  * \param *err Pointer to error type returned from function
00975  */
00976 void FBiGeom_getEgFcArrSense( FBiGeom_Instance instance, iBase_EntityHandle const* edge_handles, int edge_handles_size,
00977                               iBase_EntityHandle const* face_handles, int face_handles_size, int** sense,
00978                               int* sense_allocated, int* sense_size, int* err );
00979 
00980 /**\brief  Get the sense of a vertex pair with respect to an edge
00981  *
00982  * Get the sense of a vertex pair with respect to an edge.  Sense returned
00983  * is -1, 0, or 1, representing "reversed", "both", or "forward".  "both"
00984  * sense indicates that vertices are identical and that vertex bounds both
00985  * sides of the edge.
00986  * \param instance FBiGeom instance handle
00987  * \param edge Edge being queried
00988  * \param vertex1 First vertex being queried
00989  * \param vertex2 Second vertex being queried
00990  * \param sense_out Sense of vertex pair with respect to edge
00991  * \param *err Pointer to error type returned from function
00992  */
00993 void FBiGeom_getEgVtxSense( FBiGeom_Instance instance, iBase_EntityHandle edge, iBase_EntityHandle vertex1,
00994                             iBase_EntityHandle vertex2, int* sense_out, int* err );
00995 
00996 /**\brief  Get the senses of vertex pair with respect to a edges
00997  *
00998  * Get the senses of vertex pairs with respect to edges.  Sense returned is
00999  * -1, 0, or 1, representing "reversed", "both", or "forward".  "both" sense
01000  * indicates that both vertices in pair are identical and that vertex bounds
01001  * both sides of the edge.
01002  * \param instance FBiGeom instance handle
01003  * \param edge_handles Edges being queried
01004  * \param edge_handles_size Number of edges being queried
01005  * \param vertex_handles_1 First vertex being queried
01006  * \param vertex_handles_1_size Number of vertices in vertices array
01007  * \param vertex_handles_2 Second vertex being queried
01008  * \param vertex_handles_2_size Number of vertices in vertices array
01009  * \param sense Sense of vertex pair with respect to edge
01010  * \param sense_allocated Allocated size of sense array
01011  * \param sense_size Occupied size of sense array
01012  * \param *err Pointer to error type returned from function
01013  */
01014 void FBiGeom_getEgVtxArrSense( FBiGeom_Instance instance, iBase_EntityHandle const* edge_handles, int edge_handles_size,
01015                                iBase_EntityHandle const* vertex_handles_1, int veretx_handles_1_size,
01016                                iBase_EntityHandle const* vertex_handles_2, int vertex_handles_2_size, int** sense,
01017                                int* sense_allocated, int* sense_size, int* err );
01018 
01019 /**\brief  Return the measure (length, area, or volume) of entities
01020  *
01021  * Return the measure (length, area, or volume) of entities
01022  * \param instance FBiGeom instance handle
01023  * \param entity_handles Array of entities being queried
01024  * \param entity_handles_size Number of entities in entity array
01025  * \param measures Measures of entities being queried
01026  * \param measures_allocated Allocated size of measures array
01027  * \param measures_size Occupied size of measures array
01028  * \param *err Pointer to error type returned from function
01029  */
01030 void FBiGeom_measure( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
01031                       double** measures, int* measures_allocated, int* measures_size, int* err );
01032 
01033 /**\brief  Get the geometric type of a face
01034  *
01035  * Get the geometric type of a face.  Specific types depend on
01036  * implementation.
01037  * \param instance FBiGeom instance handle
01038  * \param face_handle Face being queried
01039  * \param face_type Face type
01040  * \param face_type_length Length of face type string
01041  */
01042 void FBiGeom_getFaceType( FBiGeom_Instance instance, iBase_EntityHandle face_handle, char* face_type, int* err,
01043                           int* face_type_length );
01044 
01045 /**\brief  Return whether interface has information about parameterization
01046  *
01047  * Return whether an interface has information about parameterization (!=0)
01048  * or not (0)
01049  * \param instance FBiGeom instance handle
01050  * \param is_parametric If non-zero, interface has information about
01051  *        parameterization
01052  * \param *err Pointer to error type returned from function
01053  */
01054 void FBiGeom_getParametric( FBiGeom_Instance instance, int* is_parametric, int* err );
01055 
01056 /**\brief  Return whether an entity has a parameterization
01057  *
01058  * Return whether an entity has a parameterization (=1) or not (=0)
01059  * \param instance FBiGeom instance handle
01060  * \param entity_handle Entity being queried
01061  * \param is_parametric Entity has a parameterization (=1) or not (=0)
01062  * \param *err Pointer to error type returned from function
01063  */
01064 void FBiGeom_isEntParametric( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* parametric, int* err );
01065 
01066 /**\brief  Return whether entities have parameterizations
01067  *
01068  * Return whether entities have parameterizations (=1) or not (=0)
01069  * \param instance FBiGeom instance handle
01070  * \param entity_handles Entities being queried
01071  * \param entity_handles_size Number of entities being queried
01072  * \param is_parametric entity_handles[i] has a parameterization (=1) or
01073  *        not (=0)
01074  * \param is_parametric_allocated Allocated size of is_parametric array
01075  * \param is_parametric_size Occupied size of is_parametric array
01076  * \param *err Pointer to error type returned from function
01077  */
01078 void FBiGeom_isArrParametric( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01079                               int entity_handles_size, int** is_parametric, int* is_parametric_allocated,
01080                               int* is_parametric_size, int* err );
01081 
01082 /**\brief  Return coordinate position at specified parametric position on
01083  *         entity
01084  *
01085  * Return coordinate position at specified parametric position on entity.
01086  * \param instance FBiGeom instance handle
01087  * \param entity_handle Entity being queried
01088  * \param u Parametric coordinate being queried
01089  * \param v Parametric coordinate being queried
01090  * \param x Spatial coordinate at parametric position being queried
01091  * \param y Spatial coordinate at parametric position being queried
01092  * \param z Spatial coordinate at parametric position being queried
01093  * \param *err Pointer to error type returned from function
01094  */
01095 void FBiGeom_getEntUVtoXYZ( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double v, double* x,
01096                             double* y, double* z, int* err );
01097 
01098 /**\brief  Return coordinate positions at specified parametric position(s)
01099  *         on entity(ies)
01100  *
01101  * Return coordinate positions at specified parametric position(s) on
01102  * entity(ies).  If either the number of entities or number of parametric
01103  * coordinate pairs is unity, then all points or entities are queried for
01104  * that entity or point, respectively, otherwise each point corresponds to
01105  * each entity.  storage_order should be a value in the iBase_StorageOrder
01106  * enum.
01107  * \param instance FBiGeom instance handle
01108  * \param entity_handles Entities being queried
01109  * \param entity_handles_size Number of entities being queried
01110  * \param storage_order Storage order of uv coordinates input and xyz
01111  *        coordinate output
01112  * \param uv Coordinates being queried
01113  * \param uv_size Number of coordinates in array
01114  * \param coordinates Coordinates of parametric positions
01115  * \param coordinates_allocated Allocated size of coordinates array
01116  * \param coordinates_size Occupied size of coordinates array
01117  * \param *err Pointer to error type returned from function
01118  */
01119 void FBiGeom_getArrUVtoXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01120                             int entity_handles_size, int storage_order, double const* uv, int uv_size,
01121                             double** coordinates, int* coordinates_allocated, int* coordinates_size, int* err );
01122 
01123 /**\brief  Return coordinate position at specified parametric position on
01124  *         entity
01125  *
01126  * Return coordinate position at specified parametric position on entity.
01127  * \param instance FBiGeom instance handle
01128  * \param entity_handle Entity being queried
01129  * \param u Parametric coordinate being queried
01130  * \param x Spatial coordinate at parametric position being queried
01131  * \param y Spatial coordinate at parametric position being queried
01132  * \param z Spatial coordinate at parametric position being queried
01133  * \param *err Pointer to error type returned from function
01134  */
01135 void FBiGeom_getEntUtoXYZ( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double* x, double* y,
01136                            double* z, int* err );
01137 
01138 /**\brief  Return coordinate positions at specified parametric position(s)
01139  *         on entity(ies)
01140  *
01141  * Return coordinate positions at specified parametric position(s) on
01142  * entity(ies). If either the number of entities or number of parametric
01143  * coordinate pairs is unity, then all points or entities are queried for
01144  * that entity or point, respectively, otherwise each point corresponds to
01145  * each entity.  storage_order should be a value in the iBase_StorageOrder
01146  * enum.
01147  * \param instance FBiGeom instance handle
01148  * \param entity_handles Entities being queried
01149  * \param entity_handles_size Number of entities being queried
01150  * \param storage_order Storage order of resulting coordinates
01151  * \param uv Coordinates being queried
01152  * \param uv_size Number of coordinates in array
01153  * \param coordinates Coordinates of parametric positions
01154  * \param coordinates_allocated Allocated size of coordinates array
01155  * \param coordinates_size Occupied size of coordinates array
01156  * \param *err Pointer to error type returned from function
01157  */
01158 void FBiGeom_getArrUtoXYZ( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
01159                            double const* u, int u_size, int storage_order, double** on_coords, int* on_coords_allocated,
01160                            int* on_coords_size, int* err );
01161 
01162 /**\brief  Return parametric position at specified spatial position on
01163  *         entity
01164  *
01165  * Return parametric position at specified spatial position on entity
01166  * \param instance FBiGeom instance handle
01167  * \param entity_handle Entity being queried
01168  * \param x Spatial coordinate being queried
01169  * \param y Spatial coordinate being queried
01170  * \param z Spatial coordinate being queried
01171  * \param u Parametric coordinate at spatial position being queried
01172  * \param v Parametric coordinate at spatial position being queried
01173  * \param *err Pointer to error type returned from function
01174  */
01175 void FBiGeom_getEntXYZtoUV( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y, double z,
01176                             double* u, double* v, int* err );
01177 
01178 /**\brief  Return parametric position at specified spatial position on
01179  *         entity
01180  *
01181  * Return parametric position at specified spatial position on entity
01182  * \param instance FBiGeom instance handle
01183  * \param entity_handle Entity being queried
01184  * \param x Spatial coordinate being queried
01185  * \param y Spatial coordinate being queried
01186  * \param z Spatial coordinate being queried
01187  * \param u Parametric coordinate at spatial position being queried
01188  * \param *err Pointer to error type returned from function
01189  */
01190 void FBiGeom_getEntXYZtoU( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y, double z,
01191                            double* u, int* err );
01192 
01193 /**\brief  Return parametric positions at specified spatial position(s) on
01194  *         entity(ies)
01195  * Return parametric positions at specified spatial position(s) on
01196  * entity(ies).  If either the number of entities or number of spatial
01197  * coordinate triples is unity, then all points or entities are queried for
01198  * that entity or point, respectively, otherwise each point corresponds to
01199  * each entity.  storage_order should be a value in the iBase_StorageOrder
01200  * enum.
01201  * \param instance FBiGeom instance handle
01202  * \param entity_handles Entities being queried
01203  * \param entity_handles_size Number of entities being queried
01204  * \param storage_order Storage order of spatial coordinates input
01205  * \param coordinates Coordinates being queried
01206  * \param coordinates_size Number of coordinates in array
01207  * \param uv Coordinates of parametric positions
01208  * \param uv_allocated Allocated size of coordinates array
01209  * \param uv_size Occupied size of coordinates array
01210  * \param *err Pointer to error type returned from function
01211  */
01212 void FBiGeom_getArrXYZtoUV( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01213                             int entity_handles_size, int storage_order, double const* coordinates, int coordinates_size,
01214                             double** uv, int* uv_allocated, int* uv_size, int* err );
01215 
01216 /**\brief  Return spatial positions at specified parametric position(s) on
01217  *         entity(ies)
01218  *
01219  * Return spatial positions at specified parametric position(s) on
01220  * entity(ies). If either the number of entities or number of spatial
01221  * coordinate triples is unity, then all points or entities are queried for
01222  * that entity or point, respectively, otherwise each point corresponds to
01223  * each entity.  storage_order should be a value in the iBase_StorageOrder
01224  * enum.
01225  * \param instance FBiGeom instance handle
01226  * \param entity_handles Entities being queried
01227  * \param entity_handles_size Number of entities being queried
01228  * \param storage_order Storage order of spatial coordinates input
01229  * \param coordinates Coordinates being queried
01230  * \param coordinates_size Number of coordinates in array
01231  * \param u Coordinates of parametric positions
01232  * \param u_allocated Allocated size of coordinates array
01233  * \param u_size Occupied size of coordinates array
01234  * \param *err Pointer to error type returned from function
01235  */
01236 void FBiGeom_getArrXYZtoU( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
01237                            int storage_order, double const* coordinates, int coordinates_size, double** u,
01238                            int* u_allocated, int* u_size, int* err );
01239 
01240 /**\brief  Return parametric position at specified spatial position on
01241  *         entity, based on parametric position hint
01242  *
01243  * Return parametric position at specified spatial position on entity,
01244  * based on parametric position hint.  For this function, u and v are input
01245  * with parameters from which to start search. Typically this will reduce
01246  * the search time for new parametric coordinates.
01247  * \param instance FBiGeom instance handle
01248  * \param entity_handle Entity being queried
01249  * \param x Spatial coordinate being queried
01250  * \param y Spatial coordinate being queried
01251  * \param z Spatial coordinate being queried
01252  * \param u Parametric coordinate at spatial position being queried
01253  * \param v Parametric coordinate at spatial position being queried
01254  * \param *err Pointer to error type returned from function
01255  */
01256 void FBiGeom_getEntXYZtoUVHint( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double x, double y,
01257                                 double z, double* u, double* v, int* err );
01258 
01259 /**\brief  Return parametric positions at specified spatial position(s) on
01260  *         entity(ies), based on parametric position hints
01261  * Return parametric positions at specified spatial position(s) on
01262  * entity(ies), based on parametric position hints.  If either the number of
01263  * entities or number of spatial coordinate triples is unity, then all
01264  * points or entities are queried for that entity or point, respectively,
01265  * otherwise each point corresponds to each entity.  storage_order should be
01266  * a value in the iBase_StorageOrder enum.
01267  * \param instance FBiGeom instance handle
01268  * \param entity_handles Entities being queried
01269  * \param entity_handles_size Number of entities being queried
01270  * \param storage_order Storage order of spatial coordinates input
01271  * \param coordinates Coordinates being queried
01272  * \param coordinates_size Number of coordinates in array
01273  * \param uv Coordinates of parametric positions
01274  * \param uv_allocated Allocated size of coordinates array
01275  * \param uv_size Occupied size of coordinates array
01276  * \param *err Pointer to error type returned from function
01277  */
01278 void FBiGeom_getArrXYZtoUVHint( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01279                                 int entity_handles_size, int storage_order, double const* coords, int coords_size,
01280                                 double** uv, int* uv_allocated, int* uv_size, int* err );
01281 
01282 /**\brief  Get parametric range of entity
01283  *
01284  * Get parametric range of entity
01285  * \param instance FBiGeom instance handle
01286  * \param entity_handle Entity being queried
01287  * \param u_min Minimum parametric coordinate for entity
01288  * \param v_min Minimum parametric coordinate for entity
01289  * \param u_max Maximum parametric coordinate for entity
01290  * \param v_max Maximum parametric coordinate for entity
01291  * \param *err Pointer to error type returned from function
01292  */
01293 void FBiGeom_getEntUVRange( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double* u_min, double* v_min,
01294                             double* u_max, double* v_max, int* err );
01295 
01296 /**\brief  Get parametric range of entity
01297  *
01298  * Get parametric range of entity
01299  * \param instance FBiGeom instance handle
01300  * \param entity_handle Entity being queried
01301  * \param u_min Minimum parametric coordinate for entity
01302  * \param u_max Maximum parametric coordinate for entity
01303  * \param *err Pointer to error type returned from function
01304  */
01305 void FBiGeom_getEntURange( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double* u_min, double* u_max,
01306                            int* err );
01307 
01308 /**\brief  Get parametric range of entities
01309  *
01310  * Get parametric range of entities
01311  * \param instance FBiGeom instance handle
01312  * \param entity_handles Entities being queried
01313  * \param entity_handles_size Number of entities being queried
01314  * \param storage_order Storage order of parametric coordinates being
01315  *        returned
01316  * \param uv_min Minimum parametric coordinate for entities
01317  * \param uv_min_allocated Allocated size of minimum parametric coordinate
01318  *        array
01319  * \param uv_min_size Occupied size of minimum parametric coordinate array
01320  * \param uv_max Maximum parametric coordinate for entities
01321  * \param uv_max_allocated Allocated size of maximum parametric coordinate
01322  *        array
01323  * \param uv_max_size Occupied size of maximum parametric coordinate array
01324  * \param *err Pointer to error type returned from function
01325  */
01326 void FBiGeom_getArrUVRange( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01327                             int entity_handles_size, int storage_order, double** uv_min, int* uv_min_allocated,
01328                             int* uv_min_size, double** uv_max, int* uv_max_allocated, int* uv_max_size, int* err );
01329 
01330 /**\brief  Get parametric range of entities
01331  *
01332  * Get parametric range of entities
01333  * \param instance FBiGeom instance handle
01334  * \param entity_handles Entities being queried
01335  * \param entity_handles_size Number of entities being queried
01336  * \param storage_order Storage order of parametric coordinates being
01337  *        returned
01338  * \param u_min Minimum parametric coordinate for entities
01339  * \param u_min_allocated Allocated size of minimum parametric coordinate
01340  *        array
01341  * \param u_min_size Occupied size of minimum parametric coordinate array
01342  * \param u_max Maximum parametric coordinate for entities
01343  * \param u_max_allocated Allocated size of maximum parametric coordinate
01344  *        array
01345  * \param u_max_size Occupied size of maximum parametric coordinate array
01346  * \param *err Pointer to error type returned from function
01347  */
01348 void FBiGeom_getArrURange( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles, int entity_handles_size,
01349                            double** u_min, int* u_min_allocated, int* u_min_size, double** u_max, int* u_max_allocated,
01350                            int* u_max_size, int* err );
01351 
01352 /**\brief  Return the face parametric coordinates for a parametric position
01353  *         on a bounding edge
01354  *
01355  * Return the face parametric coordinates for a parametric position on a
01356  * bounding edge
01357  * \param instance FBiGeom instance handle
01358  * \param edge_handle Edge being queried
01359  * \param face_handle Face being queried
01360  * \param in_u Parametric position on edge
01361  * \param u Corresponding parametric position on face
01362  * \param v Corresponding parametric position on face
01363  * \param *err Pointer to error type returned from function
01364  */
01365 void FBiGeom_getEntUtoUV( FBiGeom_Instance instance, iBase_EntityHandle edge_handle, iBase_EntityHandle face_handle,
01366                           double in_u, double* u, double* v, int* err );
01367 
01368 /**\brief  Return parametric coordinates on face of vertex position
01369  *
01370  * Return parametric coordinates on face of vertex position
01371  * \param instance FBiGeom instance handle
01372  * \param vertex_handle Vertex being queried
01373  * \param face_handle Face being queried
01374  * \param u Corresponding parametric position on face
01375  * \param v Corresponding parametric position on face
01376  * \param *err Pointer to error type returned from function
01377  */
01378 void FBiGeom_getVtxToUV( FBiGeom_Instance instance, iBase_EntityHandle vertex_handle, iBase_EntityHandle face_handle,
01379                          double* u, double* v, int* err );
01380 
01381 /**\brief  Return parametric coordinates on edge of vertex position
01382  *
01383  * Return parametric coordinates on edge of vertex position
01384  * \param instance FBiGeom instance handle
01385  * \param vertex_handle Vertex being queried
01386  * \param edge_handle Edge being queried
01387  * \param u Corresponding parametric position on face
01388  * \param *err Pointer to error type returned from function
01389  */
01390 void FBiGeom_getVtxToU( FBiGeom_Instance instance, iBase_EntityHandle vertex_handle, iBase_EntityHandle edge_handle,
01391                         double* u, int* err );
01392 
01393 /**\brief  Return the face parametric coordinates for a parametric position
01394  *         on bounding edges
01395  *
01396  * Return the face parametric coordinates for a parametric position on
01397  * bounding edges
01398  * \param instance FBiGeom instance handle
01399  * \param edge_handles Edges being queried
01400  * \param edge_handles_size Number of edges being queried
01401  * \param face_handles Faces being queried
01402  * \param face_handles_size Number of faces being queried
01403  * \param u_in Parametric positions on edges
01404  * \param u_in_size Number of parametric positions on edges
01405  * \param storage_order Storage order of coordinates returned
01406  * \param uv Corresponding parametric positions on faces
01407  * \param uv_allocated Allocated size of parameter array
01408  * \param uv_size Occupied size of parameter array
01409  * \param *err Pointer to error type returned from function
01410  */
01411 void FBiGeom_getArrUtoUV( FBiGeom_Instance instance, iBase_EntityHandle const* edge_handles, int edge_handles_size,
01412                           iBase_EntityHandle const* face_handles, int face_handles_size, double const* u_in,
01413                           int u_in_size, int storage_order, double** uv, int* uv_allocated, int* uv_size, int* err );
01414 
01415 /**\brief  Return parametric coordinates on faces of vertex positions
01416  *
01417  * Return parametric coordinates on faces of vertex positions
01418  * \param instance FBiGeom instance handle
01419  * \param vertex_handles Vertices being queried
01420  * \param vertex_handles_size Number of vertices being queried
01421  * \param face_handles Faces being queried
01422  * \param face_handles_size Number of faces being queried
01423  * \param storage_order Storage order of coordinates returned
01424  * \param uv Corresponding parametric positions on faces
01425  * \param uv_allocated Allocated size of positions array
01426  * \param uv_size Occupied size of positions array
01427  * \param *err Pointer to error type returned from function
01428  */
01429 void FBiGeom_getVtxArrToUV( FBiGeom_Instance instance, iBase_EntityHandle const* vertex_handles,
01430                             int vertex_handles_size, iBase_EntityHandle const* face_handles, int face_handles_size,
01431                             int storage_order, double** uv, int* uv_allocated, int* uv_size, int* err );
01432 
01433 /**\brief  Return parametric coordinates on edges of vertex positions
01434  *
01435  * Return parametric coordinates on edges of vertex positions
01436  * \param instance FBiGeom instance handle
01437  * \param vertex_handles Vertices being queried
01438  * \param vertex_handles_size Number of vertices being queried
01439  * \param edge_handles Edges being queried
01440  * \param edge_handles_size Number of edges being queried
01441  * \param u Corresponding parametric positions on faces
01442  * \param u_allocated Allocated size of positions array
01443  * \param u_size Occupied size of positions array
01444  * \param *err Pointer to error type returned from function
01445  */
01446 void FBiGeom_getVtxArrToU( FBiGeom_Instance instance, iBase_EntityHandle const* vertex_handles, int vertex_handles_size,
01447                            iBase_EntityHandle const* edge_handles, int edge_handles_size, double** u, int* u_allocated,
01448                            int* u_size, int* err );
01449 
01450 /**\brief  Return the normal at a specified parametric position
01451  *
01452  * Return the normal at a specified parametric position
01453  * \param instance FBiGeom instance handle
01454  * \param entity_handle Entity being queried
01455  * \param u Parametric position being queried
01456  * \param v Parametric position being queried
01457  * \param nrml_i Normal at specified position
01458  * \param nrml_j Normal at specified position
01459  * \param nrml_k Normal at specified position
01460  * \param *err Pointer to error type returned from functino
01461  */
01462 void FBiGeom_getEntNrmlUV( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double v,
01463                            double* nrml_i, double* nrml_j, double* nrml_k, int* err );
01464 
01465 /**\brief  Return the normals at specified parametric positions
01466  *
01467  * Return the normals at specified parametric positions.  If either the
01468  * number of entities or number of spatial coordinate pairs is unity, then
01469  * all points or entities are queried for that entity or point,
01470  * respectively, otherwise each point corresponds to each entity.
01471  * storage_order should be a value in the iBase_StorageOrder enum.
01472  * \param instance FBiGeom instance handle
01473  * \param face_handle Faces being queried
01474  * \param face_handles_size Number of faces being queried
01475  * \param storage_order Storage order of coordinates input and output
01476  * \param parameters Parametric coordinates being queried
01477  * \param parameters_size Number of coordinates in array
01478  * \param normals Coordinates of normals at specified positions
01479  * \param normals_allocated Allocated size of normals array
01480  * \param normals_size Occupied size of normals array
01481  * \param *err Pointer to error type returned from function
01482  */
01483 void FBiGeom_getArrNrmlUV( FBiGeom_Instance instance, iBase_EntityHandle const* face_handles, int face_handles_size,
01484                            int storage_order, double const* parameters, int parameters_size, double** normals,
01485                            int* normals_allocated, int* normals_size, int* err );
01486 
01487 /**\brief  Return the tangent at a specified parametric position
01488  *
01489  * Return the tangent at a specified parametric position
01490  * \param instance FBiGeom instance handle
01491  * \param entity_handle Entity being queried
01492  * \param u Parametric position being queried
01493  * \param tgnt_i Tangent at specified position
01494  * \param tgnt_j Tangent at specified position
01495  * \param tgnt_k Tangent at specified position
01496  * \param *err Pointer to error type returned from function
01497  */
01498 void FBiGeom_getEntTgntU( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double* tgnt_i,
01499                           double* tgnt_j, double* tgnt_k, int* err );
01500 
01501 /**\brief  Return the tangents at specified parametric positions
01502  *
01503  * Return the tangents at specified parametric positions.  If either the
01504  * number of entities or number of spatial coordinates is unity, then all
01505  * points or entities are queried for that entity or point, respectively,
01506  * otherwise each point corresponds to each entity.  storage_order should be
01507  * a value in the iBase_StorageOrder enum.
01508  * \param instance FBiGeom instance handle
01509  * \param edge_handle Edges being queried
01510  * \param edge_handles_size Number of faces being queried
01511  * \param storage_order Storage order of coordinates output
01512  * \param parameters Parametric coordinates being queried
01513  * \param parameters_size Number of coordinates in array
01514  * \param tangents Coordinates of tangents at specified positions
01515  * \param tangents_allocated Allocated size of tangents array
01516  * \param tangents_size Occupied size of tangents array
01517  * \param *err Pointer to error type returned from function
01518  */
01519 void FBiGeom_getArrTgntU( FBiGeom_Instance instance, iBase_EntityHandle const* edge_handles, int edge_handles_size,
01520                           int storage_order, double const* parameters, int parameters_size, double** tangents,
01521                           int* tangents_allocated, int* tangents_size, int* err );
01522 
01523 /**\brief  Get the first derivative of a face at specified parametric
01524  *         position
01525  *
01526  * Get the first derivative of a face at specified parametric position.
01527  * \param instance FBiGeom instance handle
01528  * \param entity_handle Entity being queried
01529  * \param u Parametric position being queried
01530  * \param v Parametric position being queried
01531  * \param dvrt_u Pointer to coordinates of derivative with respect to u at
01532  *        specified position returned from function
01533  * \param dvrt_u_allocated Allocated size of dvrt_u array
01534  * \param dvrt_u_size Occupied size of dvrt_u array
01535  * \param dvrt_v Pointer to coordinates of derivative with respect to v at
01536  *        specified position returned from function
01537  * \param dvrt_v_allocated Allocated size of dvrt_v array
01538  * \param dvrt_v_size Occupied size of dvrt_v array
01539  * \param *err Pointer to error type returned from function
01540  */
01541 void FBiGeom_getEnt1stDrvt( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double v,
01542                             double** drvt_u, int* drvt_u_allocated, int* drvt_u_size, double** drvt_v,
01543                             int* dvrt_v_allocated, int* dvrt_v_size, int* err );
01544 
01545 /**\brief  Get the first derivatives of faces at specified parametric
01546  *         positions
01547  *
01548  * Get the first derivatives of faces at specified parametric positions.
01549  * storage_order should be a value in the iBase_StorageOrder enum.
01550  * \param instance FBiGeom instance handle
01551  * \param entity_handles Array of entity handles being queried
01552  * \param entity_handles_size Number of entities in entity_handles array
01553  * \param storage_order Storage order of coordinates input and output
01554  * \param uv Parametric coordinates being queried
01555  * \param uv_size Number of coordinates in array
01556  * \param dvrt_u Pointer to array of coordinates of derivative with respect
01557  *        to u at specified position returned from function
01558  * \param dvrt_u_allocated Allocated size of dvrt_u array
01559  * \param dvrt_u_size Occupied size of dvrt_u array
01560  * \param u_offset Pointer to array of offsets for dvrt_u returned from
01561  *        function
01562  * \param u_offset_allocated Pointer to allocated size of u_offset array
01563  * \param u_offset_size Pointer to occupied size of u_offset array
01564  * \param dvrt_v Pointer to array of coordinates of derivative with respect
01565  *        to v at specified position returned from function
01566  * \param dvrt_v_allocated Allocated size of dvrt_v array
01567  * \param dvrt_v_size Occupied size of dvrt_v array
01568  * \param v_offset Pointer to array of offsets for dvrt_v returned from
01569  *        function
01570  * \param v_offset_allocated Pointer to allocated size of v_offset array
01571  * \param v_offset_size Pointer to occupied size of v_offset array
01572  * \param *err Pointer to error type returned from function
01573  */
01574 void FBiGeom_getArr1stDrvt( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01575                             int entity_handles_size, int storage_order, double const* uv, int uv_size, double** dvrt_u,
01576                             int* dvrt_u_allocated, int* dvrt_u_size, int** u_offset, int* u_offset_allocated,
01577                             int* u_offset_size, double** dvrt_v, int* dvrt_v_allocated, int* dvrt_v_size,
01578                             int** v_offset, int* v_offset_allocated, int* v_offset_size, int* err );
01579 
01580 /**\brief  Get the second derivative of a face at specified parametric
01581  *         position
01582  *
01583  * Get the second derivative of a face at specified parametric position.
01584  * \param instance FBiGeom instance handle
01585  * \param entity_handle Entity being queried
01586  * \param u Parametric position being queried
01587  * \param v Parametric position being queried
01588  * \param dvrt_uu Pointer to coordinates of derivative with respect to u at
01589  *        specified position returned from function
01590  * \param dvrt_uu_allocated Allocated size of dvrt_uu array
01591  * \param dvrt_uu_size Occupied size of dvrt_uu array
01592  * \param dvrt_vv Pointer to coordinates of derivative with respect to v at
01593  *        specified position returned from function
01594  * \param dvrt_vv_allocated Allocated size of dvrt_vv array
01595  * \param dvrt_vv_size Occupied size of dvrt_vv array
01596  * \param dvrt_uv Pointer to coordinates of derivative with respect to u and
01597  *        v at specified position returned from function
01598  * \param dvrt_uv_allocated Allocated size of dvrt_uv array
01599  * \param dvrt_uv_size Occupied size of dvrt_uv array
01600  * \param *err Pointer to error type returned from function
01601  */
01602 void FBiGeom_getEnt2ndDrvt( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double u, double v,
01603                             double** drvt_uu, int* drvt_uu_allocated, int* drvt_uu_size, double** drvt_vv,
01604                             int* dvrt_vv_allocated, int* dvrt_vv_size, double** drvt_uv, int* dvrt_uv_allocated,
01605                             int* dvrt_uv_size, int* err );
01606 
01607 /**\brief  Get the second derivatives of faces at specified parametric
01608  *         positions
01609  *
01610  * Get the second derivatives of faces at specified parametric positions.
01611  * storage_order should be a value in the iBase_StorageOrder enum.
01612  * \param instance FBiGeom instance handle
01613  * \param entity_handles Array of entity handles being queried
01614  * \param entity_handles_size Number of entities in entity_handles array
01615  * \param storage_order Storage order of coordinates input and output
01616  * \param uv Parametric coordinates being queried
01617  * \param uv_size Number of coordinates in array
01618  * \param dvrt_uu Pointer to array of coordinates of derivative with respect
01619  *        to u at specified position returned from function
01620  * \param dvrt_uu_allocated Allocated size of dvrt_uu array
01621  * \param dvrt_uu_size Occupied size of dvrt_uu array
01622  * \param uu_offset Pointer to array of offsets for dvrt_uu returned from
01623  *        function
01624  * \param uu_offset_allocated Pointer to allocated size of uu_offset array
01625  * \param uu_offset_size Pointer to occupied size of uu_offset array
01626  * \param dvrt_vv Pointer to array of coordinates of derivative with respect
01627  *        to v at specified position returned from function
01628  * \param dvrt_vv_allocated Allocated size of dvrt_vv array
01629  * \param dvrt_vv_size Occupied size of dvrt_vv array
01630  * \param vv_offset Pointer to array of offsets for dvrt_vv returned from
01631  *        function
01632  * \param vv_offset_allocated Pointer to allocated size of vv_offset array
01633  * \param vv_offset_size Pointer to occupied size of vv_offset array
01634  * \param dvrt_uv Pointer to array of coordinates of derivative with respect
01635  *        to u and v at specified position returned from function
01636  * \param dvrt_uv_allocated Allocated size of dvrt_uv array
01637  * \param dvrt_uv_size Occupied size of dvrt_uv array
01638  * \param uv_offset Pointer to array of offsets for dvrt_uv returned from
01639  *        function
01640  * \param uv_offset_allocated Pointer to allocated size of uv_offset array
01641  * \param uv_offset_size Pointer to occupied size of uv_offset array
01642  * \param *err Pointer to error type returned from function
01643  */
01644 void FBiGeom_getArr2ndDrvt( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01645                             int entity_handles_size, int storage_order, double const* uv, int uv_size, double** dvtr_uu,
01646                             int* dvrt_uu_allocated, int* dvrt_uu_size, int** uu_offset, int* uu_offset_allocated,
01647                             int* uu_offset_size, double** dvtr_vv, int* dvrt_vv_allocated, int* dvrt_vv_size,
01648                             int** vv_offset, int* vv_offset_allocated, int* vv_offset_size, double** dvrt_uv,
01649                             int* dvrt_uv_allocated, int* dvrt_uv_size, int** uv_offset, int* uv_offset_allocated,
01650                             int* uv_offset_size, int* err );
01651 
01652 /**\brief  Get the two principle curvature vectors for a face at a
01653  *         parametric position
01654  *
01655  * Get the two principle curvature vectors for a face at a parametric
01656  * position.  Magnitudes of vectors are curvature, directions are
01657  * directions of principal curvatures.
01658  * \param instance FBiGeom instance handle
01659  * \param face_handle Face being queried
01660  * \param u Parametric position being queried
01661  * \param v Parametric position being queried
01662  * \param cvtr1_i Maximum curvature vector
01663  * \param cvtr1_j Maximum curvature vector
01664  * \param cvtr1_k Maximum curvature vector
01665  * \param cvtr2_i Minimum curvature vector
01666  * \param cvtr2_j Minimum curvature vector
01667  * \param cvtr2_k Minimum curvature vector
01668  * \param *err Pointer to error type returned from function
01669  */
01670 void FBiGeom_getFcCvtrUV( FBiGeom_Instance instance, iBase_EntityHandle face_handle, double u, double v,
01671                           double* cvtr1_i, double* cvtr1_j, double* cvtr1_k, double* cvtr2_i, double* cvtr2_j,
01672                           double* cvtr2_k, int* err );
01673 
01674 /**\brief  Get the curvature(s) on face(s) at given parametric position(s)
01675  *
01676  * Get the curvature(s) on face(s) at given parametric position(s).  If
01677  * either the number of faces or number of coordinate pairs is unity, then
01678  * all points or entities are queried for that entity or point,
01679  * respectively, otherwise each point corresponds to each entity.
01680  * storage_order should be a value in the iBase_StorageOrder enum.
01681  * \param instance FBiGeom instance handle
01682  * \param face_handles Face(s) being queried
01683  * \param face_handles_size Number of entities being queried
01684  * \param storage_order Storage order of uv coordinates
01685  * \param uv Starting parametric coordinates
01686  * \param uv_size Number of values in uv array
01687  * \param cvtr_1 First principal curvatures
01688  * \param cvtr_1_allocated Allocated size of first curvature array
01689  * \param cvtr_1_size Occupied size of first curvature array
01690  * \param cvtr_2 Second principal curvatures
01691  * \param cvtr_2_allocated Allocated size of second curvature array
01692  * \param cvtr_2_size Occupied size of second curvature array
01693  * \param *err Pointer to error type returned from function
01694  */
01695 void FBiGeom_getFcArrCvtrUV( FBiGeom_Instance instance, iBase_EntityHandle const* face_handles, int face_handles_size,
01696                              int storage_order, double const* uv, int uv_size, double** cvtr_1, int* cvtr_1_allocated,
01697                              int* cvtr_1_size, double** cvtr_2, int* cvtr_2_allocated, int* cvtr_2_size, int* err );
01698 
01699 /**\brief  Return whether an entity is periodic
01700  *
01701  * Return whether an entity is periodic (=1) or not (=0) in the u and v
01702  * directions.
01703  * \param instance FBiGeom instance handle
01704  * \param entity_handle Entity being queried
01705  * \param in_u Entity is periodic in u direction (=1) or not (=0)
01706  * \param in_v Entity is periodic in v direction (=1) or not (=0)
01707  * \param *err Pointer to error type returned from function
01708  */
01709 void FBiGeom_isEntPeriodic( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* in_u, int* in_v,
01710                             int* err );
01711 
01712 /**\brief  Return whether entities are periodic
01713  *
01714  * Return whether entities are periodic (=1) or not (=0) in the u and v
01715  * directions.
01716  * \param instance FBiGeom instance handle
01717  * \param entity_handles Entities being queried
01718  * \param entity_handles_size Number of entities being queried
01719  * \param in_uv Array of pairs of integers representing whether
01720  *        entity_handles[i] is periodic (=1) or not (=0) in u and v
01721  *        directions
01722  * \param in_uv_allocated Allocated size of in_uv array
01723  * \param in_uv_size Occupied size of in_uv array
01724  * \param *err Pointer to error type returned from function
01725  */
01726 void FBiGeom_isArrPeriodic( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01727                             int entity_handles_size, int** in_uv, int* in_uv_allocated, int* in_uv_size, int* err );
01728 
01729 /**\brief  Return whether a face is degenerate
01730  *
01731  * Return whether a face is degenerate (=1) or not (=0).
01732  * \param instance FBiGeom instance handle
01733  * \param face_handle Face being queried
01734  * \param is_degenerate Face is degenerate (=1) or not (=0)
01735  * \param *err Pointer to error type returned from function
01736  */
01737 void FBiGeom_isFcDegenerate( FBiGeom_Instance instance, iBase_EntityHandle face_handle, int* is_degenerate, int* err );
01738 
01739 /**\brief  Return whether faces are degenerate
01740  *
01741  * Return whether faces are degenerate (=1) or not (=0).
01742  * \param instance FBiGeom instance handle
01743  * \param face_handles Faces being queried
01744  * \param face_handles_size Number of faces being queried
01745  * \param degenerate face_handles[i] is degenerate (=1) or not (=0)
01746  * \param degenerate_allocated Allocated size of degenerate array
01747  * \param degenerate_size Occupied size of degenerate array
01748  * \param *err Pointer to error type returned from function
01749  */
01750 void FBiGeom_isFcArrDegenerate( FBiGeom_Instance instance, iBase_EntityHandle const* face_handles,
01751                                 int face_handles_size, int** degenerate, int* degenerate_allocated,
01752                                 int* degenerate_size, int* err );
01753 
01754 /**\brief  Get the tolerance of the instance
01755  *
01756  * Get the tolerance at the modeler level.  type is an integer representing
01757  * the type of the tolerance, where 0 = no tolerance information,
01758  * 1 = modeler-level tolerance, 2 = entity-level tolerances.  If type is 1,
01759  * tolerance returns the modeler-level tolerance.  If type is 2, use
01760  * FBiGeom_getEntTolerance to query the tolerance on a per-entity basis.
01761  * \param instance FBiGeom instance handle
01762  * \param type Type of tolerance used by the modeler
01763  * \param tolerance Modeler-level tolerance, if any
01764  * \param *err Pointer to error type returned from function
01765  */
01766 void FBiGeom_getTolerance( FBiGeom_Instance instance, int* type, double* tolerance, int* err );
01767 
01768 /**\brief  Get the tolerance of the specified entity
01769  *
01770  * Get the tolerance of the specified entity.
01771  * \param instance FBiGeom instance handle
01772  * \param entity_handle Entity handle being queried
01773  * \param tolerance Pointer to tolerance returned from function
01774  * \param *err Pointer to error type returned from function
01775  */
01776 void FBiGeom_getEntTolerance( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, double* tolerance,
01777                               int* err );
01778 
01779 /**\brief  Get the tolerances of the specified entities
01780  *
01781  * Get the tolerances of the specified entities.
01782  * \param instance FBiGeom instance handle
01783  * \param entity_handles Array of entity handles being queried
01784  * \param entity_handles_size Number of entities in entity_handles array
01785  * \param tolerance Pointer to array of tolerances returned from function
01786  * \param tolerance_allocated Pointer to allocated size of tolerance array
01787  * \param tololerance_size Pointer to occupied size of tolerance array
01788  * \param *err Pointer to error type returned from function
01789  */
01790 void FBiGeom_getArrTolerance( FBiGeom_Instance instance, iBase_EntityHandle const* entity_handles,
01791                               int entity_handles_size, double** tolerances, int* tolerances_allocated,
01792                               int* tolerances_size, int* err );
01793 
01794 /**\brief  Initialize an iterator over specified entity type
01795  *
01796  * Initialize an iterator over specified entity type for a specified set or
01797  * instance.  Iterator returned can be used as input to functions returning
01798  * the entity for the iterator.  If all entities of a specified type are to
01799  * be iterated, specify iBase_ALL_TYPES.  Specified type must be a value in
01800  * the iBase_EntityType enumeration.
01801  * \param instance FBiGeom instance handle
01802  * \param entity_set_handle Entity set being iterated
01803  * \param requested_entity_type Type of entity to iterate
01804  * \param entity_iterator Pointer to iterator returned from function
01805  * \param *err Pointer to error type returned from function
01806  */
01807 void FBiGeom_initEntIter( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle, int requested_entity_type,
01808                           iBase_EntityIterator* entity_iterator, int* err );
01809 
01810 /**\brief  Initialize an array iterator over specified entity type and size
01811  *
01812  * Initialize an array iterator over specified entity type and size for a
01813  * specified set or instance.  Iterator returned can be used as input to
01814  * functions returning entities for the iterator.  If all entities of a
01815  * specified type are to be iterated, specify iBase_ALL_TYPES. Specified
01816  * type must be a value in the iBase_EntityType enumerations.
01817  * \param instance FBiGeom instance handle
01818  * \param entity_set_handle Entity set being iterated
01819  * \param requested_entity_type Type of entity to iterate
01820  * \param requested_array_size Size of chunks of handles returned for each
01821  *        value of the iterator
01822  * \param entArr_iterator Pointer to iterator returned from function
01823  * \param *err Pointer to error type returned from function
01824  */
01825 void FBiGeom_initEntArrIter( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle,
01826                              int requested_entity_type, int requested_array_size,
01827                              iBase_EntityArrIterator* entArr_iterator, int* err );
01828 
01829 /**\brief  Get entity corresponding to an iterator and increment iterator
01830  *
01831  * Get the entity corresponding to an array iterator, and increment the
01832  * iterator.  Also return whether the next value of the iterator has
01833  * an entity (if non-zero, next iterator value is the end of the
01834  * iteration).
01835  * \param instance FBiGeom instance handle
01836  * \param entity_iterator Iterator being queried
01837  * \param entity_handle Pointer to an entity handle corresponding to the
01838  *        current value of iterator
01839  * \param has_data Pointer to a flag indicating if the value returned
01840  *        in entity_handle is valid. A non-zero value indicates the value
01841  *        is valid. A zero value indicates the value is NOT valid.
01842  * \param *err Pointer to error type returned from function
01843  */
01844 void FBiGeom_getNextEntIter( FBiGeom_Instance instance, iBase_EntityIterator entity_iterator,
01845                              iBase_EntityHandle* entity_handle, int* has_data, int* err );
01846 
01847 /**\brief  Get entities contained in array iterator and increment iterator
01848  *
01849  * Get the entities contained in an array iterator, and increment the
01850  * iterator.  Also return whether the next value of the iterator has
01851  * any entities (if non-zero, next iterator value is the end of the
01852  * iteration).
01853  * \param instance FBiGeom instance handle
01854  * \param entArr_iterator Iterator being queried
01855  * \param *entity_handles Pointer to array of entity handles contained in
01856  *        current value of iterator
01857  * \param *entity_handles_allocated Pointer to allocated size of
01858  *        entity_handles array
01859  * \param *entity_handles_size Pointer to occupied size of entity_handles
01860  *        array
01861  * \param has_data Pointer to a flag indicating if the value(s) returned
01862  *        in entity_handles are valid. A non-zero value indicates the
01863  *        value(s) are valid. A zero value indicates the value(s) are NOT
01864  *        valid.
01865  * \param *err Pointer to error type returned from function
01866  */
01867 void FBiGeom_getNextEntArrIter( FBiGeom_Instance instance, iBase_EntityArrIterator entArr_iterator,
01868                                 iBase_EntityHandle** entity_handles, int* entity_handles_allocated,
01869                                 int* entity_handles_size, int* has_data, int* err );
01870 
01871 /**\brief  Reset the iterator
01872  *
01873  * Reset the iterator
01874  * \param instance FBiGeom instance handle
01875  * \param entity_iterator Iterator to reset
01876  * \param *err Pointer to error type returned from function
01877  */
01878 void FBiGeom_resetEntIter( FBiGeom_Instance instance, iBase_EntityIterator entity_iterator, int* err );
01879 
01880 /**\brief  Reset the array iterator
01881  *
01882  * Reset the array iterator
01883  * \param instance FBiGeom instance handle
01884  * \param entArr_iterator Iterator to reset
01885  * \param *err Pointer to error type returned from function
01886  */
01887 void FBiGeom_resetEntArrIter( FBiGeom_Instance instance, iBase_EntityArrIterator entArr_iterator, int* err );
01888 
01889 /**\brief  Destroy the specified iterator
01890  *
01891  * Destroy the specified iterator
01892  * \param instance FBiGeom instance handle
01893  * \param entity_iterator Iterator which gets destroyed
01894  * \param *err Pointer to error type returned from function
01895  */
01896 void FBiGeom_endEntIter( FBiGeom_Instance instance, iBase_EntityIterator entity_iterator, int* err );
01897 
01898 /**\brief  Destroy the specified array iterator
01899  *
01900  * Destroy the specified array iterator
01901  * \param instance FBiGeom instance handle
01902  * \param entArr_iterator Iterator which gets destroyed
01903  * \param *err Pointer to error type returned from function
01904  */
01905 void FBiGeom_endEntArrIter( FBiGeom_Instance instance, iBase_EntityArrIterator entArr_iterator, int* err );
01906 
01907 /**\brief  Make a copy of the specified entity
01908  *
01909  * Make a copy of the specified entity
01910  * \param instance FBiGeom instance handle
01911  * \param source entity to be copied
01912  * \param copy the newly-created entity
01913  * \param *err Pointer to error type returned from function
01914  */
01915 void FBiGeom_copyEnt( FBiGeom_Instance instance, iBase_EntityHandle source, iBase_EntityHandle* copy, int* err );
01916 
01917 /**\brief  Sweep (extrude) an entity about an axis
01918  *
01919  * Sweep (extrude) an entity by the given angle about the given axis.
01920  *
01921  * \param instance FBiGeom instance handle
01922  * \param geom_entity the entity to rotate
01923  * \param angle the rotational angle, in degrees
01924  * \param axis_x x coordinate of the axis
01925  * \param axis_y y coordinate of the axis
01926  * \param axis_z z coordinate of the axis
01927  * \param geom_entity2 Pointer to new entity handle returned from function
01928  * \param *err Pointer to error type returned from function
01929  */
01930 void FBiGeom_sweepEntAboutAxis( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double angle, double axis_x,
01931                                 double axis_y, double axis_z, iBase_EntityHandle* geom_entity2, int* err );
01932 
01933 /**\brief  Delete all entities and sets
01934  *
01935  * Delete all entities and sets
01936  * \param instance FBiGeom instance handle
01937  * \param *err Pointer to error type returned from function
01938  */
01939 void FBiGeom_deleteAll( FBiGeom_Instance instance, int* err );
01940 
01941 /**\brief  Delete specified entity
01942  *
01943  * Delete specified entity
01944  * \param instance FBiGeom instance handle
01945  * \param entity_handle Entity to be deleted
01946  * \param *err Pointer to error type returned from function
01947  */
01948 void FBiGeom_deleteEnt( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, int* err );
01949 
01950 /**\brief Create a sphere
01951  *
01952  * Create a sphere of the specified radius centered on the origin.
01953  * \param instance FBiGeom instance handle
01954  * \param radius radius of the sphere
01955  * \param geom_entity Pointer to new entity handle returned from function
01956  * \param *err Pointer to error type returned from function
01957  */
01958 void FBiGeom_createSphere( FBiGeom_Instance instance, double radius, iBase_EntityHandle* geom_entity, int* err );
01959 
01960 /**\brief  Create a prism
01961  *
01962  * Create a prism parallel to the z-axis and centered at the origin (so
01963  * that its z-coordinate extents are +height/2 and -height/2).
01964  * \param instance FBiGeom instance handle
01965  * \param height height of new prism
01966  * \param n_sides number of sides of new prism
01967  * \param major_rad major radius of new prism
01968  * \param minor_rad minor radius of new prism
01969  * \param geom_entity Pointer to new entity handle returned from function
01970  * \param *err Pointer to error type returned from function
01971  */
01972 void FBiGeom_createPrism( FBiGeom_Instance instance, double height, int n_sides, double major_rad, double minor_rad,
01973                           iBase_EntityHandle* geom_entity, int* err );
01974 
01975 /**\brief  Create an axis-oriented box
01976  *
01977  * Create an axis-oriented box of the given dimensions, centered at the
01978  * origin.
01979  * \param instance FBiGeom instance handle
01980  * \param x x dimension of new box
01981  * \param y y dimension of new box
01982  * \param z z dimension of new box
01983  * \param geom_entity Pointer to new entity handle returned from function
01984  * \param *err Pointer to error type returned from function
01985  */
01986 void FBiGeom_createBrick( FBiGeom_Instance instance, double x, double y, double z, iBase_EntityHandle* geom_entity,
01987                           int* err );
01988 
01989 /**\brief  Create a cylinder
01990  *
01991  * Create a cylinder parallel to the z-axis and centered at the origin (so
01992  * that its z-coordinate extents are +height/2 and -height/2).
01993  * \param instance FBiGeom instance handle
01994  * \param height The height of the cylinder.
01995  * \param major_rad The x-axis radius
01996  * \param minor_rad The y-axis radius. If minor_rad is 0, the cylinder will
01997  *        be circular (as if minor_rad == major_rad).
01998  * \param geom_entity Pointer to new entity handle returned from function
01999  * \param *err Pointer to error type returned from function
02000  */
02001 void FBiGeom_createCylinder( FBiGeom_Instance instance, double height, double major_rad, double minor_rad,
02002                              iBase_EntityHandle* geom_entity, int* err );
02003 
02004 /**\brief  Create a cone or tapered cylinder
02005  *
02006  * Create a cone parallel to the z-axis and centered at the origin (so that
02007  * its z-coordinate extents are +height/2 and -height/2). The 'base' of the
02008  * cylinder is at z = -height/2, and the top is at +height/2.
02009  * \param instance FBiGeom instance handle
02010  * \param height The height of the cone.
02011  * \param major_rad_base The x-axis radius at the base of the cylinder
02012  * \param minor_rad_base The y-axis radius at the base.  If minor_rad_base
02013  *        is 0, the cylinder will be circular (as if minor_rad_base ==
02014  *        major_rad_base)
02015  * \param rad_top The x-axis radius at the top of the cone.  The y-axis
02016  *        radius at the top of the cone will be inferred to keep the aspect
02017  *        ratio of the top of the cone the same as the bottom. If rad_top is
02018  *        0, the cone terminates at a point.
02019  * \param geom_entity Pointer to new entity handle returned from function
02020  * \param *err Pointer to error type returned from function
02021  */
02022 void FBiGeom_createCone( FBiGeom_Instance instance, double height, double major_rad_base, double minor_rad_base,
02023                          double rad_top, iBase_EntityHandle* geom_entity, int* err );
02024 
02025 /**\brief  Create a torus
02026  *
02027  * Create a torus centered on the origin and encircling the z-axis.
02028  * \param instance FBiGeom instance handle
02029  * \param major_rad The distance from the origin to the center of the
02030  *        torus's circular cross-section.
02031  * \param minor_rad The radius of the cross-section.
02032  * \param geom_entity Pointer to new entity handle returned from function
02033  * \param *err Pointer to error type returned from function
02034  */
02035 void FBiGeom_createTorus( FBiGeom_Instance instance, double major_rad, double minor_rad,
02036                           iBase_EntityHandle* geom_entity, int* err );
02037 
02038 /**\brief  Move an entity by the given vector
02039  *
02040  * Move an entity by translating it along the given vector.
02041  * \param instance FBiGeom instance handle
02042  * \param geom_entity the entity to move
02043  * \param x x coordinate of the vector
02044  * \param y y coordinate of the vector
02045  * \param z z coordinate of the vector
02046  * \param *err Pointer to error type returned from function
02047  */
02048 void FBiGeom_moveEnt( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double x, double y, double z,
02049                       int* err );
02050 
02051 /**\brief  Rotate an entity about an axis
02052  *
02053  * Rotate an entity by the given angle about the given axis.
02054  * \param instance FBiGeom instance handle
02055  * \param geom_entity the entity to rotate
02056  * \param angle the rotational angle, in degrees
02057  * \param axis_x x coordinate of the axis
02058  * \param axis_y y coordinate of the axis
02059  * \param axis_z z coordinate of the axis
02060  * \param *err Pointer to error type returned from function
02061  */
02062 void FBiGeom_rotateEnt( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double angle, double axis_x,
02063                         double axis_y, double axis_z, int* err );
02064 
02065 /**\brief  Reflect an entity across a plane
02066  *
02067  * Reflect an entity across the given plane
02068  * \param instance FBiGeom instance handle
02069  * \param geom_entity the entity to reflect,
02070  * \param point_x  x coordinate of the point that the reflecting plane goes though
02071  * \param point_y  y coordinate of the point that the reflecting plane goes though
02072  * \param point_z  z coordinate of the point that the reflecting plane goes though
02073  * \param plane_normal_x x coordinate of the plane's normal
02074  * \param plane_normal_y y coordinate of the plane's normal
02075  * \param plane_normal_z z coordinate of the plane's normal
02076  * \param *err Pointer to error type returned from function
02077  */
02078 void FBiGeom_reflectEnt( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double x, double y, double z,
02079                          double plane_normal_x, double plane_normal_y, double plane_normal_z, int* err );
02080 
02081 /**\brief  Scale an entity in the x, y, and z directions
02082  *
02083  * Scale an entity in the x, y, and z directions.
02084  * \param instance FBiGeom instance handle
02085  * \param geom_entity the entity to scale,
02086  * \param point_x  x coordinate of the scaling center
02087  * \param point_y  y coordinate of the scaling center
02088  * \param point_z  z coordinate of the scaling center
02089  * \param scale_x factor to scale by in the x direction
02090  * \param scale_y factor to scale by in the y direction
02091  * \param scale_z factor to scale by in the z direction
02092  * \param *err Pointer to error type returned from function
02093  */
02094 void FBiGeom_scaleEnt( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double x, double y, double z,
02095                        double scale_x, double scale_y, double scale_z, int* err );
02096 
02097 /**\brief  Geometrically unite entities
02098  *
02099  * Geometrically unite the specified entities.
02100  * \param instance FBiGeom instance handle
02101  * \param geom_entities Array of entity handles being united
02102  * \param geom_entities_size Number of entities in geom_entities array
02103  * \param geom_entity Pointer to new entity handle returned from function
02104  * \param *err Pointer to error type returned from function
02105  */
02106 void FBiGeom_uniteEnts( FBiGeom_Instance instace, iBase_EntityHandle const* geom_entities, int geom_entities_size,
02107                         iBase_EntityHandle* geom_entity, int* err );
02108 
02109 /**\brief  Geometrically subtract one entity from another
02110  *
02111  * Geometrically subtract the entity tool from the entity blank.
02112  * \param instance FBiGeom instance handle
02113  * \param blank The entity to subtract from
02114  * \param tool The entity to subtract
02115  * \param geom_entity Pointer to new entity handle returned from function
02116  * \param *err Pointer to error type returned from function
02117  */
02118 void FBiGeom_subtractEnts( FBiGeom_Instance instance, iBase_EntityHandle blank, iBase_EntityHandle tool,
02119                            iBase_EntityHandle* geom_entity, int* err );
02120 
02121 /**\brief  Geometrically intersect a pair of entities
02122  *
02123  * Geometrically intersect a pair of entities.
02124  * \param instance FBiGeom instance handle
02125  * \param entity1 The entity to intersect
02126  * \param entity2 The entity to intersect
02127  * \param geom_entity Pointer to new entity handle returned from function
02128  * \param *err Pointer to error type returned from function
02129  */
02130 void FBiGeom_intersectEnts( FBiGeom_Instance instance, iBase_EntityHandle entity2, iBase_EntityHandle entity1,
02131                             iBase_EntityHandle* geom_entity, int* err );
02132 
02133 /**\brief  Section (cut) a region with a plane
02134  *
02135  * Section (cut) a region with a plane, retaining one of the pieces and
02136  * discarding the other.
02137  * \param instance FBiGeom instance handle
02138  * \param geom_entity The entity to section
02139  * \param plane_normal_x x coordinate of the plane's normal
02140  * \param plane_normal_y y coordinate of the plane's normal
02141  * \param plane_normal_z z coordinate of the plane's normal
02142  * \param offset Distance of the plane from the origin
02143  * \param reverse Keep the piece on the normal's side (=0) or not (=1)
02144  * \param geom_entity2 Pointer to new entity handle returned from function
02145  * \param *err Pointer to error type returned from function
02146  */
02147 void FBiGeom_sectionEnt( FBiGeom_Instance instance, iBase_EntityHandle geom_entity, double plane_normal_x,
02148                          double plane_normal_y, double plane_normal_z, double offset, int reverse,
02149                          iBase_EntityHandle* geom_entity2, int* err );
02150 
02151 /**\brief  Imprint entities
02152  *
02153  * Imprint entities by merging coincident surfaces.
02154  * \param instance FBiGeom instance handle
02155  * \param geom_entities Array of entity handles being imprinted
02156  * \param geom_entities_size Number of entities in geom_entities array
02157  * \param *err Pointer to error type returned from function
02158  */
02159 void FBiGeom_imprintEnts( FBiGeom_Instance instance, iBase_EntityHandle const* geom_entities, int geom_entities_size,
02160                           int* err );
02161 
02162 /**\brief  Merge ents
02163  *
02164  * Merge entities of corresponding topology/geometry within the specified
02165  * tolerance.
02166  * \param instance FBiGeom instance handle
02167  * \param geom_entities Array of entity handles being imprinted
02168  * \param geom_entities_size Number of entities in geom_entities array
02169  * \param tolerance Tolerance within which entities are considered the same
02170  * \param *err Pointer to error type returned from function
02171  */
02172 void FBiGeom_mergeEnts( FBiGeom_Instance instance, iBase_EntityHandle const* geom_entities, int geom_entities_size,
02173                         double tolerance, int* err );
02174 
02175 /**\brief  Create an entity set
02176  *
02177  * Create an entity set, either ordered (isList=1) or unordered
02178  * (isList=0).  Unordered entity sets can contain a given entity or
02179  * set only once.
02180  * \param instance FBiGeom instance handle
02181  * \param isList If non-zero, an ordered list is created, otherwise an
02182  *        unordered set is created.
02183  * \param entity_set_created Entity set created by function
02184  * \param *err Pointer to error type returned from function
02185  */
02186 void FBiGeom_createEntSet( FBiGeom_Instance instance, int isList, iBase_EntitySetHandle* entity_set_created, int* err );
02187 
02188 /**\brief  Destroy an entity set
02189  *
02190  * Destroy an entity set
02191  * \param instance FBiGeom instance handle
02192  * \param entity_set Entity set to be destroyed
02193  * \param *err Pointer to error type returned from function
02194  */
02195 void FBiGeom_destroyEntSet( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int* err );
02196 
02197 /**\brief  Return whether a specified set is ordered or unordered
02198  *
02199  * Return whether a specified set is ordered (*is_list=1) or
02200  * unordered (*is_list=0)
02201  * \param instance FBiGeom instance handle
02202  * \param entity_set Entity set being queried
02203  * \param is_list Pointer to flag returned from function
02204  * \param *err Pointer to error type returned from function
02205  */
02206 void FBiGeom_isList( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int* is_list, int* err );
02207 
02208 /**\brief  Get the number of entity sets contained in a set or interface
02209  *
02210  * Get the number of entity sets contained in a set or interface.  If
02211  * a set is input which is not the root set, num_hops indicates the
02212  * maximum number of contained sets from entity_set_handle to one of the
02213  * contained sets, not inclusive of the contained set.
02214  * \param instance FBiGeom instance handle
02215  * \param entity_set_handle Entity set being queried
02216  * \param num_hops Maximum hops from entity_set_handle to contained set,
02217  *        not inclusive of the contained set
02218  * \param num_sets Pointer to the number of sets returned from function
02219  * \param *err Pointer to error type returned from function
02220  */
02221 void FBiGeom_getNumEntSets( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle, int num_hops,
02222                             int* num_sets, int* err );
02223 
02224 /**\brief  Get the entity sets contained in a set or interface
02225  *
02226  * Get the entity sets contained in a set or interface.  If
02227  * a set is input which is not the root set, num_hops indicates the
02228  * maximum number of contained sets from entity_set_handle to one of the
02229  * contained sets, not inclusive of the contained set.
02230  * \param instance FBiGeom instance handle
02231  * \param entity_set_handle Entity set being queried
02232  * \param num_hops Maximum hops from entity_set_handle to contained set,
02233  *        not inclusive of the contained set
02234  * \param *contained_set_handles Pointer to array of set handles returned
02235  *        from function
02236  * \param contained_set_handles_allocated Pointer to allocated length of
02237  *        contained_set_handles array
02238  * \param contained_set_handles_size Pointer to occupied length of
02239  *        contained_set_handles array
02240  * \param *err Pointer to error type returned from function
02241  */
02242 void FBiGeom_getEntSets( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle, int num_hops,
02243                          iBase_EntitySetHandle** contained_set_handles, int* contained_set_handles_allocated,
02244                          int* contained_set_handles_size, int* err );
02245 
02246 /**\brief  Add an entity to a set
02247  *
02248  * Add an entity to a set
02249  * \param instance FBiGeom instance handle
02250  * \param entity_handle The entity being added
02251  * \param entity_set Pointer to the set being added to
02252  * \param *err Pointer to error type returned from function
02253  */
02254 void FBiGeom_addEntToSet( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_EntitySetHandle entity_set,
02255                           int* err );
02256 
02257 /**\brief  Remove an entity from a set
02258  *
02259  * Remove an entity from a set
02260  *
02261  * \param instance FBiGeom instance handle
02262  * \param entity_handle The entity being removed
02263  * \param entity_set Pointer to the set being removed from
02264  * \param *err Pointer to error type returned from function
02265  */
02266 void FBiGeom_rmvEntFromSet( FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
02267                             iBase_EntitySetHandle entity_set, int* err );
02268 
02269 /**\brief  Add an array of entities to a set
02270  *
02271  * Add an array of entities to a set
02272  * \param instance FBiGeom instance handle
02273  * \param entity_handles Array of entities being added
02274  * \param entity_handles_size Number of entities in entity_handles array
02275  * \param entity_set Pointer to the set being added to
02276  * \param *err Pointer to error type returned from function
02277  */
02278 void FBiGeom_addEntArrToSet( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02279                              int entity_handles_size, iBase_EntitySetHandle entity_set, int* err );
02280 
02281 /**\brief  Remove an array of entities from a set
02282  *
02283  * Remove an array of entities from a set
02284  * \param instance FBiGeom instance handle
02285  * \param entity_handles Array of entities being remove
02286  * \param entity_handles_size Number of entities in entity_handles array
02287  * \param entity_set Pointer to the set being removed from
02288  * \param *err Pointer to error type returned from function
02289  */
02290 void FBiGeom_rmvEntArrFromSet( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02291                                int entity_handles_size, iBase_EntitySetHandle entity_set, int* err );
02292 
02293 /**\brief  Add an entity set to a set
02294  *
02295  * Add an entity set to a set
02296  * \param instance FBiGeom instance handle
02297  * \param entity_set_to_add The entity set being added
02298  * \param entity_set_handle Pointer to the set being added to
02299  * \param *err Pointer to error type returned from function
02300  */
02301 void FBiGeom_addEntSet( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_to_add,
02302                         iBase_EntitySetHandle entity_set_handle, int* err );
02303 
02304 /**\brief  Remove an entity set from a set
02305  *
02306  * Remove an entity set from a set
02307  * \param instance FBiGeom instance handle
02308  * \param entity_set_to_remove The entity set being removed
02309  * \param entity_set_handle Pointer to the set being removed from
02310  * \param *err Pointer to error type returned from function
02311  */
02312 void FBiGeom_rmvEntSet( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_to_remove,
02313                         iBase_EntitySetHandle entity_set_handle, int* err );
02314 
02315 /**\brief  Return whether an entity is contained in another set
02316  *
02317  * Return whether an entity is contained (*is_contained=1) or not
02318  * contained (*is_contained=0) in another set
02319  * \param instance FBiGeom instance handle
02320  * \param containing_entity_set Entity set being queried
02321  * \param contained_entity Entity potentially contained in
02322  *        containing_entity_set
02323  * \param is_contained Pointer to flag returned from function
02324  * \param *err Pointer to error type returned from function
02325  */
02326 void FBiGeom_isEntContained( FBiGeom_Instance instance, iBase_EntitySetHandle containing_entity_set,
02327                              iBase_EntityHandle contained_entity, int* is_contained, int* err );
02328 
02329 /**\brief  Return whether entities are contained in a set
02330  *
02331  * Return whether each entity is contained in the set.
02332  * \param instance iMesh instance handle
02333  * \param containing_entity_set Entity set being queried
02334  * \param entity_handles List of entities for which to check containment.
02335  * \param is_contained One value for each input entity, 1 if contained
02336  *          in set, zero otherwise.
02337  * \param *err Pointer to error type returned from function
02338  */
02339 void FBiGeom_isEntArrContained( FBiGeom_Instance                 instance,
02340                                 /*in*/ iBase_EntitySetHandle     containing_set,
02341                                 /*in*/ const iBase_EntityHandle* entity_handles,
02342                                 /*in*/ int                       num_entity_handles,
02343                                 /*inout*/ int**                  is_contained,
02344                                 /*inout*/ int*                   is_contained_allocated,
02345                                 /*out*/ int*                     is_contained_size,
02346                                 /*out*/ int*                     err );
02347 
02348 /**\brief  Return whether an entity set is contained in another set
02349  *
02350  * Return whether a set is contained (*is_contained=1) or not contained
02351  * (*is_contained=0) in another set
02352  * \param instance FBiGeom instance handle
02353  * \param containing_entity_set Entity set being queried
02354  * \param contained_entity_set Entity set potentially contained in
02355  *        containing_entity_set
02356  * \param is_contained Pointer to flag returned from function
02357  * \param *err Pointer to error type returned from function
02358  */
02359 void FBiGeom_isEntSetContained( FBiGeom_Instance instance, iBase_EntitySetHandle containing_entity_set,
02360                                 iBase_EntitySetHandle contained_entity_set, int* is_contained, int* err );
02361 
02362 /**\brief  Add parent/child links between two sets
02363  *
02364  * Add parent/child links between two sets.  Makes parent point to child
02365  * and child point to parent.
02366  * \param instance FBiGeom instance handle
02367  * \param parent_entity_set Pointer to parent set
02368  * \param child_entity_set Pointer to child set
02369  * \param *err Pointer to error type returned from function
02370  */
02371 void FBiGeom_addPrntChld( FBiGeom_Instance instance, iBase_EntitySetHandle parent_entity_set,
02372                           iBase_EntitySetHandle child_entity_set, int* err );
02373 
02374 /**\brief  Remove parent/child links between two sets
02375  *
02376  * Remove parent/child links between two sets.
02377  * \param instance FBiGeom instance handle
02378  * \param parent_entity_set Pointer to parent set
02379  * \param child_entity_set Pointer to child set
02380  * \param *err Pointer to error type returned from function
02381  */
02382 void FBiGeom_rmvPrntChld( FBiGeom_Instance instance, iBase_EntitySetHandle parent_entity_set,
02383                           iBase_EntitySetHandle child_entity_set, int* err );
02384 
02385 /**\brief  Return whether two sets are related by parent/child links
02386  *
02387  * Return whether two sets are related (*is_child=1) or not (*is_child=0)
02388  * by parent/child links
02389  * \param instance FBiGeom instance handle
02390  * \param parent_entity_set Pointer to parent set
02391  * \param child_entity_set Pointer to child set
02392  * \param is_child Pointer to flag returned from function
02393  * \param *err Pointer to error type returned from function
02394  */
02395 void FBiGeom_isChildOf( FBiGeom_Instance instance, iBase_EntitySetHandle parent_entity_set,
02396                         iBase_EntitySetHandle child_entity_set, int* is_child, int* err );
02397 
02398 /**\brief  Get the number of child sets linked from a specified set
02399  *
02400  * Get the number of child sets linked from a specified set.  If num_hops
02401  * is not -1, this represents the maximum hops from entity_set to any
02402  * child in the count.
02403  * \param instance FBiGeom instance handle
02404  * \param entity_set Entity set being queried
02405  * \param num_hops Maximum hops from entity_set_handle to child set,
02406  *        not inclusive of the child set
02407  * \param num_child Pointer to number of children returned from function
02408  * \param *err Pointer to error type returned from function
02409  */
02410 void FBiGeom_getNumChld( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int num_hops, int* num_child,
02411                          int* err );
02412 
02413 /**\brief  Get the number of parent sets linked from a specified set
02414  *
02415  * Get the number of parent sets linked from a specified set.  If num_hops
02416  * is not -1, this represents the maximum hops from entity_set to any
02417  * parent in the count.
02418  * \param instance FBiGeom instance handle
02419  * \param entity_set Entity set being queried
02420  * \param num_hops Maximum hops from entity_set_handle to parent set,
02421  *        not inclusive of the parent set
02422  * \param num_parent Pointer to number of parents returned from function
02423  * \param *err Pointer to error type returned from function
02424  */
02425 void FBiGeom_getNumPrnt( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, int num_hops, int* num_parent,
02426                          int* err );
02427 
02428 /**\brief  Get the child sets linked from a specified set
02429  *
02430  * Get the child sets linked from a specified set.  If num_hops
02431  * is not -1, this represents the maximum hops from entity_set to any
02432  * child.
02433  * \param instance FBiGeom instance handle
02434  * \param from_entity_set Entity set being queried
02435  * \param num_hops Maximum hops from entity_set_handle to child set,
02436  *        not inclusive of the child set
02437  * \param *entity_set_handles Pointer to array of child sets
02438  *        returned from function
02439  * \param *entity_set_handles_allocated Pointer to allocated size of
02440  *        entity_set_handles array
02441  * \param *entity_set_handles_size Pointer to occupied size of
02442  *        entity_set_handles array
02443  * \param *err Pointer to error type returned from function
02444  */
02445 void FBiGeom_getChldn( FBiGeom_Instance instance, iBase_EntitySetHandle from_entity_set, int num_hops,
02446                        iBase_EntitySetHandle** entity_set_handles, int* entity_set_handles_allocated,
02447                        int* entity_set_handles_size, int* err );
02448 
02449 /**\brief  Get the parent sets linked from a specified set
02450  *
02451  * Get the parent sets linked from a specified set.  If num_hops
02452  * is not -1, this represents the maximum hops from entity_set to any
02453  * parent.
02454  * \param instance FBiGeom instance handle
02455  * \param from_entity_set Entity set being queried
02456  * \param num_hops Maximum hops from entity_set_handle to parent set,
02457  *        not inclusive of the parent set
02458  * \param *entity_set_handles Pointer to array of parent sets
02459  *        returned from function
02460  * \param *entity_set_handles_allocated Pointer to allocated size of
02461  *        entity_set_handles array
02462  * \param *entity_set_handles_size Pointer to occupied size of
02463  *        entity_set_handles array
02464  * \param *err Pointer to error type returned from function
02465  */
02466 void FBiGeom_getPrnts( FBiGeom_Instance instance, iBase_EntitySetHandle from_entity_set, int num_hops,
02467                        iBase_EntitySetHandle** entity_set_handles, int* entity_set_handles_allocated,
02468                        int* entity_set_handles_size, int* err );
02469 
02470 /**\brief  Create a tag with specified name, size, and type
02471  *
02472  * Create a tag with specified name, size, and type.  Tag size is in
02473  * units of size of tag_type data types.  Value input for tag type must be
02474  * value in iBase_TagType enumeration.
02475  * \param instance FBiGeom instance handle
02476  * \param tag_name Character string indicating tag name
02477  * \param tag_size Size of each tag value, in units of number of tag_type
02478  *        entities
02479  * \param tag_type Data type for data stored in this tag
02480  * \param tag_handle Pointer to tag handle returned from function
02481  * \param *err Pointer to error type returned from function
02482  * \param tag_name_len Length of tag name string
02483  */
02484 void FBiGeom_createTag( FBiGeom_Instance instance, const char* tag_name, int tag_size, int tag_type,
02485                         iBase_TagHandle* tag_handle, int* err, int tag_name_len );
02486 
02487 /**\brief  Destroy a tag
02488  *
02489  * Destroy a tag.  If forced is non-zero and entities still have values
02490  * set for this tag, tag is deleted anyway and those values disappear,
02491  * otherwise tag is not deleted.
02492  * \param instance FBiGeom instance handle
02493  * \param tag_handle Handle of tag to be deleted
02494  * \param forced If non-zero, delete the tag even if entities have values
02495  *        set for that tag
02496  * \param *err Pointer to error type returned from function
02497  */
02498 void FBiGeom_destroyTag( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int forced, int* err );
02499 
02500 /**\brief  Get the name for a given tag handle
02501  *
02502  * Get the name for a given tag handle
02503  * \param instance FBiGeom instance handle
02504  * \param tag_handle Tag handle being queried
02505  * \param name Pointer to character string to store name returned from
02506  *        function
02507  * \param *err Pointer to error type returned from function
02508  * \param name_len Length of character string input to function
02509  */
02510 void FBiGeom_getTagName( FBiGeom_Instance instance, iBase_TagHandle tag_handle, char* name, int* err, int name_len );
02511 
02512 /**\brief  Get size of a tag in units of numbers of tag data type
02513  *
02514  * Get size of a tag in units of numbers of tag data type
02515  * \param instance FBiGeom instance handle
02516  * \param tag_handle Handle of tag being queried
02517  * \param tag_size Pointer to tag size returned from function
02518  * \param *err Pointer to error type returned from function
02519  */
02520 void FBiGeom_getTagSizeValues( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_size, int* err );
02521 
02522 /**\brief  Get size of a tag in units of bytes
02523  *
02524  * Get size of a tag in units of bytes
02525  * \param instance FBiGeom instance handle
02526  * \param tag_handle Handle of tag being queried
02527  * \param tag_size Pointer to tag size returned from function
02528  * \param *err Pointer to error type returned from function
02529  */
02530 void FBiGeom_getTagSizeBytes( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_size, int* err );
02531 
02532 /**\brief  Get a the handle of an existing tag with the specified name
02533  *
02534  * Get a the handle of an existing tag with the specified name
02535  * \param instance FBiGeom instance handle
02536  * \param tag_name Name of tag being queried
02537  * \param tag_handle Pointer to tag handle returned from function
02538  * \param *err Pointer to error type returned from function
02539  * \param tag_name_len Length of tag name string
02540  */
02541 void FBiGeom_getTagHandle( FBiGeom_Instance instance, const char* tag_name, iBase_TagHandle* tag_handle, int* err,
02542                            int tag_name_len );
02543 
02544 /**\brief  Get the data type of the specified tag handle
02545  *
02546  * Get the data type of the specified tag handle.  Tag type is a value in
02547  * the iBase_TagType enumeration.
02548  * \param instance FBiGeom instance handle
02549  * \param tag_handle Handle for the tag being queried
02550  * \param tag_type Pointer to tag type returned from function
02551  * \param *err Pointer to error type returned from function
02552  */
02553 void FBiGeom_getTagType( FBiGeom_Instance instance, iBase_TagHandle tag_handle, int* tag_type, int* err );
02554 
02555 /**\brief  Set a tag value of arbitrary type on an entity set
02556  *
02557  * Set a tag value of arbitrary type on an entity set. The tag data
02558  * is passed as void*. tag_value_size specifies the size of the memory
02559  * pointed to by tag_value in terms of bytes. Applications are free to
02560  * use this function to set data of any type, not just iBase_BYTES.
02561  * However, in all cases, the size specified by tag_value_size is
02562  * always in terms of bytes.
02563  *
02564  * \param instance FBiGeom instance handle
02565  * \param entity_set_handle Entity set on which tag is being set
02566  * \param tag_handle Tag being set on an entity set
02567  * \param tag_value Pointer to tag data being set on entity set
02568  * \param tag_value_size Size in bytes of tag data
02569  * \param *err Pointer to error type returned from function
02570  */
02571 void FBiGeom_setEntSetData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle,
02572                             const iBase_TagHandle tag_handle, const void* tag_value, const int tag_value_size,
02573                             int* err );
02574 
02575 /**\brief  Set a tag value of integer type on an entity set
02576  *
02577  * Set a tag value of integer type on an entity set.
02578  * \param instance FBiGeom instance handle
02579  * \param entity_set Entity set on which tag is being set
02580  * \param tag_handle Tag being set on an entity set
02581  * \param tag_value Tag value being set on entity set
02582  * \param *err Pointer to error type returned from function
02583  */
02584 void FBiGeom_setEntSetIntData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02585                                int tag_value, int* err );
02586 
02587 /**\brief  Set a tag value of double type on an entity set
02588  *
02589  * Set a tag value of double type on an entity set.
02590  * \param instance FBiGeom instance handle
02591  * \param entity_set Entity set on which tag is being set
02592  * \param tag_handle Tag being set on an entity set
02593  * \param tag_value Tag value being set on entity set
02594  * \param *err Pointer to error type returned from function
02595  */
02596 void FBiGeom_setEntSetDblData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02597                                double tag_value, int* err );
02598 
02599 /**\brief  Set a tag value of entity handle type on an entity set
02600  *
02601  * Set a tag value of entity handle type on an entity set.
02602  * \param instance FBiGeom instance handle
02603  * \param entity_set Entity set on which tag is being set
02604  * \param tag_handle Tag being set on an entity set
02605  * \param tag_value Tag value being set on entity set
02606  * \param *err Pointer to error type returned from function
02607  */
02608 void FBiGeom_setEntSetEHData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02609                               iBase_EntityHandle tag_value, int* err );
02610 
02611 /**\brief  Set a tag value of entity set handle type on an entity set
02612  *
02613  * Set a tag value of entity set handle type on an entity set.
02614  * \param instance FBiGeom instance handle
02615  * \param entity_set Entity set on which tag is being set
02616  * \param tag_handle Tag being set on an entity set
02617  * \param tag_value Tag value being set on entity set
02618  * \param *err Pointer to error type returned from function
02619  */
02620 void FBiGeom_setEntSetESHData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02621                                iBase_EntitySetHandle tag_value, int* err );
02622 
02623 /**\brief  Get the value of a tag of arbitrary type on an entity set
02624  *
02625  * Get the value of a tag of arbitrary type on an entity set.  Tag data
02626  * is returned back as void*. tag_value_size specifies the size of the
02627  * memory pointed to by tag_value in terms of bytes. Applications may
02628  * use this function to get data of any type, not just iBase_BYTES.
02629  * However because this function supports data of arbitrary type,
02630  * in all cases the size specified by tag_value_size is always in terms
02631  * of bytes.
02632  *
02633  * \param instance FBiGeom instance handle
02634  * \param entity_set_handle Entity set on which tag is being set
02635  * \param tag_handle Tag being set on an entity set
02636  * \param *tag_value Pointer to tag data array being queried
02637  * \param *tag_value_allocated Pointer to tag data array allocated size
02638  * \param *tag_value_size Pointer to occupied size in bytes of tag data
02639  *        array
02640  * \param *err Pointer to error type returned from function
02641  */
02642 void FBiGeom_getEntSetData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle,
02643                             iBase_TagHandle tag_handle, void** tag_value, int* tag_value_allocated, int* tag_value_size,
02644                             int* err );
02645 
02646 /**\brief  Get the value of a tag of integer type on an entity set
02647  *
02648  * Get the value of a tag of integer type on an entity set.
02649  * \param instance FBiGeom instance handle
02650  * \param entity_set Entity set on which tag is being set
02651  * \param tag_handle Tag being set on an entity set
02652  * \param *out_data Pointer to tag value returned from function
02653  * \param *err Pointer to error type returned from function
02654  */
02655 void FBiGeom_getEntSetIntData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02656                                int* out_data, int* err );
02657 
02658 /**\brief  Get the value of a tag of double type on an entity set
02659  *
02660  * Get the value of a tag of double type on an entity set.
02661  * \param instance FBiGeom instance handle
02662  * \param entity_set Entity set on which tag is being set
02663  * \param tag_handle Tag being set on an entity set
02664  * \param *out_data Pointer to tag value returned from function
02665  * \param *err Pointer to error type returned from function
02666  */
02667 void FBiGeom_getEntSetDblData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02668                                double* out_data, int* err );
02669 
02670 /**\brief  Get the value of a tag of entity handle type on an entity set
02671  *
02672  * Get the value of a tag of entity handle type on an entity set.
02673  * \param instance FBiGeom instance handle
02674  * \param entity_set Entity set on which tag is being set
02675  * \param tag_handle Tag being set on an entity set
02676  * \param *out_data Pointer to tag value returned from function
02677  * \param *err Pointer to error type returned from function
02678  */
02679 void FBiGeom_getEntSetEHData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02680                               iBase_EntityHandle* out_data, int* err );
02681 
02682 /**\brief  Get the value of a tag of entity set handle type on an entity set
02683  *
02684  * Get the value of a tag of entity set handle type on an entity set.
02685  * \param instance FBiGeom instance handle
02686  * \param entity_set Entity set on which tag is being set
02687  * \param tag_handle Tag being set on an entity set
02688  * \param *out_data Pointer to tag value returned from function
02689  * \param *err Pointer to error type returned from function
02690  */
02691 void FBiGeom_getEntSetESHData( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
02692                                iBase_EntitySetHandle* out_data, int* err );
02693 
02694 /**\brief  Get all the tags associated with a specified entity set
02695  *
02696  * Get all the tags associated with a specified entity set
02697  * \param instance FBiGeom instance handle
02698  * \param entity_set_handle Entity being queried
02699  * \param *tag_handles Pointer to array of tag_handles returned from
02700  *        function
02701  * \param *tag_handles_allocated Pointer to allocated size of tag_handles
02702  *        array
02703  * \param *tag_handles_size Pointer to occupied size of tag_handles array
02704  * \param *err Pointer to error type returned from function
02705  */
02706 void FBiGeom_getAllEntSetTags( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle,
02707                                iBase_TagHandle** tag_handles, int* tag_handles_allocated, int* tag_handles_size,
02708                                int* err );
02709 
02710 /**\brief  Remove a tag value from an entity set
02711  *
02712  * Remove a tag value from an entity set
02713  * \param instance FBiGeom instance handle
02714  * \param entity_set_handle Entity set from which tag is being removed
02715  * \param tag_handle Tag handle of tag being removed
02716  * \param *err Pointer to error type returned from function
02717  */
02718 void FBiGeom_rmvEntSetTag( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_handle,
02719                            iBase_TagHandle tag_handle, int* err );
02720 
02721 /**\brief  Get tag values of arbitrary type for an array of entities
02722  *
02723  * Get tag values of arbitrary type for an array of entities.  Tag data
02724  * is returned as void*. tag_values_size specifies the size of the
02725  * memory pointed to by tag_values in terms of bytes. Applications may
02726  * use this function to get data of any type, not just iBase_BYTES.
02727  * However, because this function supports data of arbitrary type, in
02728  * all cases the size specified by tag_values_size always in terms of
02729  * bytes.
02730  *
02731  * \param instance FBiGeom instance handle
02732  * \param entity_handles Entity array on which tag is being set
02733  * \param entity_handles_size Number of entities in array
02734  * \param tag_handle Tag being set on an entity
02735  * \param *tag_values Pointer to tag data array being returned from
02736  *        function. Note that the implicit INTERLEAVED storage
02737  *        order rule applies (see section ITAPS Storage Orders)
02738  * \param tag_values_allocated Pointer to allocated size of tag data array
02739  * \param tag_values_size Pointer to occupied size in bytes of tag data
02740  *        array
02741  * \param *err Pointer to error type returned from function
02742  */
02743 void FBiGeom_getArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles, int entity_handles_size,
02744                          iBase_TagHandle tag_handle, void** tag_values, int* tag_values_allocated, int* tag_values_size,
02745                          int* err );
02746 
02747 /**\brief  Get tag values of integer type for an array of entities
02748  *
02749  * Get tag values of integer type for an array of entities.
02750  * \param instance FBiGeom instance handle
02751  * \param entity_handles Entity array on which tag is being set
02752  * \param entity_handles_size Number of entities in array
02753  * \param tag_handle Tag being set on an entity
02754  * \param *tag_values Pointer to tag data array being returned from
02755  *        function
02756  * \param tag_values_allocated Pointer to allocated size of tag data array
02757  * \param tag_values_size Pointer to occupied size of tag data array
02758  * \param *err Pointer to error type returned from function
02759  */
02760 void FBiGeom_getIntArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02761                             int entity_handles_size, iBase_TagHandle tag_handle, int** tag_values,
02762                             int* tag_values_allocated, int* tag_values_size, int* err );
02763 
02764 /**\brief  Get tag values of double type for an array of entities
02765  *
02766  * Get tag values of double type for an array of entities.
02767  * \param instance FBiGeom instance handle
02768  * \param entity_handles Entity array on which tag is being set
02769  * \param entity_handles_size Number of entities in array
02770  * \param tag_handle Tag being set on an entity
02771  * \param *tag_values Pointer to tag data array being returned from
02772  *        function
02773  * \param tag_values_allocated Pointer to allocated size of tag data array
02774  * \param tag_values_size Pointer to occupied size of tag data array
02775  * \param *err Pointer to error type returned from function
02776  */
02777 void FBiGeom_getDblArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02778                             int entity_handles_size, iBase_TagHandle tag_handle, double** tag_values,
02779                             int* tag_values_allocated, int* tag_values_size, int* err );
02780 
02781 /**\brief  Get tag values of entity handle type for an array of entities
02782  *
02783  * Get tag values of entity handle type for an array of entities.
02784  * \param instance FBiGeom instance handle
02785  * \param entity_handles Entity array on which tag is being set
02786  * \param entity_handles_size Number of entities in array
02787  * \param tag_handle Tag being set on an entity
02788  * \param *tag_value Pointer to tag data array being returned from
02789  *        function
02790  * \param tag_value_allocated Pointer to allocated size of tag data array
02791  * \param tag_value_size Pointer to occupied size of tag data array
02792  * \param *err Pointer to error type returned from function
02793  */
02794 void FBiGeom_getEHArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles, int entity_handles_size,
02795                            iBase_TagHandle tag_handle, iBase_EntityHandle** tag_value, int* tag_value_allocated,
02796                            int* tag_value_size, int* err );
02797 
02798 /**\brief  Get tag values of entity set handle type for an array of entities
02799  *
02800  * Get tag values of entity set handle type for an array of entities.
02801  * \param instance FBiGeom instance handle
02802  * \param entity_handles Entity array on which tag is being set
02803  * \param entity_handles_size Number of entities in array
02804  * \param tag_handle Tag being set on an entity
02805  * \param *tag_value Pointer to tag data array being returned from
02806  *        function
02807  * \param tag_value_allocated Pointer to allocated size of tag data array
02808  * \param tag_value_size Pointer to occupied size of tag data array
02809  * \param *err Pointer to error type returned from function
02810  */
02811 void FBiGeom_getESHArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02812                             int entity_handles_size, iBase_TagHandle tag_handle, iBase_EntitySetHandle** tag_value,
02813                             int* tag_value_allocated, int* tag_value_size, int* err );
02814 
02815 /**\brief  Set tag values of arbitrary type on an array of entities
02816  *
02817  * Set tag values of arbitrary type on an array of entities.  Tag data
02818  * is passed as void*. tag_values_size specifies the size of the
02819  * memory pointed to by tag_values in terms of bytes. Applications may
02820  * use this function to set data of any type, not just iBase_BYTES.
02821  * However, because this function supports data of arbitrary type, in all
02822  * cases the size specified by tag_values_size is always in terms of
02823  * bytes.
02824  *
02825  * \param instance FBiGeom instance handle
02826  * \param entity_handles Entity array on which tag is being set
02827  * \param entity_handles_size Number of entities in array
02828  * \param tag_handle Tag being set on an entity
02829  * \param tag_values Pointer to tag data being set on entity. Note that
02830  *        the implicit INTERLEAVED storage order rule applies (see section
02831  *        ITAPS Storage Orders)
02832  * \param tag_values_size Size in bytes of tag data
02833  * \param *err Pointer to error type returned from function
02834  */
02835 void FBiGeom_setArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles, int entity_handles_size,
02836                          iBase_TagHandle tag_handle, const void* tag_values, int tag_values_size, int* err );
02837 
02838 /**\brief  Set tag values of integer type on an array of entities
02839  *
02840  * Set tag values of integer type on an array of entities.
02841  * \param instance FBiGeom instance handle
02842  * \param entity_handles Entity array on which tag is being set
02843  * \param entity_handles_size Number of entities in array
02844  * \param tag_handle Tag being set on an entity
02845  * \param tag_values Pointer to tag data being set on entities
02846  * \param tag_values_size Size in total number of integers of tag data
02847  * \param *err Pointer to error type returned from function
02848  */
02849 void FBiGeom_setIntArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02850                             int entity_handles_size, iBase_TagHandle tag_handle, const int* tag_values,
02851                             int tag_values_size, int* err );
02852 
02853 /**\brief  Set tag values of double type on an array of entities
02854  *
02855  * Set tag values of double type on an array of entities.
02856  * \param instance FBiGeom instance handle
02857  * \param entity_handles Entity array on which tag is being set
02858  * \param entity_handles_size Number of entities in array
02859  * \param tag_handle Tag being set on an entity
02860  * \param tag_values Pointer to tag data being set on entities
02861  * \param tag_values_size Size in total number of doubles of tag data
02862  * \param *err Pointer to error type returned from function
02863  */
02864 void FBiGeom_setDblArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02865                             int entity_handles_size, iBase_TagHandle tag_handle, const double* tag_values,
02866                             const int tag_values_size, int* err );
02867 
02868 /**\brief  Set tag values of entity handle type on an array of entities
02869  *
02870  * Set tag values of entity handle type on an array of entities.
02871  * \param instance FBiGeom instance handle
02872  * \param entity_handles Entity array on which tag is being set
02873  * \param entity_handles_size Number of entities in array
02874  * \param tag_handle Tag being set on an entity
02875  * \param tag_values Pointer to tag data being set on entities
02876  * \param tag_values_size Size in total number of entity handles of tag
02877  *        data
02878  * \param *err Pointer to error type returned from function
02879  */
02880 void FBiGeom_setEHArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles, int entity_handles_size,
02881                            iBase_TagHandle tag_handle, const iBase_EntityHandle* tag_values, int tag_values_size,
02882                            int* err );
02883 
02884 /**\brief  Set tag values of entity set handle type on an array of entities
02885  *
02886  * Set tag values of entity set handle type on an array of entities.
02887  * \param instance FBiGeom instance handle
02888  * \param entity_handles Entity array on which tag is being set
02889  * \param entity_handles_size Number of entities in array
02890  * \param tag_handle Tag being set on an entity
02891  * \param tag_values Pointer to tag data being set on entities
02892  * \param tag_values_size Size in total number of entity handles of tag
02893  *        data
02894  * \param *err Pointer to error type returned from function
02895  */
02896 void FBiGeom_setESHArrData( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles,
02897                             int entity_handles_size, iBase_TagHandle tag_handle,
02898                             const iBase_EntitySetHandle* tag_values, int tag_values_size, int* err );
02899 
02900 /**\brief  Remove a tag value from an array of entities
02901  *
02902  * Remove a tag value from an array of entities
02903  * \param instance FBiGeom instance handle
02904  * \param entity_handles Entity from which tag is being removed
02905  * \param entity_handles_size Number of entities in entity array
02906  * \param tag_handle Tag handle of tag being removed
02907  * \param *err Pointer to error type returned from function
02908  */
02909 void FBiGeom_rmvArrTag( FBiGeom_Instance instance, const iBase_EntityHandle* entity_handles, int entity_handles_size,
02910                         iBase_TagHandle tag_handle, int* err );
02911 
02912 /**\brief  Get the value of a tag of arbitrary type on an entity
02913  *
02914  * Get the value of a tag of arbitrary type on an entity.  Tag data
02915  * is passed back as void*. tag_value_size specifies the size of the
02916  * memory pointed to by tag_value in terms of bytes. Applications may
02917  * use this function to get data of any type, not just iBase_BYTES.
02918  * However, because this function supports arbitrary type, in all
02919  * cases the size specified by tag_value_size is always in terms of
02920  * bytes.
02921  *
02922  * \param instance FBiGeom instance handle
02923  * \param entity_handle Entity on which tag is being set
02924  * \param tag_handle Tag being set on an entity
02925  * \param *tag_value Pointer to tag data array being queried
02926  * \param *tag_value_allocated Pointer to tag data array allocated size
02927  * \param *tag_value_size Pointer to occupied size in bytes of tag data
02928  *        array
02929  * \param *err Pointer to error type returned from function
02930  */
02931 void FBiGeom_getData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
02932                       void** tag_value, int* tag_value_allocated, int* tag_value_size, int* err );
02933 
02934 /**\brief  Get the value of a tag of integer type on an entity
02935  *
02936  * Get the value of a tag of integer type on an entity.
02937  * \param instance FBiGeom instance handle
02938  * \param entity_handle Entity on which tag is being set
02939  * \param tag_handle Tag being set on an entity
02940  * \param *out_data Pointer to tag value returned from function
02941  * \param *err Pointer to error type returned from function
02942  */
02943 void FBiGeom_getIntData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
02944                          int* out_data, int* err );
02945 
02946 /**\brief  Get the value of a tag of double type on an entity
02947  *
02948  * Get the value of a tag of double type on an entity.
02949  * \param instance FBiGeom instance handle
02950  * \param entity_handle Entity on which tag is being set
02951  * \param tag_handle Tag being set on an entity
02952  * \param *out_data Pointer to tag value returned from function
02953  * \param *err Pointer to error type returned from function
02954  */
02955 void FBiGeom_getDblData( FBiGeom_Instance                instance,
02956                          /*in*/ const iBase_EntityHandle entity_handle,
02957                          /*in*/ const iBase_TagHandle tag_handle, double* out_data, int* err );
02958 
02959 /**\brief  Get the value of a tag of entity handle type on an entity
02960  *
02961  * Get the value of a tag of entity handle type on an entity.
02962  * \param instance FBiGeom instance handle
02963  * \param entity_handle Entity on which tag is being set
02964  * \param tag_handle Tag being set on an entity
02965  * \param *out_data Pointer to tag value returned from function
02966  * \param *err Pointer to error type returned from function
02967  */
02968 void FBiGeom_getEHData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
02969                         iBase_EntityHandle* out_data, int* err );
02970 
02971 /**\brief  Get the value of a tag of entity set handle type on an entity
02972  *
02973  * Get the value of a tag of entity set handle type on an entity.
02974  * \param instance FBiGeom instance handle
02975  * \param entity_handle Entity on which tag is being set
02976  * \param tag_handle Tag being set on an entity
02977  * \param *out_data Pointer to tag value returned from function
02978  * \param *err Pointer to error type returned from function
02979  */
02980 void FBiGeom_getESHData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
02981                          iBase_EntitySetHandle* out_data, int* err );
02982 
02983 /**\brief  Set a tag value of arbitrary type on an entity
02984  *
02985  * Set a tag value of arbitrary type on an entity.  Tag data
02986  * is passed as void*. tag_value_size specifies the size of the
02987  * memory pointed to by tag_value in terms of bytes. Applications may
02988  * use this function to set data of any type, not just iBase_BYTES.
02989  * However, because this function supports data of arbitrary type, in
02990  * all cases the size specified by tag_value_size is always in terms
02991  * of bytes.
02992  *
02993  * \param instance FBiGeom instance handle
02994  * \param entity_handle Entity on which tag is being set
02995  * \param tag_handle Tag being set on an entity
02996  * \param tag_value Pointer to tag data being set on entity
02997  * \param tag_value_size Size in bytes of tag data
02998  * \param *err Pointer to error type returned from function
02999  */
03000 void FBiGeom_setData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03001                       const void* tag_value, int tag_value_size, int* err );
03002 
03003 /**\brief  Set a tag value of integer type on an entity
03004  *
03005  * Set a tag value of integer type on an entity.
03006  * \param instance FBiGeom instance handle
03007  * \param entity_handle Entity on which tag is being set
03008  * \param tag_handle Tag being set on an entity
03009  * \param tag_value Tag value being set on entity
03010  * \param *err Pointer to error type returned from function
03011  */
03012 void FBiGeom_setIntData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03013                          int tag_value, int* err );
03014 
03015 /**\brief  Set a tag value of double type on an entity
03016  *
03017  * Set a tag value of double type on an entity.
03018  * \param instance FBiGeom instance handle
03019  * \param entity_handle Entity on which tag is being set
03020  * \param tag_handle Tag being set on an entity
03021  * \param tag_value Tag value being set on entity
03022  * \param *err Pointer to error type returned from function
03023  */
03024 void FBiGeom_setDblData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03025                          double tag_value, int* err );
03026 
03027 /**\brief  Set a tag value of entity handle type on an entity
03028  *
03029  * Set a tag value of entity handle type on an entity.
03030  * \param instance FBiGeom instance handle
03031  * \param entity_handle Entity on which tag is being set
03032  * \param tag_handle Tag being set on an entity
03033  * \param tag_value Tag value being set on entity
03034  * \param *err Pointer to error type returned from function
03035  */
03036 void FBiGeom_setEHData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03037                         iBase_EntityHandle tag_value, int* err );
03038 
03039 /**\brief  Set a tag value of entity set handle type on an entity
03040  *
03041  * Set a tag value of entity set handle type on an entity.
03042  * \param instance FBiGeom instance handle
03043  * \param entity_handle Entity on which tag is being set
03044  * \param tag_handle Tag being set on an entity
03045  * \param tag_value Tag value being set on entity
03046  * \param *err Pointer to error type returned from function
03047  */
03048 void FBiGeom_setESHData( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03049                          iBase_EntitySetHandle tag_value, int* err );
03050 
03051 /**\brief  Get all the tags associated with a specified entity handle
03052  *
03053  * Get all the tags associated with a specified entity handle
03054  * \param instance FBiGeom instance handle
03055  * \param entity_handle Entity being queried
03056  * \param *tag_handles Pointer to array of tag_handles returned from
03057  *        function
03058  * \param *tag_handles_allocated Pointer to allocated size of tag_handles
03059  *        array
03060  * \param *tag_handles_size Pointer to occupied size of tag_handles array
03061  * \param *err Pointer to error type returned from function
03062  */
03063 void FBiGeom_getAllTags( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle** tag_handles,
03064                          int* tag_handles_allocated, int* tag_handles_size, int* err );
03065 
03066 /**\brief  Remove a tag value from an entity
03067  *
03068  * Remove a tag value from an entity
03069  * \param instance FBiGeom instance handle
03070  * \param entity_handle Entity from which tag is being removed
03071  * \param tag_handle Tag handle of tag being removed
03072  * \param *err Pointer to error type returned from function
03073  */
03074 void FBiGeom_rmvTag( FBiGeom_Instance instance, iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
03075                      int* err );
03076 
03077 /**\brief  Subtract contents of one entity set from another
03078  *
03079  * Subtract contents of one entity set from another
03080  * \param instance FBiGeom instance handle
03081  * \param entity_set_1 Entity set from which other set is being subtracted
03082  * \param entity_set_2 Entity set being subtracted from other set
03083  * \param result_entity_set Pointer to entity set returned from function
03084  * \param *err Pointer to error type returned from function
03085  */
03086 void FBiGeom_subtract( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_1,
03087                        iBase_EntitySetHandle entity_set_2, iBase_EntitySetHandle* result_entity_set, int* err );
03088 
03089 /**\brief  Intersect contents of one entity set with another
03090  *
03091  * Intersect contents of one entity set with another
03092  * \param instance FBiGeom instance handle
03093  * \param entity_set_1 Entity set being intersected with another
03094  * \param entity_set_2 Entity set being intersected with another
03095  * \param result_entity_set Pointer to entity set returned from function
03096  * \param *err Pointer to error type returned from function
03097  */
03098 void FBiGeom_intersect( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_1,
03099                         iBase_EntitySetHandle entity_set_2, iBase_EntitySetHandle* result_entity_set, int* err );
03100 
03101 /**\brief  Unite contents of one entity set with another
03102  *
03103  * Unite contents of one entity set with another
03104  * \param instance FBiGeom instance handle
03105  * \param entity_set_1 Entity set being united with another
03106  * \param entity_set_2 Entity set being united with another
03107  * \param result_entity_set Pointer to entity set returned from function
03108  * \param *err Pointer to error type returned from function
03109  */
03110 void FBiGeom_unite( FBiGeom_Instance instance, iBase_EntitySetHandle entity_set_1, iBase_EntitySetHandle entity_set_2,
03111                     iBase_EntitySetHandle* result_entity_set, int* err );
03112 
03113 /**\brief  Return facet information from solid modeling engine
03114  *
03115  * Return facet information from solid modeling engine
03116  * \param instance FBiGeom instance handle
03117  * \param entity_handle Entity being queried
03118  * \param dist_tolerance Tolerance guidance for faceting engine
03119  * \param points List of vertices in faceting of curve or surface
03120  * \param points_allocated Allocated size of vertex list array
03121  * \param points_size Occupied size of vertex list array
03122  * \param facets List of facets in faceting of surface
03123  * \param facets_allocated Allocated size of facet list array
03124  * \param facets_size Occupied size of facet list array
03125  * \param *err Pointer to error type returned from function
03126  */
03127 void FBiGeom_getFacets( FBiGeom_Instance instance, iBase_EntityHandle entity, double dist_tolerance, double** points,
03128                         int* points_allocated, int* points_size, int** facets, int* facets_allocated, int* facets_size,
03129                         int* err );
03130 
03131 #ifdef __cplusplus
03132 } /* extern "C" */
03133 #endif
03134 
03135 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines