FBiGeom.h 190 KB
Newer Older
1 2
#ifndef _ITAPS_FBiGeom
#define _ITAPS_FBiGeom
3

4
  /** \mainpage The ITAPS Geometry Interface FBiGeom
5
   *
6
   * The ITAPS Geometry Interface FBiGeom provides a common interface for
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
   * accessing geometry and data associated with a mesh.  Applications written
   * to use this interface can use a variety of implementations, choosing
   * the one that best meets its needs.  They can also use tools written
   * to this interface.
   *
   * \section ITAPS Data Model
   *
   * The ITAPS interfaces use a data model composed of four basic data types:\n
   * \em Entity: basic topological entities in a model, e.g. vertices, 
   * edges, faces, regions. \n
   * \em Entity \em Set: arbitrary grouping of other entities and sets. 
   * Entity sets also support parent/child relations with other sets which
   * are distinct from entities contained in those sets.  Parent/child links
   * can be used to embed graph relationships between sets, e.g. to 
   * represent topological relationships between the sets. \n
   * \em Interface: the object with which model is associated and on which
23
   * functions in FBiGeom are called. \n
24 25 26 27 28 29 30 31 32 33 34
   * \em Tag: application data associated with objects of any of the other 
   * data types.  Each tag has a designated name, size, and data type.
   *
   * \section JTAPS Entity Type
   * Each entity has a specific Entity Type.  The Entity 
   * Type is one of VERTEX, EDGE, FACE, and REGION, and is synonymous with
   * the topological dimension of the entity.  Entity Type is an enumerated
   * type in the iBase_EntityType enumeration.
   *
   * \section KTAPS Entity-, Array-, and Iterator-Based Access
   *
35
   * The FBiGeom interface provides functions for accessing entities
36 37 38 39 40 41
   * individually, as arrays of entities, or using iterators.  These access
   * methods have different memory versus execution time tradeoffs, 
   * depending on the implementation.
   *
   * \section LTAPS Lists Passed Through Interface
   *
42
   * Many of the functions in FBiGeom have arguments corresponding to lists of 
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
   * objects.  In-type arguments for lists consist of a pointer to an array and
   * a list size.  Lists returned from functions are passed in three arguments,
   * a pointer to the array representing the list, and pointers to the
   * allocated and occupied lengths of the array.  These three arguments are 
   * inout-type arguments, because they can be allocated by the application and
   * passed into the interface to hold the results of the function.  Lists
   * which are pre-allocated must be large enough to hold the results of the
   * function; if this is not the case, an error is generated.  Otherwise, the
   * occupied size is changed to the size output from the function.  If a list
   * argument is unallocated (the list pointer points to a NULL value) or if
   * the incoming value of the allocated size is zero, the list storage will be
   * allocated by the implementation.  IN ALL CASES, MEMORY ALLOCATED BY ITAPS
   * INTERFACE IMPLEMENTATIONS IS DONE USING THE C MALLOC FUNCTION, AND CAN BE
   * DE-ALLOCATED USING THE C FREE FUNCTION.
   *
   */

#include "iBase.h"
61
#include "FBiGeom_protos.h"
62

