FBiGeom.h 189 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 1388 1389 1390
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param is_parametric entity_handles[i] has a parameterization (=1) or
     *        not (=0)
     * \param is_parametric_allocated Allocated size of is_parametric array
     * \param is_parametric_size Occupied size of is_parametric array
     * \param *err Pointer to error type returned from function
     */
1391
  void FBiGeom_isArrParametric( FBiGeom_Instance instance,
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int** is_parametric,
                              int* is_parametric_allocated,
                              int* is_parametric_size,
                              int* err );

    /**\brief  Return coordinate position at specified parametric position on
     *         entity
     *
     * Return coordinate position at specified parametric position on entity.
1403
     * \param instance FBiGeom instance handle
1404 1405 1406 1407 1408 1409 1410 1411
     * \param entity_handle Entity being queried
     * \param u Parametric coordinate being queried
     * \param v Parametric coordinate being queried
     * \param x Spatial coordinate at parametric position being queried
     * \param y Spatial coordinate at parametric position being queried
     * \param z Spatial coordinate at parametric position being queried
     * \param *err Pointer to error type returned from function
     */
1412
  void FBiGeom_getEntUVtoXYZ( FBiGeom_Instance instance,
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
                            iBase_EntityHandle entity_handle,
                            double u,
                            double v,
                            double* x,
                            double* y,
                            double* z,
                            int* err );

    /**\brief  Return coordinate positions at specified parametric position(s)
     *         on entity(ies)
     *
     * Return coordinate positions at specified parametric position(s) on
     * entity(ies).  If either the number of entities or number of parametric
     * coordinate pairs 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.
1430
     * \param instance FBiGeom instance handle
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of uv coordinates input and xyz
     *        coordinate output
     * \param uv Coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param coordinates Coordinates of parametric positions
     * \param coordinates_allocated Allocated size of coordinates array
     * \param coordinates_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
1442
  void FBiGeom_getArrUVtoXYZ( FBiGeom_Instance instance,
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* uv,
                            int uv_size,
                            double** coordinates,
                            int* coordinates_allocated,
                            int* coordinates_size,
                            int* err );

    /**\brief  Return coordinate position at specified parametric position on
     *         entity
     *
     * Return coordinate position at specified parametric position on entity.
1457
     * \param instance FBiGeom instance handle
1458 1459 1460 1461 1462 1463 1464
     * \param entity_handle Entity being queried
     * \param u Parametric coordinate being queried
     * \param x Spatial coordinate at parametric position being queried
     * \param y Spatial coordinate at parametric position being queried
     * \param z Spatial coordinate at parametric position being queried
     * \param *err Pointer to error type returned from function
     */
1465
  void FBiGeom_getEntUtoXYZ( FBiGeom_Instance instance,
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
                           iBase_EntityHandle entity_handle,
                           double u,
                           double* x, 
                           double* y,
                           double* z,
                           int* err );

    /**\brief  Return coordinate positions at specified parametric position(s)
     *         on entity(ies)
     *
     * Return coordinate positions at specified parametric position(s) on
     * entity(ies). If either the number of entities or number of parametric
     * coordinate pairs 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.
1482
     * \param instance FBiGeom instance handle
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of resulting coordinates
     * \param uv Coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param coordinates Coordinates of parametric positions
     * \param coordinates_allocated Allocated size of coordinates array
     * \param coordinates_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
1493
  void FBiGeom_getArrUtoXYZ( FBiGeom_Instance instance,
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           double const* u,
                           int u_size,
                           int storage_order,
                           double** on_coords,
                           int* on_coords_allocated,
                           int* on_coords_size,
                           int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity
     *
     * Return parametric position at specified spatial position on entity
1508
     * \param instance FBiGeom instance handle
1509 1510 1511 1512 1513 1514 1515 1516
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param v Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
1517
  void FBiGeom_getEntXYZtoUV( FBiGeom_Instance instance,
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* u,
                            double* v, 
                            int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity
     *
     * Return parametric position at specified spatial position on entity
1530
     * \param instance FBiGeom instance handle
1531 1532 1533 1534 1535 1536 1537
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
1538
  void FBiGeom_getEntXYZtoU( FBiGeom_Instance instance,
1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
                           iBase_EntityHandle entity_handle,
                           double x,
                           double y,
                           double z,
                           double* u,
                           int* err );

    /**\brief  Return parametric positions at specified spatial position(s) on
     *         entity(ies)
     * Return parametric positions at specified spatial position(s) on
     * entity(ies).  If either the number of entities or number of spatial
     * 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.
1554
     * \param instance FBiGeom instance handle
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param uv Coordinates of parametric positions
     * \param uv_allocated Allocated size of coordinates array
     * \param uv_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
1565
  void FBiGeom_getArrXYZtoUV( FBiGeom_Instance instance,
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** uv,
                            int* uv_allocated,
                            int* uv_size,
                            int* err );

    /**\brief  Return spatial positions at specified parametric position(s) on
     *         entity(ies)
     *
     * Return spatial positions at specified parametric position(s) on
     * entity(ies). If either the number of entities or number of spatial
     * 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.
1585
     * \param instance FBiGeom instance handle
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param u Coordinates of parametric positions
     * \param u_allocated Allocated size of coordinates array
     * \param u_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
1596
  void FBiGeom_getArrXYZtoU( FBiGeom_Instance instance,
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           int storage_order,
                           double const* coordinates,
                           int coordinates_size,
                           double** u,
                           int* u_allocated,
                           int* u_size,
                           int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity, based on parametric position hint
     *
     * Return parametric position at specified spatial position on entity,
     * based on parametric position hint.  For this function, u and v are input
     * with parameters from which to start search. Typically this will reduce
     * the search time for new parametric coordinates.
1614
     * \param instance FBiGeom instance handle
1615 1616 1617 1618 1619 1620 1621 1622
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param v Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
1623
  void FBiGeom_getEntXYZtoUVHint( FBiGeom_Instance instance,
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
                                iBase_EntityHandle entity_handle,
                                double x,
                                double y,
                                double z,
                                double* u,
                                double* v,
                                int* err );

    /**\brief  Return parametric positions at specified spatial position(s) on
     *         entity(ies), based on parametric position hints
     * Return parametric positions at specified spatial position(s) on
     * entity(ies), based on parametric position hints.  If either the number of
     * entities or number of spatial 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.
1640
     * \param instance FBiGeom instance handle
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param uv Coordinates of parametric positions
     * \param uv_allocated Allocated size of coordinates array
     * \param uv_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
1651
  void FBiGeom_getArrXYZtoUVHint( FBiGeom_Instance instance,
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
                                iBase_EntityHandle const* entity_handles,
                                int entity_handles_size,
                                int storage_order,
                                double const* coords,
                                int coords_size,
                                double** uv,
                                int* uv_allocated,
                                int* uv_size,
                                int* err );

    /**\brief  Get parametric range of entity
     *
     * Get parametric range of entity
1665
     * \param instance FBiGeom instance handle
1666 1667 1668 1669 1670 1671 1672
     * \param entity_handle Entity being queried
     * \param u_min Minimum parametric coordinate for entity
     * \param v_min Minimum parametric coordinate for entity
     * \param u_max Maximum parametric coordinate for entity
     * \param v_max Maximum parametric coordinate for entity
     * \param *err Pointer to error type returned from function
     */
1673
  void FBiGeom_getEntUVRange( FBiGeom_Instance instance,
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
                            iBase_EntityHandle entity_handle,
                            double* u_min,
                            double* v_min,
                            double* u_max,
                            double* v_max,
                            int* err );

    /**\brief  Get parametric range of entity
     *
     * Get parametric range of entity
1684
     * \param instance FBiGeom instance handle
1685 1686 1687 1688 1689
     * \param entity_handle Entity being queried
     * \param u_min Minimum parametric coordinate for entity
     * \param u_max Maximum parametric coordinate for entity
     * \param *err Pointer to error type returned from function
     */
1690
  void FBiGeom_getEntURange( FBiGeom_Instance instance,
1691 1692 1693 1694 1695 1696 1697 1698
                           iBase_EntityHandle entity_handle,
                           double* u_min,
                           double* u_max,
                           int* err );

    /**\brief  Get parametric range of entities
     *
     * Get parametric range of entities
1699
     * \param instance FBiGeom instance handle
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of parametric coordinates being
     *        returned
     * \param uv_min Minimum parametric coordinate for entities
     * \param uv_min_allocated Allocated size of minimum parametric coordinate
     *        array
     * \param uv_min_size Occupied size of minimum parametric coordinate array
     * \param uv_max Maximum parametric coordinate for entities
     * \param uv_max_allocated Allocated size of maximum parametric coordinate
     *        array
     * \param uv_max_size Occupied size of maximum parametric coordinate array
     * \param *err Pointer to error type returned from function
     */
1714
  void FBiGeom_getArrUVRange( FBiGeom_Instance instance,
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double** uv_min,
                            int* uv_min_allocated,
                            int* uv_min_size,
                            double** uv_max,
                            int* uv_max_allocated,
                            int* uv_max_size,
                            int* err );

    /**\brief  Get parametric range of entities
     *
     * Get parametric range of entities
1729
     * \param instance FBiGeom instance handle
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of parametric coordinates being
     *        returned
     * \param u_min Minimum parametric coordinate for entities
     * \param u_min_allocated Allocated size of minimum parametric coordinate
     *        array
     * \param u_min_size Occupied size of minimum parametric coordinate array
     * \param u_max Maximum parametric coordinate for entities
     * \param u_max_allocated Allocated size of maximum parametric coordinate
     *        array
     * \param u_max_size Occupied size of maximum parametric coordinate array
     * \param *err Pointer to error type returned from function
     */