63 64 65 66
#ifdef __cplusplus
extern "C" {
#endif

67
    /**\brief  Type used to store FBiGeom interface handle
68
     *
69
     * Type used to store FBiGeom interface handle
70
     */
71
  typedef struct FBiGeom_Instance_Private* FBiGeom_Instance;
72

73
    /**\brief  Get a description of the error returned from the last FBiGeom call
74
     *
75 76
     * Get a description of the error returned from the last FBiGeom function
     * \param instance FBiGeom instance handle
77
     * \param descr Pointer to a character string to be filled with a
78
     *        description of the error from the last FBiGeom function
79 80
     * \param descr_len Length of the character string pointed to by descr
     */
81
  void FBiGeom_getDescription( FBiGeom_Instance instance,
82 83 84
                             char* descr,
                             int descr_len );

85
    /**\brief  Get the error type returned from the last FBiGeom function
86
     *
87
     * Get the error type returned from the last FBiGeom function.  Value
88
     * returned is a member of the iBase_ErrorType enumeration.
89 90
     * \param instance FBiGeom instance handle
     * \param *error_type Error type returned from last FBiGeom function
91
     */
92
  void FBiGeom_getErrorType( FBiGeom_Instance instance,
93
                           /*out*/ int *error_type );
94

95
    /**\brief  Construct a new FBiGeom instance
96
     *
97
     * Construct a new FBiGeom instance, using implementation-specific options
98
     * \param options Pointer to implementation-specific options string
99
     * \param instance Pointer to FBiGeom instance handle returned from function
100 101 102
     * \param *err Pointer to error type returned from function
     * \param options_len Length of the character string pointed to by options
     */
103 104
  void FBiGeom_newGeom( char const* options,
                      FBiGeom_Instance* instance_out,
105 106 107
                      int* err,
                      int options_len );

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
  /**\brief  Construct a new FBiGeom instance
       *
       * Construct a new FBiGeom instance, using an existing moab iMesh instance
       * and a root set that encapsulates the topological model
       * \param mesh iMesh_Instance
       * \param set  root set for the mesh based geometry
       * \param options Pointer to implementation-specific options string
       * \param instance Pointer to FBiGeom instance handle returned from function
       * \param *err Pointer to error type returned from function
       * \param options_len Length of the character string pointed to by options
       */

/*  void FBiGeom_newGeomFromMesh( iMesh_Instance mesh, iBase_EntitySetHandle set,
                          const char *options, FBiGeom_Instance *geom,
                          int *err, int options_len);*/
123
    /**\brief  Destroy an FBiGeom instance
124
     *
125 126
     * Destroy an FBiGeom instance
     * \param instance FBiGeom instance to be destroyed
127 128
     * \param *err Pointer to error type returned from function
     */
129
  void FBiGeom_dtor( FBiGeom_Instance instance,
130 131 132 133 134 135 136
                   int* err );


    /**\brief  Load a geom from a file
     *
     * Load a geom from a file.  If entity set is specified, loaded geom
     * is added to that set; specify zero if that is not desired.
137
     * \param instance FBiGeom instance handle
138 139 140 141 142 143 144 145
     * \param entity_set_handle Set to which loaded geom will be added, zero
     *        if not desired
     * \param name File name from which geom is to be loaded
     * \param options Pointer to implementation-specific options string
     * \param *err Pointer to error type returned from function
     * \param name_len Length of the file name character string
     * \param options_len Length of the options character string
     */
146
  void FBiGeom_load( FBiGeom_Instance instance,
147 148 149 150 151 152 153 154 155 156
                   char const* name,
                   char const* options,
                   int* err,
                   int name_len,
                   int options_len );

    /**\brief  Save a geom to a file
     *
     * Save a geom to a file.  If entity set is specified, save only the
     * geom contained in that set.
157
     * \param instance FBiGeom instance handle
158 159 160 161 162 163 164
     * \param entity_set_handle Entity set being saved
     * \param name File name to which geom is to be saved
     * \param options Pointer to implementation-specific options string
     * \param *err Pointer to error type returned from function
     * \param name_len Length of the file name character string
     * \param options_len Length of the options character string
     */
165
  void FBiGeom_save( FBiGeom_Instance instance,
166 167 168 169 170 171 172 173 174 175
                   char const* name,
                   char const* options,
                   int* err,
                   int name_len,
                   int options_len );

    /**\brief  Get handle of the root set for this instance
     *
     * Get handle of the root set for this instance.  All geom in
     * this instance can be accessed from this set.
176
     * \param instance FBiGeom instance handle
177 178 179
     * \param root_set Pointer to set handle returned from function
     * \param *err Pointer to error type returned from function
     */
180
  void FBiGeom_getRootSet( FBiGeom_Instance instance,
181 182 183 184 185 186
                         iBase_EntitySetHandle* root_set,
                         int* err );

    /**\brief Get the bounding box of the entire model
     *
     * Get the bounding box of the entire model
187
     * \param instance FBiGeom instance handle
188 189 190 191 192 193 194 195
     * \param min_x Minimum coordinate of bounding box
     * \param min_y Minimum coordinate of bounding box
     * \param min_z Minimum coordinate of bounding box
     * \param max_x Maximum coordinate of bounding box
     * \param max_y Maximum coordinate of bounding box
     * \param max_z Maximum coordinate of bounding box
     * \param *err Pointer to error type returned from function
     */
196
  void FBiGeom_getBoundBox( FBiGeom_Instance instance,
197 198 199 200 201 202 203 204 205 206 207 208 209
                          double* min_x,
                          double* min_y,
                          double* min_z,
                          double* max_x,
                          double* max_y,
                          double* max_z,
                          int* err );

    /**\brief  Get entities of specific type in set or instance
     *
     * Get entities of specific type in set or instance.  All entities are
     * requested by specifying iBase_ALL_TYPES.  Specified type must be a value
     * in the iBase_EntityType enumeration.
210
     * \param instance FBiGeom instance handle
211 212 213 214 215 216 217 218 219 220 221
     * \param entity_set_handle Entity set being queried
     * \param entity_type Type of entities being requested
     * \param entity_topology Topology of entities being requested
     * \param *entity_handles Pointer to array of entity handles returned 
     *        from function
     * \param *entity_handles_allocated Pointer to allocated size of 
     *        entity_handles array
     * \param *entity_handles_size Pointer to occupied size of entity_handles
     *        array
     * \param *err Pointer to error type returned from function
     */
222
  void FBiGeom_getEntities( FBiGeom_Instance instance,
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
                          iBase_EntitySetHandle set_handle,
                          int entity_type,
                          iBase_EntityHandle** entity_handles,
                          int* entity_handles_allococated,
                          int* entity_handles_size,
                          int* err );

    /**\brief  Get the number of entities with the specified type in the
     *         instance or set
     *
     * Get the number of entities with the specified type in the instance 
     * or set.  If entity set handle is zero, return information for instance,
     * otherwise for set.  Value of entity type must be from the
     * iBase_EntityType enumeration.  If iBase_ALL_TYPES is specified, total
     * number of entities (excluding entity sets) is returned.
238
     * \param instance FBiGeom instance handle
239 240 241 242 243
     * \param entity_set_handle Entity set being queried
     * \param entity_type Type of entity requested
     * \param num_type Pointer to number of entities, returned from function
     * \param *err Pointer to error type returned from function
     */
244
  void FBiGeom_getNumOfType( FBiGeom_Instance instance,
245 246 247 248 249 250 251 252 253
                           iBase_EntitySetHandle set_handle,
                           int entity_type,
                           int* num_out,
                           int* err );

    /**\brief  Get the entity type for the specified entity
     *
     * Get the entity type for the specified entity.  Type returned is a value
     * in the iBase_EntityType enumeration.
254
     * \param instance FBiGeom instance handle
255 256 257 258
     * \param entity_handle entity handle being queried
     * \param *type Pointer to location at which to store the returned type
     * \param *err Pointer to error type returned from function
     */
259
  void FBiGeom_getEntType( FBiGeom_Instance instance,
260 261 262 263 264 265 266 267
                         iBase_EntityHandle entity_handle,
                         int* type,
                         int* err );

    /**\brief  Get the entity type for the specified entities
     *
     * Get the entity type for the specified entities.  Types returned are
     * values in the iBase_EntityType enumeration.
268
     * \param instance FBiGeom instance handle
269 270 271 272 273 274 275
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param *type Pointer to array of types returned from function
     * \param *type_allocated Pointer to allocated size of type array
     * \param *type_size Pointer to occupied size of type array
     * \param *err Pointer to error type returned from function
     */
276
  void FBiGeom_getArrType( FBiGeom_Instance instance,
277 278 279 280 281 282 283 284 285 286 287
                         iBase_EntityHandle const* entity_handles,
                         int entity_handles_size,
                         int** type,
                         int* type_allocated,
                         int* type_size,
                         int* err );

    /**\brief  Get entities of specified type adjacent to an entity
     *
     * Get entities of specified type adjacent to an entity.  Specified type
     * must be value in the iBase_EntityType enumeration.
288
     * \param instance FBiGeom instance handle
289 290 291 292 293 294 295 296 297 298
     * \param entity_handle Entity handle being queried
     * \param entity_type_requested Type of adjacent entities requested
     * \param *adj_entity_handles Pointer to array of adjacent entities
     *        returned from function
     * \param *adj_entity_handles_allocated Pointer to allocated size of 
     *        adj_entity_handles array
     * \param *adj_entity_handles_size Pointer to occupied size of 
     *        adj_entity_handles array
     * \param *err Pointer to error type returned from function
     */
299
  void FBiGeom_getEntAdj( FBiGeom_Instance instance,
300 301 302 303 304 305 306 307 308 309 310 311 312
                        iBase_EntityHandle entity_handle,
                        int to_dimension,
                        iBase_EntityHandle** adj_entities,
                        int* adj_entities_allocated,
                        int* adj_entities_size,
                        int* err );

    /**\brief  Get entities of specified type adjacent to entities
     *
     * Get entities of specified type adjacent to entities.  Specified type
     * must be value in the iBase_EntityType enumeration.  \em offset(i) is
     * index of first entity in adjacentEntityHandles array adjacent to 
     * entity_handles[i].
313
     * \param instance FBiGeom instance handle
314 315 316 317 318 319 320 321 322 323 324 325 326 327
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param entity_type_requested Type of adjacent entities requested
     * \param *adjacentEntityHandles Pointer to array of adjacentEntityHandles 
     *        returned from function
     * \param *adjacentEntityHandles_allocated Pointer to allocated size of 
     *        adjacentEntityHandles array
     * \param *adj_entity_handles_size Pointer to occupied size of 
     *        adjacentEntityHandles array
     * \param *offset Pointer to array of offsets returned from function
     * \param *offset_allocated Pointer to allocated size of offset array
     * \param *offset_size Pointer to occupied size of offset array
     * \param *err Pointer to error type returned from function
     */
328
  void FBiGeom_getArrAdj( FBiGeom_Instance instance,
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
                        iBase_EntityHandle const* entity_handles,
                        int entity_handles_size,
                        int requested_entity_type,
                        iBase_EntityHandle** adj_entity_handles,
                        int* adj_entity_handles_allocated,
                        int* adj_entity_handles_size,
                        int** offset,
                        int* offset_allocated,
                        int* offset_size,
                        int* err );

    /**\brief  Get "2nd order" adjacencies to an entity
     *
     * Get "2nd order" adjacencies to an entity, that is, from an entity,
     * through other entities of a specified "bridge" dimension, to other
     * entities of another specified "to" dimension.
345
     * \param instance FBiGeom instance handle
346 347 348 349 350 351 352 353
     * \param entity_handle Entity from which adjacencies are requested
     * \param bridge_dimension Bridge dimension for 2nd order adjacencies
     * \param to_dimension Dimension of adjacent entities returned
     * \param adjacent_entities Adjacent entities
     * \param adjacent_entities_allocated Allocated size of returned array
     * \param adjacent_entities_size Occupied size of returned array
     * \param *err Pointer to error type returned from function
     */
354
  void FBiGeom_getEnt2ndAdj( FBiGeom_Instance instance,
355 356 357 358 359 360 361 362 363 364 365 366 367
                           iBase_EntityHandle entity_handle,
                           int bridge_dimension,
                           int to_dimension,
                           iBase_EntityHandle** adjacent_entities,
                           int* adjacent_entities_allocated,
                           int* adjacent_entities_size,
                           int* err );

    /**\brief  Get "2nd order" adjacencies to an array of entities
     *
     * Get "2nd order" adjacencies to an array of entities, that is, from each
     * entity, through other entities of a specified "bridge" dimension, to
     * other entities of another specified "to" dimension.
368
     * \param instance FBiGeom instance handle
369 370 371 372 373 374 375 376 377 378 379 380 381 382
     * \param entity_handles Entities from which adjacencies are requested
     * \param entity_handles_size Number of entities whose adjacencies are
     *        requested
     * \param bridge_dimension Bridge dimension for 2nd order adjacencies
     * \param to_dimension Dimension of adjacent entities returned
     * \param adj_entity_handles Adjacent entities
     * \param adj_entity_handles_allocated Allocated size of returned array
     * \param adj_entity_handles_size Occupied size of returned array
     * \param offset Offset[i] is offset into adj_entity_handles of 2nd order 
     *        adjacencies of ith entity in entity_handles
     * \param offset_allocated Allocated size of offset array
     * \param offset_size Occupied size of offset array
     * \param *err Pointer to error type returned from function
     */
383
  void FBiGeom_getArr2ndAdj( FBiGeom_Instance instance,
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           int order_adjacent_key,
                           int requested_entity_type,
                           iBase_EntityHandle** adj_entity_handles,
                           int* adj_entity_handles_allocated,
                           int* adj_entity_handles_size,
                           int** offset,
                           int* offset_allocated,
                           int* offset_size,
                           int* err );

    /**\brief  Return whether two entities are adjacent
     *
     * Return whether two entities are adjacent.
399
     * \param instance FBiGeom instance handle
400 401 402 403 404 405
     * \param entity_handle1 First entity queried
     * \param entity_handle2 Second entity queried
     * \param are_adjacent If returned non-zero, entities are adjacent,
     *        otherwise they are not
     * \param *err Pointer to error type returned from function
     */
406
  void FBiGeom_isEntAdj( FBiGeom_Instance instance,
407 408 409 410 411 412 413 414 415 416
                       iBase_EntityHandle entity_handle1,
                       iBase_EntityHandle entity_handle2,
                       int* are_adjacent,
                       int* err );

    /**\brief  Return whether entity pairs are adjacent
     *
     * Return whether entity pairs are adjacent, i.e. if entity_handles_1[i] is
     * adjacent to entity_handles_2[i].  This function requires
     * entity_handles_1_size and entity_handles_2_size to be equal.
417
     * \param instance FBiGeom instance handle
418 419 420 421 422 423 424 425 426
     * \param entity_handles_1 First array of entities
     * \param entity_handles_1_size Number of entities in first array
     * \param entity_handles_2 Second array of entities
     * \param entity_handles_2_size Number of entities in second array
     * \param is_adjacent_info Array of flags returned from function
     * \param is_adjacent_info_allocated Allocated size of flags array
     * \param is_adjacent_info_size Occupied size of flags array
     * \param *err Pointer to error type returned from function
     */
427
  void FBiGeom_isArrAdj( FBiGeom_Instance instance,
428 429 430 431 432 433 434 435 436 437 438 439 440
                       iBase_EntityHandle const* entity_handles_1,
                       int entity_handles_1_size,
                       iBase_EntityHandle const* entity_handles_2,
                       int entity_handles_2_size,
                       int** is_adjacent_info,
                       int* is_adjacent_info_allocated,
                       int* is_adjacent_info_size,
                       int* err );

    /**\brief  Return the topology level of the geometry
     *
     * Return the topology level of the geometry as an integer, where 0 = basic
     * entities only, 1 = manifold entities, 2 = non-manifold entities.
441
     * \param instance FBiGeom instance handle
442 443 444
     * \param topo_level_out The topology level
     * \param *err Pointer to error type returned from function
     */
445
  void FBiGeom_getTopoLevel( FBiGeom_Instance instance,
446 447 448 449 450 451
                           int* topo_level_out,
                           int* err );

    /**\brief  Get closest point to an entity
     *
     * Get closest point to a specified position on an entity
452
     * \param instance FBiGeom instance handle
453 454 455 456 457 458 459 460 461
     * \param entity_handle Entity being queried
     * \param near_x Coordinates of starting point
     * \param near_y Coordinates of starting point
     * \param near_z Coordinates of starting point
     * \param on_x Closest point on entity
     * \param on_y Closest point on entity
     * \param on_z Closest point on entity
     * \param *err Pointer to error type returned from function
     */
462
  void FBiGeom_getEntClosestPt( FBiGeom_Instance instance,
463 464 465 466 467 468 469 470 471 472
                              iBase_EntityHandle entity_handle,
                              double near_x, 
                              double near_y,
                              double near_z,
                              double* on_x,
                              double* on_y,
                              double* on_z,
                              int* err );

    /**\brief  Get closest point for an array of entities and points
473 474 475 476 477 478
     * For surfaces, closest point could be on the void space inside it.
     * Get closest point for an array of entities and points.  If either the
     * number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
479
     * \param instance FBiGeom instance handle
480 481 482 483 484 485 486 487 488 489 490
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of input points
     * \param near_coordinates Coordinates of starting point(s)
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Coordinates of closest points
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param *err Pointer to error type returned from function
     */

491
  void FBiGeom_getEntClosestPtTrimmed( FBiGeom_Instance instance,
492 493 494 495 496 497 498 499 500 501 502
                                     iBase_EntityHandle entity_handle,
                                     double near_x,
                                     double near_y,
                                     double near_z,
                                     double* on_x,
                                     double* on_y,
                                     double* on_z,
                                     int* err );

    /**\brief  Get closest point for an array of entities and points
     * For surfaces, it made sure the closest point in on surface.
503 504 505 506 507
     * Get closest point for an array of entities and points.  If either the
     * number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
508
     * \param instance FBiGeom instance handle
509 510 511 512 513 514 515 516 517 518
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of input points
     * \param near_coordinates Coordinates of starting point(s)
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Coordinates of closest points
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param *err Pointer to error type returned from function
     */
519
  void FBiGeom_getArrClosestPt( FBiGeom_Instance instance,
520 521 522 523 524 525 526 527 528 529 530 531
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double const* near_coordinates,
                              int near_coordinates_size,
                              double** on_coordinates,
                              int* on_coordinates_allocated,
                              int* on_coordinates_size,
                              int* err );

    /**\brief  Get the normal vector on an entity at the given position
     * Get the normal vector on an entity at the given position.
532
     * \param instance FBiGeom instance handle
533 534 535 536 537 538 539 540 541
     * \param entity_handle Entity being queried
     * \param x Coordinates of starting point
     * \param y Coordinates of starting point
     * \param z Coordinates of starting point
     * \param nrml_i Normal vector at starting point
     * \param nrml_j Normal vector at starting point
     * \param nrml_k Normal vector at starting point
     * \param *err Pointer to error type returned from function
     */
542
  void FBiGeom_getEntNrmlXYZ( FBiGeom_Instance instance,
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* nrml_i,
                            double* nrml_j,
                            double* nrml_k,
                            int* err );

    /**\brief  Get the normal vector on an entity(ies) at given position(s)
     *
     * Get the normal vector on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
559
     * \param instance FBiGeom instance handle
560 561 562 563 564 565 566 567 568 569
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coordinates Starting coordinates
     * \param coordinates_size Number of values in coordinates array
     * \param normals Normal coordinates
     * \param normals_allocated Allocated size of normals array
     * \param normals_size Occupied size of normals array
     * \param *err Pointer to error type returned from function
     */
570
  void FBiGeom_getArrNrmlXYZ( FBiGeom_Instance instance,
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** normals,
                            int* normals_allocated,
                            int* normals_size,
                            int* err );

    /**\brief  Get the normal vector AND closest point on an entity at given
     *         position
     *
     * Get the normal vector AND closest point on an entity at a given position.
     * \param entity_handle Entity being queried
586
     * \param instance FBiGeom instance handle
587 588 589 590 591 592 593 594 595 596 597
     * \param x Starting coordinates
     * \param y Starting coordinates
     * \param z Starting coordinates
     * \param pt_x Closest point
     * \param pt_y Closest point
     * \param pt_z Closest point
     * \param nrml_i Normal at closest point
     * \param nrml_j Normal at closest point
     * \param nrml_k Normal at closest point
     * \param *err Pointer to error type returned from function
     */
598
  void FBiGeom_getEntNrmlPlXYZ( FBiGeom_Instance instance,
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
                              iBase_EntityHandle entity_handle,
                              double x,
                              double y,
                              double z,
                              double* pt_x,
                              double* pt_y,
                              double* pt_z,
                              double* nrml_i,
                              double* nrml_j,
                              double* nrml_k,
                              int* err );

    /**\brief Get the normal vector AND closest point on an entity(ies) at
     *        given position(s)
     *
     * Get the normal vector AND closest point on an entity(ies) at given
     * position(s).  If either the number of entities or number of coordinate
     * triples is unity, then all points or entities are queried for that entity
     * or point, respectively, otherwise each point corresponds to each entity.
     * storage_order should be a value in the iBase_StorageOrder enum.
619
     * \param instance FBiGeom instance handle
620 621 622 623 624 625 626 627 628 629 630 631 632
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entity(ies) being queried
     * \param storage_order Storage order in near_coordinates array
     * \param near_coordinates Starting coordinates
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Closest point array
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param normals Normal array
     * \param normals_allocated Allocated size of normal array
     * \param normals_size Occupied size of normal array
     * \param *err Pointer to error type returned from function
     */
633
  void FBiGeom_getArrNrmlPlXYZ( FBiGeom_Instance instance,
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double const* near_coordinates,
                              int near_coordinates_size,
                              double** on_coordinates,
                              int* on_coordinates_allocated,
                              int* on_coordinates_size,
                              double** normals,
                              int* normals_allocated,
                              int* normals_size,
                              int* err );

    /**\brief  Get the tangent vector on an entity at given position
     *
     * Get the tangent vector on an entity at a given position.
650
     * \param instance FBiGeom instance handle
651 652 653 654 655 656 657 658 659
     * \param entity_handle Entity being queried
     * \param x Starting coordinates
     * \param y Starting coordinates
     * \param z Starting coordinates
     * \param tgnt_i Tangent at closest point
     * \param tgnt_j Tangent at closest point
     * \param tgnt_k Tangent at closest point
     * \param *err Pointer to error type returned from function
     */
660
  void FBiGeom_getEntTgntXYZ( FBiGeom_Instance instance,
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* tgnt_i,
                            double* tgnt_j,
                            double* tgnt_k,
                            int* err );

    /**\brief  Get the tangent vector on an entity(ies) at given position(s)
     *
     * Get the tangent vector on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum
677
     * \param instance FBiGeom instance handle
678 679 680 681 682 683 684 685 686 687
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coordinates Starting coordinates
     * \param coordinates_size Number of values in coordinates array
     * \param tangents Tangent coordinates
     * \param tangents_allocated Allocated size of tangents array
     * \param tangents_size Occupied size of tangents array
     * \param *err Pointer to error type returned from function
     */
688
  void FBiGeom_getArrTgntXYZ( FBiGeom_Instance instance,
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** tangents,
                            int* tangents_allocated,
                            int* tangents_size,
                            int* err );

    /**\brief  Get the two principle curvature vectors for a face at a point
     *
     * Get the two principle curvature vectors for a face at a point.
     * Magnitudes of vectors are curvature, directions are directions of
     * principal curvatures.
704
     * \param instance FBiGeom instance handle
705 706 707 708 709 710 711 712 713 714 715 716
     * \param face_handle Face being queried
     * \param x Position being queried
     * \param y Position being queried
     * \param z Position being queried
     * \param cvtr1_i Maximum curvature vector
     * \param cvtr1_j Maximum curvature vector
     * \param cvtr1_k Maximum curvature vector
     * \param cvtr2_i Minimum curvature vector
     * \param cvtr2_j Minimum curvature vector
     * \param cvtr2_k Minimum curvature vector
     * \param *err Pointer to error type returned from function
     */
717
  void FBiGeom_getFcCvtrXYZ( FBiGeom_Instance instance,
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
                           iBase_EntityHandle face_handle,
                           double x,
                           double y,
                           double z,
                           double* cvtr1_i,
                           double* cvtr1_j,
                           double* cvtr1_k,
                           double* cvtr2_i,
                           double* cvtr2_j,
                           double* cvtr2_k,
                           int* err );

    /**\brief  Get the principle curvature vector for an edge at a point
     *
     * Get the principle curvature vector for an edge at a point.  Magnitude of
     * vector is the curvature, direction is direction of principal curvature.
734
     * \param instance FBiGeom instance handle
735 736 737 738 739 740 741 742 743
     * \param edge_handle Edge being queried
     * \param x Position being queried
     * \param y Position being queried
     * \param z Position being queried
     * \param cvtr_i Maximum curvature vector
     * \param cvtr_j Maximum curvature vector
     * \param cvtr_k Maximum curvature vector
     * \param *err Pointer to error type returned from function
     */
744
  void FBiGeom_getEgCvtrXYZ( FBiGeom_Instance instance,
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
                           iBase_EntityHandle edge_handle,
                           double x,
                           double y,
                           double z,
                           double* cvtr_i,
                           double* cvtr_j,
                           double* cvtr_k,
                           int* err );

    /**\brief  Get the curvature(s) on an entity(ies) at given position(s)
     *
     * Get the curvature(s) on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
761
     * \param instance FBiGeom instance handle
762 763 764 765 766 767 768 769 770 771 772 773 774
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param cvtr_1 First principal curvatures
     * \param cvtr_1_allocated Allocated size of first curvature array
     * \param cvtr_1_size Occupied size of first curvature array
     * \param cvtr_2 Second principal curvatures
     * \param cvtr_2_allocated Allocated size of second curvature array
     * \param cvtr_2_size Occupied size of second curvature array
     * \param *err Pointer to error type returned from function
     */
775
  void FBiGeom_getEntArrCvtrXYZ( FBiGeom_Instance instance,
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
                               iBase_EntityHandle const* entity_handles,
                               int entity_handles_size,
                               int storage_order,
                               double const* coords,
                               int coords_size,
                               double** cvtr_1,
                               int* cvtr_1_allocated,
                               int* cvtr_1_size,
                               double** cvtr_2,
                               int* cvtr_2_allocated,
                               int* cvtr_2_size,
                               int* err );

    /**\brief  Get closest point, tangent, and curvature of edge
     *
     * Get closest point, tangent, and curvature of edge.
792
     * \param instance FBiGeom instance handle
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807
     * \param edge_handle Edge being queried
     * \param x Point at which entity is being queried
     * \param y Point at which entity is being queried
     * \param z Point at which entity is being queried
     * \param on_x Closest point at point being queried
     * \param on_y Closest point at point being queried
     * \param on_z Closest point at point being queried
     * \param tgnt_i Tangent at point being queried
     * \param tgnt_j Tangent at point being queried
     * \param tgnt_k Tangent at point being queried
     * \param cvtr_i Curvature at point being queried
     * \param cvtr_j Curvature at point being queried
     * \param cvtr_k Curvature at point being queried
     * \param *err Pointer to error type returned from function
     */
808
  void FBiGeom_getEgEvalXYZ( FBiGeom_Instance instance,
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
                           iBase_EntityHandle edge_handle,
                           double x,
                           double y,
                           double z,
                           double* on_x,
                           double* on_y,
                           double* on_z,
                           double* tgnt_i,
                           double* tgnt_j,
                           double* tgnt_k,
                           double* cvtr_i,
                           double* cvtr_j,
                           double* cvtr_k,
                           int* err );

    /**\brief  Get closest point, tangent, and curvature of face
     *
     * Get closest point, tangent, and curvature of face.  If any of input
     * coordinate pointers are NULL, that value is not returned.
828
     * \param instance FBiGeom instance handle
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
     * \param face_handle Face being queried
     * \param x Point at which entity is being queried
     * \param y Point at which entity is being queried
     * \param z Point at which entity is being queried
     * \param on_x Closest point at point being queried
     * \param on_y Closest point at point being queried
     * \param on_z Closest point at point being queried
     * \param nrml_i Normal at point being queried
     * \param nrml_j Normal at point being queried
     * \param nrml_k Normal at point being queried
     * \param cvtr1_i First principal curvature at point being queried
     * \param cvtr1_j First principal curvature at point being queried
     * \param cvtr1_k First principal curvature at point being queried
     * \param cvtr2_i Second principal curvature at point being queried
     * \param cvtr2_j Second principal curvature at point being queried
     * \param cvtr2_k Second principal curvature at point being queried
     * \param *err Pointer to error type returned from function
     */
847
  void FBiGeom_getFcEvalXYZ( FBiGeom_Instance instance,
848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
                           iBase_EntityHandle face_handle,
                           double x,
                           double y,
                           double z,
                           double* on_x,
                           double* on_y,
                           double* on_z,
                           double* nrml_i,
                           double* nrml_j,
                           double* nrml_k,
                           double* cvtr1_i,
                           double* cvtr1_j,
                           double* cvtr1_k,
                           double* cvtr2_i,
                           double* cvtr2_j,
                           double* cvtr2_k,
                           int* err );

    /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
     *         entity(ies) at given position(s)
     *
     * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
     * at given position(s).  If either the number of entities or number of
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
875
     * \param instance FBiGeom instance handle
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891
     * \param edge_handles Edge(s) being queried
     * \param edge_handles_size Number of edges being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param on_coords Closest point array
     * \param on_coords_allocated Allocated size of closest point array
     * \param on_coords_size Occupied size of closest point array
     * \param tangent Tangent array
     * \param tangent_allocated Allocated size of tangent array
     * \param tangent_size Occupied size of tangent array
     * \param cvtr First principal curvatures
     * \param cvtr_allocated Allocated size of first curvature array
     * \param cvtr_size Occupied size of first curvature array
     * \param *err Pointer to error type returned from function
     */
892
  void FBiGeom_getArrEgEvalXYZ( FBiGeom_Instance instance,
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
                              iBase_EntityHandle const* edge_handles,
                              int edge_handles_size,
                              int storage_order,
                              double const* coords,
                              int coords_size,
                              double** on_coords,
                              int* on_coords_allocated,
                              int* on_coords_size,
                              double** tangent,
                              int* tangent_allocated,
                              int* tangent_size,
                              double** cvtr,
                              int* cvtr_allocated,
                              int* cvtr_size,
                              int* err );

    /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
     *         entity(ies) at given position(s)
     *
     * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
     * at given position(s).  If either the number of entities or number of
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
918
     * \param instance FBiGeom instance handle
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
     * \param edge_handles Edge(s) being queried
     * \param edge_handles_size Number of edges being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param on_coords Closest point array
     * \param on_coords_allocated Allocated size of closest point array
     * \param on_coords_size Occupied size of closest point array
     * \param normal Normal array
     * \param normal_allocated Allocated size of normal array
     * \param normal_size Occupied size of normal array
     * \param cvtr_1 First principal curvatures
     * \param cvtr_1_allocated Allocated size of first curvature array
     * \param cvtr_1_size Occupied size of first curvature array
     * \param cvtr_2 Second principal curvatures
     * \param cvtr_2_allocated Allocated size of second curvature array
     * \param cvtr_2_size Occupied size of second curvature array
     * \param *err Pointer to error type returned from function
     */
938
  void FBiGeom_getArrFcEvalXYZ( FBiGeom_Instance instance,
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              int storage_order,
                              double const* coords,
                              int coords_size,
                              double** on_coords,
                              int* on_coords_allocated,
                              int* on_coords_size,
                              double** normal,
                              int* normal_allocated,
                              int* normal_size,
                              double** cvtr1,
                              int* cvtr1_allocated,
                              int* cvtr1_size,
                              double** cvtr2,
                              int* cvtr2_allocated,
                              int* cvtr2_size,
                              int* err );

    /**\brief  Get the bounding box of the specified entity
     *
     * Get the bounding box of the specified entity
961
     * \param instance FBiGeom instance handle
962 963 964 965 966 967 968 969 970
     * \param entity_handle Entity being queried
     * \param min_x Minimum coordinate of bounding box 
     * \param min_y Minimum coordinate of bounding box 
     * \param min_z Minimum coordinate of bounding box 
     * \param max_x Maximum coordinate of bounding box 
     * \param max_y Maximum coordinate of bounding box 
     * \param max_z Maximum coordinate of bounding box 
     * \param *err Pointer to error type returned from function
     */
971
  void FBiGeom_getEntBoundBox( FBiGeom_Instance instance,
972 973 974 975 976 977 978 979 980 981 982 983 984
                             iBase_EntityHandle entity_handle,
                             double* min_x,
                             double* min_y,
                             double* min_z,
                             double* max_x,
                             double* max_y,
                             double* max_z,
                             int* err );

    /**\brief  Get the bounding box of the specified entities
     *
     * Get the bounding box of the specified entities.  Storage order passed in
     * should be a member of iBase_StorageOrder enum.
985
     * \param instance FBiGeom instance handle
986 987 988 989 990 991 992 993 994 995 996
     * \param entity_handles Entity handles being queried
     * \param enttiy_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates passed back
     * \param min_corner Minimum coordinates of bounding boxes
     * \param min_corner_allocated Allocated size of minimum coordinates array
     * \param min_corner_size Occupied size of minimum coordinates array
     * \param max_corner Maximum coordinates of bounding boxes
     * \param max_corner_allocated Allocated size of maximum coordinates array
     * \param max_corner_size Occupied size of maximum coordinates array
     * \param *err Pointer to error type returned from function
     */
997
  void FBiGeom_getArrBoundBox( FBiGeom_Instance instance,
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
                             iBase_EntityHandle const* entity_handles,
                             int entity_handles_size,
                             int storage_order,
                             double** min_corner,
                             int* min_corner_allocated,
                             int* min_corner_size,
                             double** max_corner,
                             int* max_corner_allocated,
                             int* max_corner_size,
                             int* err );

    /**\brief  Get coordinates of specified vertex
     *
     * Get coordinates of specified vertex.
1012
     * \param instance FBiGeom instance handle
1013 1014 1015 1016 1017 1018
     * \param vertex_handle Geom vertex being queried
     * \param *x Pointer to x coordinate returned from function
     * \param *y Pointer to y coordinate returned from function
     * \param *z Pointer to z coordinate returned from function
     * \param *err Pointer to error type returned from function
     */
1019
  void FBiGeom_getVtxCoord( FBiGeom_Instance instance,
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
                          iBase_EntityHandle vertex_handle,
                          double* x,
                          double* y,
                          double* z,
                          int* err );

    /**\brief  Get coordinates of specified vertices
     *
     * Get coordinates of specified vertices.  If storage order is passed in
     * with a value other than iBase_UNDETERMINED, coordinates are returned
     * in the specified storage order, otherwise storage order is that native
     * to the implementation.  Storage order of returned coordinates is also
     * returned.
1033
     * \param instance FBiGeom instance handle
1034 1035 1036 1037 1038 1039 1040 1041 1042
     * \param vertex_handles Array of geom vertex handles whose coordinates are
     *        being requested
     * \param vertex_handles_size Number of vertices in vertex_handles array
     * \param storage_order Storage order requested for coordinate data
     * \param *coords Pointer to array of coordinates returned from function
     * \param *coords_allocated Pointer to allocated size of coords array
     * \param *coords_size Pointer to occupied size of coords array
     * \param *err Pointer to error type returned from function
     */
1043
  void FBiGeom_getVtxArrCoords( FBiGeom_Instance instance,
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double** coordinates,
                              int* coordinates_allocated,
                              int* coordinates_size,
                              int* err );

    /**\brief  Intersect a ray with the model
     *
     * Intersect a ray with the model.  Storage orders passed in should be a
     * member of the iBase_StorageOrder enumeration.
1056
     * \param instance FBiGeom instance handle
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
     * \param x Point from which ray is fired
     * \param y Point from which ray is fired
     * \param z Point from which ray is fired
     * \param dir_x Direction in which ray is fired
     * \param dir_y Direction in which ray is fired
     * \param dir_z Direction in which ray is fired
     * \param intersect_entity_handles Entities intersected by ray
     * \param intersect_entity_handles_allocated Allocated size of
     *        intersections array
     * \param intersect_entity_hangles_size Occupied size of intersections array
     * \param storage_order Storage order of coordinates passed back
     * \param intersect_coords Coordinates of intersections
     * \param intersect_coords_allocated Allocated size of coordinates array
     * \param intersect_coords_size Occupied size of coordinates array
     * \param param_coords Distances along ray of intersections
     * \param param_coords_allocated Allocated size of param_coords array
     * \param param_coords_size Occupied size of param_coords array
     * \param *err Pointer to error type returned from function
     */
1076
  void FBiGeom_getPntRayIntsct( FBiGeom_Instance instance,
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
                              double x,
                              double y,
                              double z,
                              double dir_x,
                              double dir_y,
                              double dir_z,
                              iBase_EntityHandle** intersect_entity_handles,
                              int* intersect_entity_handles_allocated,
                              int* intersect_entity_hangles_size,
                              int storage_order,
                              double** intersect_coords,
                              int* intersect_coords_allocated,
                              int* intersect_coords_size,
                              double** param_coords,
                              int* param_coords_allocated,
                              int* param_coords_size,
                              int* err );

    /**\brief  Intersect an array of rays with the model
     *
     * Intersect an array of rays with the model.  Storage order passed in is
     * a member of the iBase_StorageOrder enumeration.
1099
     * \param instance FBiGeom instance handle
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
     * \param storage_order Storage order of input coordinates
     * \param coords Points from which rays are fired
     * \param coords_size Number of points from which rays are fired
     * \param directions Directions in which rays are fired
     * \param directions_size Number of coordinates in directions array
     * \param intersect_entity_handles Entities intersected by ray
     * \param intersect_entity_handles_allocated Allocated size of intersections
     *        array
     * \param intersect_entity_hangles_size Occupied size of intersections array
     * \param offset Offset[i] is offset into intersect_entity_handles of ith
     *        ray
     * \param offset_allocated Allocated size of offset array
     * \param offset_size Occupied size of offset array
     * \param storage_order Storage order of coordinates passed back
     * \param intersect_coords Coordinates of intersections
     * \param intersect_coords_allocated Allocated size of coordinates array
     * \param intersect_coords_size Occupied size of coordinates array
     * \param param_coords Distances along ray of intersections
     * \param param_coords_allocated Allocated size of param_coords array
     * \param param_coords_size Occupied size of param_coords array
     * \param *err Pointer to error type returned from function
     */
1122
  void FBiGeom_getPntArrRayIntsct( FBiGeom_Instance instance,
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
                                 int storage_order,
                                 const double* coords,
                                 int coords_size,
                                 const double* directions,
                                 int directions_size,
                                 iBase_EntityHandle** intersect_entity_handles,
                                 int* intersect_entity_handles_allocated,
                                 int* intersect_entity_hangles_size,
                                 int** offset,
                                 int* offset_allocated,
                                 int* offset_size,
                                 double** intersect_coords,
                                 int* intersect_coords_allocated,
                                 int* intersect_coords_size,
                                 double** param_coords,
                                 int* param_coords_allocated,
                                 int* param_coords_size,
                                 int* err );

    /**\brief  Get the entity on which a point is located
     *
     * Get the entity on which a point is located
1145
     * \param instance FBiGeom instance handle
1146 1147 1148 1149 1150 1151
     * \param x Point being queried
     * \param y Point being queried
     * \param z Point being queried
     * \param entity_handle Entity on which point is located
     * \param *err Pointer to error type returned from function
     */
1152
  void FBiGeom_getPntClsf( FBiGeom_Instance instance,
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
                         double x,
                         double y,
                         double z,
                         iBase_EntityHandle* entity_handle,
                         int* err );

    /**\brief  Get the entities on which points are located
     *
     * Get the entities on which points are located.  Storage orders should be
     * members of the iBase_StorageOrder enumeration.
1163
     * \param instance FBiGeom instance handle
1164 1165 1166 1167 1168 1169 1170 1171
     * \param storage_order Storage order of coordinates in coords
     * \param coords Points being queried
     * \param coords_size Number of entries in coords array
     * \param entity_handles Entities on which points are located
     * \param entity_handles_allocated Allocated size of entity_handles array
     * \param entity_handles_size Occupied size of entity_handles array
     * \param *err Pointer to error type returned from function
     */
1172
  void FBiGeom_getPntArrClsf( FBiGeom_Instance instance,
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
                            int storage_order,
                            double const* coords,
                            int coords_size,
                            iBase_EntityHandle** entity_handles,
                            int* entity_handles_allocated,
                            int* entity_handles_size,
                            int* err );

    /**\brief  Get the sense of a face with respect to a region
     *
     * Get the sense of a face with respect to a region.  Sense returned is -1,
     * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that face bounds the region once with each sense.
1186
     * \param instance FBiGeom instance handle
1187 1188 1189 1190 1191
     * \param face Face being queried
     * \param region Region being queried
     * \param sense_out Sense of face with respect to region
     * \param *err Pointer to error type returned from function
     */
1192
  void FBiGeom_getEntNrmlSense( FBiGeom_Instance instance,
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
                              iBase_EntityHandle face,
                              iBase_EntityHandle region,
                              int* sense_out,
                              int* err );

    /**\brief  Get the senses of an array of faces with respect to an array of
     *         regions
     *
     * Get the senses of an array of faces with respect to an array of regions.
     * Sense returned is -1, 0, or 1, representing "reversed", "both", or
     * "forward".  "both" sense indicates that face bounds the region once with
     * each sense.
1205
     * \param instance FBiGeom instance handle
1206 1207 1208 1209 1210 1211 1212 1213 1214
     * \param face_handles Faces being queried
     * \param face_handles_size Size of face handles array
     * \param region_handles Regions being queried
     * \param region_handles_size Size of region handles array
     * \param sense Senses of faces with respect to regions
     * \param sense_allocated Allocated size of senses array
     * \param sense_size Occupied size of senses array
     * \param *err Pointer to error type returned from function
     */
1215
  void FBiGeom_getArrNrmlSense( FBiGeom_Instance instance,
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              iBase_EntityHandle const* region_handles,
                              int region_handles_size,
                              int** sense,
                              int* sense_allocated,
                              int* sense_size,
                              int* err );

    /**\brief  Get the sense of an edge with respect to a face
     *
     * Get the sense of an edge with respect to a face.  Sense returned is -1,
     * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that edge bounds the face once with each sense.
1230
     * \param instance FBiGeom instance handle
1231 1232 1233 1234 1235
     * \param edge Edge being queried
     * \param face Face being queried
     * \param sense_out Sense of edge with respect to face
     * \param *err Pointer to error type returned from function
     */
1236
  void FBiGeom_getEgFcSense( FBiGeom_Instance,
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
                           iBase_EntityHandle edge,
                           iBase_EntityHandle face,
                           int* sense_out,
                           int* err );

    /**\brief  Get the senses of an array of edges with respect to an array of
     *         faces
     *
     * Get the senses of an array of edges with respect to an array of faces.
     * Sense returned is -1, 0, or 1, representing "reversed", "both", or
     * "forward".  "both" sense indicates that edge bounds the face once with
     * each sense.
1249
     * \param instance FBiGeom instance handle
1250 1251 1252 1253 1254 1255 1256 1257 1258
     * \param edge_handles Edges being queried
     * \param edge_handles_size Size of edge handles array
     * \param face_handles Faces being queried
     * \param face_handles_size Size of face handles array
     * \param sense Senses of faces with respect to regions
     * \param sense_allocated Allocated size of senses array
     * \param sense_size Occupied size of senses array
     * \param *err Pointer to error type returned from function
     */
1259
  void FBiGeom_getEgFcArrSense( FBiGeom_Instance instance,
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
                              iBase_EntityHandle const* edge_handles,
                              int edge_handles_size,
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              int** sense,
                              int* sense_allocated,
                              int* sense_size,
                              int* err );

    /**\brief  Get the sense of a vertex pair with respect to an edge
     *
     * Get the sense of a vertex pair with respect to an edge.  Sense returned
     * is -1, 0, or 1, representing "reversed", "both", or "forward".  "both"
     * sense indicates that vertices are identical and that vertex bounds both
     * sides of the edge.
1275
     * \param instance FBiGeom instance handle
1276 1277 1278 1279 1280 1281
     * \param edge Edge being queried
     * \param vertex1 First vertex being queried
     * \param vertex2 Second vertex being queried
     * \param sense_out Sense of vertex pair with respect to edge
     * \param *err Pointer to error type returned from function
     */
1282
  void FBiGeom_getEgVtxSense( FBiGeom_Instance instance,
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
                            iBase_EntityHandle edge,
                            iBase_EntityHandle vertex1,
                            iBase_EntityHandle vertex2,
                            int* sense_out,
                            int* err );

    /**\brief  Get the senses of vertex pair with respect to a edges
     *
     * Get the senses of vertex pairs with respect to edges.  Sense returned is
     * -1, 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that both vertices in pair are identical and that vertex bounds
     * both sides of the edge.
1295
     * \param instance FBiGeom instance handle
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param vertex_handles_1 First vertex being queried
     * \param vertex_handles_1_size Number of vertices in vertices array
     * \param vertex_handles_2 Second vertex being queried
     * \param vertex_handles_2_size Number of vertices in vertices array
     * \param sense Sense of vertex pair with respect to edge
     * \param sense_allocated Allocated size of sense array
     * \param sense_size Occupied size of sense array
     * \param *err Pointer to error type returned from function
     */
1307
  void FBiGeom_getEgVtxArrSense( FBiGeom_Instance instance,
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
                               iBase_EntityHandle const* edge_handles,
                               int edge_handles_size,
                               iBase_EntityHandle const* vertex_handles_1,
                               int veretx_handles_1_size,
                               iBase_EntityHandle const* vertex_handles_2,
                               int vertex_handles_2_size,
                               int** sense,
                               int* sense_allocated,
                               int* sense_size,
                               int* err );

    /**\brief  Return the measure (length, area, or volume) of entities
     *
     * Return the measure (length, area, or volume) of entities
1322
     * \param instance FBiGeom instance handle
1323 1324 1325 1326 1327 1328 1329
     * \param entity_handles Array of entities being queried
     * \param entity_handles_size Number of entities in entity array
     * \param measures Measures of entities being queried
     * \param measures_allocated Allocated size of measures array
     * \param measures_size Occupied size of measures array
     * \param *err Pointer to error type returned from function
     */
1330
  void FBiGeom_measure( FBiGeom_Instance instance,
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
                      iBase_EntityHandle const* entity_handles,
                      int entity_handles_size,
                      double** measures,
                      int* measures_allocated,
                      int* measures_size,
                      int* err );

    /**\brief  Get the geometric type of a face
     *
     * Get the geometric type of a face.  Specific types depend on
     * implementation.
1342
     * \param instance FBiGeom instance handle
1343 1344 1345 1346
     * \param face_handle Face being queried
     * \param face_type Face type
     * \param face_type_length Length of face type string
     */
1347
  void FBiGeom_getFaceType( FBiGeom_Instance instance,
1348 1349 1350 1351 1352 1353 1354 1355 1356
                          iBase_EntityHandle face_handle,
                          char* face_type,
                          int* err,
                          int* face_type_length);

    /**\brief  Return whether interface has information about parameterization
     *
     * Return whether an interface has information about parameterization (!=0)
     * or not (0)
1357
     * \param instance FBiGeom instance handle
1358 1359 1360 1361
     * \param is_parametric If non-zero, interface has information about
     *        parameterization
     * \param *err Pointer to error type returned from function
     */
1362
  void FBiGeom_getParametric( FBiGeom_Instance instance,
1363 1364 1365 1366 1367 1368
                            int* is_parametric,
                            int* err );

    /**\brief  Return whether an entity has a parameterization
     *
     * Return whether an entity has a parameterization (=1) or not (=0)
1369
     * \param instance FBiGeom instance handle
1370 1371 1372 1373
     * \param entity_handle Entity being queried
     * \param is_parametric Entity has a parameterization (=1) or not (=0)
     * \param *err Pointer to error type returned from function
     */
1374
  void FBiGeom_isEntParametric( FBiGeom_Instance instance,
1375 1376 1377 1378 1379 1380 1381
                              iBase_EntityHandle entity_handle,
                              int* parametric,
                              int* err );

    /**\brief  Return whether entities have parameterizations
     *
     * Return whether entities have parameterizations (=1) or not (=0)
1382
     * \param instance FBiGeom instance handle
1383 1384 1385 1386 1387