1744
  void FBiGeom_getArrURange( FBiGeom_Instance instance,
1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           double** u_min,
                           int* u_min_allocated,
                           int* u_min_size,
                           double** u_max,
                           int* u_max_allocated,
                           int* u_max_size,
                           int* err );

    /**\brief  Return the face parametric coordinates for a parametric position
     *         on a bounding edge
     *
     * Return the face parametric coordinates for a parametric position on a
     * bounding edge
1760
     * \param instance FBiGeom instance handle
1761 1762 1763 1764 1765 1766 1767
     * \param edge_handle Edge being queried
     * \param face_handle Face being queried
     * \param in_u Parametric position on edge
     * \param u Corresponding parametric position on face
     * \param v Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
1768
  void FBiGeom_getEntUtoUV( FBiGeom_Instance instance,
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
                          iBase_EntityHandle edge_handle,
                          iBase_EntityHandle face_handle,
                          double in_u,
                          double* u,
                          double* v,
                          int* err );

    /**\brief  Return parametric coordinates on face of vertex position
     *
     * Return parametric coordinates on face of vertex position
1779
     * \param instance FBiGeom instance handle
1780 1781 1782 1783 1784 1785
     * \param vertex_handle Vertex being queried
     * \param face_handle Face being queried
     * \param u Corresponding parametric position on face
     * \param v Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
1786
  void FBiGeom_getVtxToUV( FBiGeom_Instance instance,
1787 1788 1789 1790 1791 1792 1793 1794 1795
                         iBase_EntityHandle vertex_handle,
                         iBase_EntityHandle face_handle,
                         double* u,
                         double* v,
                         int* err );

    /**\brief  Return parametric coordinates on edge of vertex position
     *
     * Return parametric coordinates on edge of vertex position
1796
     * \param instance FBiGeom instance handle
1797 1798 1799 1800 1801
     * \param vertex_handle Vertex being queried
     * \param edge_handle Edge being queried
     * \param u Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
1802
  void FBiGeom_getVtxToU( FBiGeom_Instance instance,
1803 1804 1805 1806 1807 1808 1809 1810 1811 1812
                        iBase_EntityHandle vertex_handle,
                        iBase_EntityHandle edge_handle,
                        double* u,
                        int* err );

    /**\brief  Return the face parametric coordinates for a parametric position
     *         on bounding edges
     *
     * Return the face parametric coordinates for a parametric position on
     * bounding edges
1813
     * \param instance FBiGeom instance handle
1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param face_handles Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param u_in Parametric positions on edges
     * \param u_in_size Number of parametric positions on edges
     * \param storage_order Storage order of coordinates returned
     * \param uv Corresponding parametric positions on faces
     * \param uv_allocated Allocated size of parameter array
     * \param uv_size Occupied size of parameter array
     * \param *err Pointer to error type returned from function
     */
1826
  void FBiGeom_getArrUtoUV( FBiGeom_Instance instance,
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
                          iBase_EntityHandle const* edge_handles,
                          int edge_handles_size,
                          iBase_EntityHandle const* face_handles,
                          int face_handles_size,
                          double const* u_in,
                          int u_in_size,
                          int storage_order,
                          double** uv,
                          int* uv_allocated,
                          int* uv_size,
                          int* err );

    /**\brief  Return parametric coordinates on faces of vertex positions
     *
     * Return parametric coordinates on faces of vertex positions
1842
     * \param instance FBiGeom instance handle
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852
     * \param vertex_handles Vertices being queried
     * \param vertex_handles_size Number of vertices being queried
     * \param face_handles Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates returned
     * \param uv Corresponding parametric positions on faces
     * \param uv_allocated Allocated size of positions array
     * \param uv_size Occupied size of positions array
     * \param *err Pointer to error type returned from function
     */
1853
  void FBiGeom_getVtxArrToUV( FBiGeom_Instance instance,
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866
                            iBase_EntityHandle const* vertex_handles,
                            int vertex_handles_size,
                            iBase_EntityHandle const* face_handles,
                            int face_handles_size,
                            int storage_order,
                            double** uv,
                            int* uv_allocated,
                            int* uv_size,
                            int* err );

    /**\brief  Return parametric coordinates on edges of vertex positions
     *
     * Return parametric coordinates on edges of vertex positions
1867
     * \param instance FBiGeom instance handle
1868 1869 1870 1871 1872 1873 1874 1875 1876
     * \param vertex_handles Vertices being queried
     * \param vertex_handles_size Number of vertices being queried
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param u Corresponding parametric positions on faces
     * \param u_allocated Allocated size of positions array
     * \param u_size Occupied size of positions array
     * \param *err Pointer to error type returned from function
     */
1877
  void FBiGeom_getVtxArrToU( FBiGeom_Instance instance,
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
                           iBase_EntityHandle const* vertex_handles,
                           int vertex_handles_size,
                           iBase_EntityHandle const* edge_handles,
                           int edge_handles_size,
                           double** u,
                           int* u_allocated,
                           int* u_size,
                           int* err );

    /**\brief  Return the normal at a specified parametric position
     *
     * Return the normal at a specified parametric position
1890
     * \param instance FBiGeom instance handle
1891 1892 1893 1894 1895 1896 1897 1898
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param nrml_i Normal at specified position
     * \param nrml_j Normal at specified position
     * \param nrml_k Normal at specified position
     * \param *err Pointer to error type returned from functino
     */
1899
  void FBiGeom_getEntNrmlUV( FBiGeom_Instance instance,
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
                           iBase_EntityHandle entity_handle,
                           double u,
                           double v,
                           double* nrml_i,
                           double* nrml_j,
                           double* nrml_k,
                           int* err );

    /**\brief  Return the normals at specified parametric positions
     *
     * Return the normals at specified parametric positions.  If either the
     * number of entities or number of spatial coordinate pairs 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.
1915
     * \param instance FBiGeom instance handle
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
     * \param face_handle Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates input and output
     * \param parameters Parametric coordinates being queried
     * \param parameters_size Number of coordinates in array
     * \param normals Coordinates of normals at specified positions
     * \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
     */
1926
  void FBiGeom_getArrNrmlUV( FBiGeom_Instance instance,
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
                           iBase_EntityHandle const* face_handles,
                           int face_handles_size,
                           int storage_order,
                           double const* parameters,
                           int parameters_size,
                           double** normals,
                           int* normals_allocated,
                           int* normals_size,
                           int* err );

    /**\brief  Return the tangent at a specified parametric position
     *
     * Return the tangent at a specified parametric position
1940
     * \param instance FBiGeom instance handle
1941 1942 1943 1944 1945 1946 1947
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param tgnt_i Tangent at specified position
     * \param tgnt_j Tangent at specified position
     * \param tgnt_k Tangent at specified position
     * \param *err Pointer to error type returned from function
     */
1948
  void FBiGeom_getEntTgntU( FBiGeom_Instance instance,
1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
                          iBase_EntityHandle entity_handle,
                          double u,
                          double* tgnt_i,
                          double* tgnt_j,
                          double* tgnt_k,
                          int* err );

    /**\brief  Return the tangents at specified parametric positions
     *
     * Return the tangents at specified parametric positions.  If either the
     * number of entities or number of spatial coordinates 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.
1963
     * \param instance FBiGeom instance handle
1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
     * \param edge_handle Edges being queried
     * \param edge_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates output
     * \param parameters Parametric coordinates being queried
     * \param parameters_size Number of coordinates in array
     * \param tangents Coordinates of tangents at specified positions
     * \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
     */
1974
  void FBiGeom_getArrTgntU( FBiGeom_Instance instance,
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
                          iBase_EntityHandle const* edge_handles,
                          int edge_handles_size,
                          int storage_order,
                          double const* parameters,
                          int parameters_size,
                          double** tangents,
                          int* tangents_allocated,
                          int* tangents_size,
                          int* err );

    /**\brief  Get the first derivative of a face at specified parametric
     *         position
     *
     * Get the first derivative of a face at specified parametric position.
1989
     * \param instance FBiGeom instance handle
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param dvrt_u Pointer to coordinates of derivative with respect to u at
     *        specified position returned from function
     * \param dvrt_u_allocated Allocated size of dvrt_u array
     * \param dvrt_u_size Occupied size of dvrt_u array
     * \param dvrt_v Pointer to coordinates of derivative with respect to v at
     *        specified position returned from function
     * \param dvrt_v_allocated Allocated size of dvrt_v array
     * \param dvrt_v_size Occupied size of dvrt_v array
     * \param *err Pointer to error type returned from function
     */
2003
  void FBiGeom_getEnt1stDrvt( FBiGeom_Instance instance,
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
                            iBase_EntityHandle entity_handle,
                            double u,
                            double v,
                            double** drvt_u,
                            int* drvt_u_allocated,
                            int* drvt_u_size,
                            double** drvt_v,
                            int* dvrt_v_allocated,
                            int* dvrt_v_size,
                            int* err );

    /**\brief  Get the first derivatives of faces at specified parametric
     *         positions
     *
     * Get the first derivatives of faces at specified parametric positions.
     * storage_order should be a value in the iBase_StorageOrder enum.
2020
     * \param instance FBiGeom instance handle
2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036