meshkit-docs/html/FBiGeom_8hpp_source.html

00001 #ifndef MESHKIT_ITAPS_FBGEOM_HPP
00002 #define MESHKIT_ITAPS_FBGEOM_HPP
00003
00007 #include "FBiGeom.h"
00008 #include "iGeom.hpp"
00009 #include "iRel.hpp"
00010
00028 class FBiGeom : public iGeom {
00029         protected:
00030                 FBiGeom_Instance mInstance;
00031         public:
00032         virtual inline iRel::IfaceType iface_type() const {
00033             return iRel::FBIGEOM_IFACE;
00034         }
00035
00036                 typedef iBase_EntitySetHandle EntitySetHandle;
00037                 typedef iBase_EntityHandle EntityHandle;
00038                 typedef iBase_TagHandle TagHandle;
00039                 typedef iBase_ErrorType Error;
00040                 typedef iBase_EntityType EntityType;
00041                 typedef iBase_StorageOrder StorageOrder;
00042                 typedef iBase_TagValueType TagValueType;
00043
00044                 inline FBiGeom(const char* options = 0);
00045                 inline FBiGeom(FBiGeom_Instance instance);
00046
00047                 inline FBiGeom(bool meshBased);
00048
00049                 virtual inline ~FBiGeom();
00050
00051                 virtual inline Error load(const char* file_name, const char* options = 0);
00052
00053                 virtual inline Error save(const char* file_name, const char* options = 0);
00054
00055                 virtual inline Error getBoundBox(double& min_x, double& min_y, double& min_z,
00056                                 double& max_x, double& max_y, double& max_z) const;
00057
00058                 virtual inline int getParametric();
00059
00060                 virtual inline Error getNumOfType(EntitySetHandle set, EntityType type,
00061                                 int& count_out) const;
00062
00063                 virtual inline Error getEntities(EntitySetHandle set, EntityType type,
00064                                 std::vector<EntityHandle>& entities_out) const;
00065
00066                 virtual inline Error getEntType(EntityHandle handle, EntityType& type_out) const;
00067
00068                 virtual inline Error getArrType(const EntityHandle* entity_handles,
00069                                 int entity_handles_Size, EntityType* types_out) const;
00070
00071                 virtual inline Error getEntAdj(EntityHandle handle,
00072                                 EntityType type_requested, std::vector<EntityHandle>& adj_entities_out) const;
00073
00074                 virtual inline Error getArrAdj(const EntityHandle* entity_handles,
00075                                 int entity_handles_size, EntityType type_requested, std::vector<
00076                                 EntityHandle>& adjacent_entity_handles_out, int* offsets_out) const;
00077
00078                 virtual inline Error getEnt2ndAdj(EntityHandle handle,
00079                                 EntityType bridge_dimension, EntityType type_requested, std::vector<
00080                                 EntityHandle>& adj_entities_out) const;
00081
00082                 virtual inline Error getArr2ndAdj(const EntityHandle* entity_handles,
00083                                 int entity_handles_size, EntityType order_adjacent_key,
00084                                 EntityType type_requested,
00085                                 std::vector<EntityHandle>& adjacent_entity_handles_out, int* offsets_out) const;
00086
00087                 virtual inline Error isEntAdj(EntityHandle entity1, EntityHandle entity2,
00088                                 bool& adjacent_out) const;
00089
00090                 virtual inline Error isArrAdj(const EntityHandle* entities1,
00091                                 const EntityHandle* entities2, int num_entity_pairs, int* is_adj_out) const;
00092
00093                 virtual inline Error getEntClosestPt(EntityHandle entity, double near_x,
00094                                 double near_y, double near_z, double& on_x, double& on_y, double& on_z) const;
00095
00096                 virtual inline Error getEntClosestPtTrimmed(EntityHandle entity, double near_x,
00097                                 double near_y, double near_z, double& on_x, double& on_y, double& on_z) const;
00098
00099                 virtual inline Error getArrClosestPt(const EntityHandle* handles,
00100                                 int handles_size, StorageOrder order, const double* near_coordinates,
00101                                 int near_coordinates_size, double* on_coordinates) const;
00102
00103                 virtual inline Error getEntNrmlXYZ(EntityHandle entity, double x, double y,
00104                                 double z, double& i, double& j, double& k) const;
00105
00106                 virtual inline Error getArrNrmlXYZ(const EntityHandle* entities,
00107                                 int entities_size, StorageOrder order, const double* xyz, int xyz_size,
00108                                 double* ijk) const;
00109
00110                 virtual inline Error getEntNrmlPlXYZ(EntityHandle entity, double x, double y,
00111                                 double z, double& on_x, double& on_y, double& on_z, double& i, double& j,
00112                                 double& k) const;
00113
00114                 virtual inline Error getArrNrmlPlXYZ(const EntityHandle* entities,
00115                                 int entities_size, StorageOrder order, const double* near_xyz,
00116                                 int near_xyz_size, double* on_xyz, double* nrml_ijk) const;
00117
00118                 virtual inline Error getEntTgntXYZ(EntityHandle entity, double x, double y,
00119                                 double z, double& i, double& j, double& k) const;
00120
00121                 virtual inline Error getArrTgntXYZ(const EntityHandle* entities,
00122                                 int entities_size, StorageOrder order, const double* xyz, int xyz_size,
00123                                 double* ijk) const;
00124
00125                 virtual inline Error getFcCvtrXYZ(EntityHandle face, double x, double y,
00126                                 double z, double& i1, double& j1, double& k1, double& i2, double& j2,
00127                                 double& k2) const;
00128
00129                 virtual inline Error getEgCvtrXYZ(EntityHandle edge, double x, double y,
00130                                 double z, double& i, double& j, double& k) const;
00131
00132                 virtual inline Error getEntArrCvtrXYZ(const EntityHandle* entities,
00133                                 int entities_size, StorageOrder order, const double* xyz, int xyz_size,
00134                                 double* cvtr_1, double* cvtr_2) const;
00135
00136                 virtual inline Error getEgEvalXYZ(EntityHandle edge, double x, double y,
00137                                 double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
00138                                 double& tngt_j, double& tngt_k, double& cvtr_i, double& cvtr_j,
00139                                 double& cvtr_k) const;
00140
00141                 virtual inline Error getFcEvalXYZ(EntityHandle face, double x, double y,
00142                                 double z, double& on_x, double& on_y, double& on_z, double& nrml_i,
00143                                 double& nrml_j, double& nrml_k, double& cvtr1_i, double& cvtr1_j,
00144                                 double& cvtr1_k, double& cvtr2_i, double& cvtr2_j, double& cvtr2_k) const;
00145
00146                 virtual inline Error getArrEgEvalXYZ(const EntityHandle* edges,
00147                                 int edges_size, StorageOrder order, const double* near_coords,
00148                                 int near_coords_size, double* on_coords, double* tangent,
00149                                 double* curvature) const;
00150
00151                 virtual inline Error getArrFcEvalXYZ(const EntityHandle* faces,
00152                                 int faces_size, StorageOrder order, const double* near_coords,
00153                                 int near_coords_size, double* on_coords, double* normal,
00154                                 double* curvature1, double* curvature2) const;
00155
00156                 virtual inline Error
00157                         getEntBoundBox(EntityHandle entity, double& min_x, double& min_y,
00158                                         double& min_z, double& max_x, double& max_y, double& max_z) const;
00159
00160                 virtual inline Error getArrBoundBox(const EntityHandle* entities,
00161                                 int entities_size, StorageOrder order, double* min_corners,
00162                                 double* max_corners) const;
00163
00164                 virtual inline Error getVtxCoord(EntityHandle vertex, double& x, double& y,
00165                                 double& z) const;
00166
00167                 virtual inline Error getVtxArrCoords(const EntityHandle* vertices,
00168                                 int vertices_size, StorageOrder order, double* coords) const;
00169
00170                 virtual inline Error getPntRayIntsct(double x, double y, double z, double i,
00171                                 double j, double k, StorageOrder order,
00172                                 std::vector<EntityHandle>& entities_out, std::vector<double>& points_out,
00173                                 std::vector<double>& params_out) const;
00174
00175                 virtual inline Error getPntClsf(double x, double y, double z,
00176                                 EntityHandle& handle_out)const;
00177
00178                 virtual inline Error getPntArrClsf(StorageOrder order, const double* coords,
00179                                 int coords_size, EntityHandle* entities_out) const;
00180
00181                 virtual inline Error getEntNrmlSense(EntityHandle face, EntityHandle region,
00182                                 int& sense) const;
00183
00184                 virtual inline Error getEgFcSense(EntityHandle edge, EntityHandle face,
00185                                 int& sense) const;
00186
00187                 virtual inline Error getEgVtxSense(EntityHandle edge, EntityHandle vtx1,
00188                                 EntityHandle vtx2, int& sense) const;
00189
00190                 virtual inline Error getArrNrmlSense(const EntityHandle* faces,
00191                                 int faces_size, const EntityHandle* vols, int vols_size, int* senses_out)const;
00192
00193                 virtual inline Error getEgFcArrSense(const EntityHandle* edges,
00194                                 int edges_size, const EntityHandle* faces, int faces_size,
00195                                 int* senses_out) const;
00196
00197                 virtual inline Error getEgVtxArrSense(const EntityHandle* edges,
00198                                 int edges_size, const EntityHandle* vertices1, int vertices1_size,
00199                                 const EntityHandle* vertices2, int vertices2_size, int* senses_out) const;
00200
00201                 virtual inline Error getSense(EntityHandle ent, EntityHandle wrt_ent,
00202                                 int &sense) const;
00203
00204                 virtual inline Error getArrSense(const EntityHandle *ent, int num_ents,
00205                                 EntityHandle wrt_ent, int *sense) const;
00206
00207                 virtual inline Error measure(const EntityHandle* entities, int entities_size,
00208                                 double* measures) const;
00209
00210                 virtual inline Error getFaceType(EntityHandle face, std::string& type) const;
00211
00212                 virtual inline Error isEntParametric(EntityHandle entity, bool& parametric) const;
00213
00214                 virtual inline Error isArrParametric(const EntityHandle* entities,
00215                                 int entities_size, int* is_parametric) const;
00216
00217                 virtual inline Error getEntUVtoXYZ(EntityHandle face, double u, double v,
00218                                 double& x, double& y, double& z) const;
00219
00220                 virtual inline Error getEntUtoXYZ(EntityHandle edge, double u, double& x,
00221                                 double& y, double& z) const;
00222
00223                 virtual inline Error getArrUVtoXYZ(const EntityHandle* faces, int faces_size,
00224                                 StorageOrder order, const double* uv, int uv_size, double* xyz) const;
00225
00226                 virtual inline Error getArrUtoXYZ(const EntityHandle* edges, int edges_size,
00227                                 const double* u, int u_size, StorageOrder order, double* xyz) const;
00228
00229                 virtual inline Error getEntXYZtoUV(EntityHandle face, double x, double y,
00230                                 double z, double& u, double& v) const;
00231
00232                 virtual inline Error getEntXYZtoU(EntityHandle edge, double x, double y,
00233                                 double z, double& u) const;
00234
00235                 virtual inline Error getArrXYZtoUV(const EntityHandle* faces, int faces_size,
00236                                 StorageOrder order, const double* coords, int coords_size, double* uv) const;
00237
00238                 virtual inline Error getArrXYZtoU(const EntityHandle* edges, int edges_size,
00239                                 StorageOrder order, const double* coords, int coords_size, double* u) const;
00240
00241                 virtual inline Error getEntXYZtoUVHint(EntityHandle face, double x, double y,
00242                                 double z, double& u, double& v) const;
00243
00244                 virtual inline Error getArrXYZtoUVHint(const EntityHandle* faces,
00245                                 int faces_size, StorageOrder order, const double* coords,
00246                                 int coords_size, double* uv) const;
00247
00248                 virtual inline Error getEntNrmlUV(EntityHandle face, double u, double v,
00249                                 double& i, double& j, double& k) const;
00250
00251                 virtual inline Error getArrNrmlUV(const EntityHandle* faces, int faces_size,
00252                                 StorageOrder order, const double* uv, int uv_size, double* normals) const;
00253
00254                 virtual inline Error getEntTgntU(EntityHandle edge, double u, double& i,
00255                                 double& j, double& k) const;
00256
00257                 virtual inline Error getArrTgntU(const EntityHandle* edges, int edges_size,
00258                                 StorageOrder order, const double* u, int u_size, double* normals) const;
00259
00260                 virtual inline Error getEnt1stDrvt(EntityHandle handle, double u, double v,
00261                                 double& du_i, double& du_j, double& du_k, double& dv_i, double& dv_j,
00262                                 double& dv_k) const;
00263                 virtual inline Error
00264                         getEnt2ndDrvt(EntityHandle handle, double u, double v, double& duu_i,
00265                                         double& duu_j, double& duu_k, double& dvv_i, double& dvv_j,
00266                                         double& dvv_k, double& duv_i, double& duv_j, double& duv_k) const;
00267
00268                 virtual inline Error getArr1stDrvt(const EntityHandle* entities,
00269                                 int entities_size, StorageOrder order, const double* uv, int uv_size,
00270                                 double* dvtr_u, double* dvtr_v) const;
00271
00272                 virtual inline Error getArr2ndDrvt(const EntityHandle* entities,
00273                                 int entities_size, StorageOrder order, const double* uv, int uv_size,
00274                                 double* dvtr_uu, double* dvtr_vv, double* dvtr_uv) const;
00275
00276                 virtual inline Error getFcCvtrUV(EntityHandle face, double u, double v,
00277                                 double& i1, double& j1, double& k1, double& i2, double& j2, double& k2) const;
00278
00279                 virtual inline Error getFcArrCvtrUV(const EntityHandle* faces,
00280                                 int faces_size, StorageOrder order, const double* uv, int uv_size,
00281                                 double* cvtr1, double* cvtr2) const;
00282
00283                 virtual inline Error isEntPeriodic(EntityHandle entity, bool& in_u,
00284                                 bool& in_v) const;
00285
00286                 virtual inline Error isArrPeriodic(const EntityHandle* entities,
00287                                 int entities_size, int* in_uv) const;
00288
00289                 virtual inline Error isFcDegenerate(EntityHandle face, bool& is_degenerate) const;
00290
00291                 virtual inline Error isFcArrDegenerate(const EntityHandle* faces,
00292                                 int faces_size, int* degenerate) const;
00293
00294                 virtual inline Error getTolerance(int& type_out, double& tolerance_out) const;
00295                 virtual inline Error getEntTolerance(EntityHandle entity, double& tolerance) const;
00296                 virtual inline Error getArrTolerance(const EntityHandle* entities,
00297                                 int entities_size, double* tolerances) const;
00298
00299                 virtual inline Error getEntUVRange(EntityHandle face, double& u_min,
00300                                 double& v_min, double& u_max, double& v_max) const;
00301                 virtual inline Error getEntURange(EntityHandle edge, double& u_min,
00302                                 double& u_max) const;
00303                 virtual inline Error getArrUVRange(const EntityHandle* faces, int faces_size,
00304                                 StorageOrder order, double* uv_min, double* uv_max) const;
00305                 virtual inline Error getArrURange(const EntityHandle* edges, int edges_size,
00306                                 double* u_min, double* u_max) const;
00307
00308                 virtual inline Error getEntUtoUV(EntityHandle edge, EntityHandle face,
00309                                 double edge_u, double& face_u, double& face_v) const;
00310                 virtual inline Error getVtxToUV(EntityHandle vertex, EntityHandle face,
00311                                 double& u, double& v) const;
00312                 virtual inline Error getVtxToU(EntityHandle vertex, EntityHandle edge,
00313                                 double& u) const;
00314                 virtual inline Error getArrUtoUV(const EntityHandle* edges, int edges_size,
00315                                 const EntityHandle* faces, int faces_size, const double* edge_u,
00316                                 int edge_u_size, StorageOrder order, double* face_uv) const;
00317                 virtual inline Error getVtxArrToUV(const EntityHandle* vertices,
00318                                 int vertices_size, const EntityHandle* faces, int faces_size,
00319                                 StorageOrder order, double* face_uv) const;
00320                 virtual inline Error getVtxArrToU(const EntityHandle* vertices,
00321                                 int vertices_size, const EntityHandle* edges, int edges_size,
00322                                 double* edge_u) const;
00323
00324                 virtual inline Error deleteAll();
00325
00326                 virtual inline Error deleteEnt(EntityHandle entity);
00327
00328                 virtual inline Error copyEnt(EntityHandle source, EntityHandle& copy);
00329
00330                 virtual inline Error createSphere(double radius, EntityHandle& sphere);
00331                 virtual inline Error createPrism(double height, int num_sides,
00332                                 double maj_radius, double min_radius, EntityHandle& prism);
00333                 virtual inline Error createBrick(double x, double y, double z,
00334                                 EntityHandle& brick);
00335                 virtual inline Error createCylinder(double height, double maj_rad,
00336                                 double min_rad, EntityHandle& cylinder);
00337                 virtual inline Error createTorus(double maj_rad, double min_rad,
00338                                 EntityHandle& torus);
00339
00340                 virtual inline Error moveEnt(EntityHandle entity, double x, double y,
00341                                 double z);
00342                 virtual inline Error rotateEnt(EntityHandle entity, double angle,
00343                                 double axis_x, double axis_y, double axis_z);
00344                 virtual inline Error reflectEnt(EntityHandle entity, double norm_x,
00345                                 double norm_y, double norm_z);
00346                 virtual inline Error scaleEnt(EntityHandle entity, double x_factor,
00347                                 double y_factor, double z_factor);
00348
00349                 virtual inline Error uniteEnts(const EntityHandle* entities,
00350                                 int entities_size, EntityHandle& result_entity);
00351                 virtual inline Error subtractEnts(EntityHandle blank, EntityHandle tool,
00352                                 EntityHandle& result);
00353                 virtual inline Error intersectEnts(EntityHandle entity1,
00354                                 EntityHandle entity2, EntityHandle& result);
00355
00356                 virtual inline Error sectionEnt(EntityHandle entity, double plane_x,
00357                                 double plane_y, double plane_z, double offset, bool reverse,
00358                                 EntityHandle& result);
00359
00360                 virtual inline Error sweepEntAboutAxis(EntityHandle entity, double angle,
00361                                 double axis_x, double axis_y, double axis_z, EntityHandle& swept_entity);
00362
00363                 virtual inline Error imprintEnts(const EntityHandle* entities,
00364                                 int entities_size);
00365                 virtual inline Error mergeEnts(const EntityHandle* entities,
00366                                 int entities_size, double tolerance);
00367
00368                 // copied from iBaseVirtual.hpp
00369                 FBiGeom_Instance instance() {
00370                         return mInstance;
00371                 }
00372
00373                 virtual inline std::string getDescription() const;
00374
00375                 virtual inline Error getErrorType() const;
00376
00377                 virtual inline EntitySetHandle getRootSet() const;
00378
00379                 virtual inline Error createEntSet(bool is_list, EntitySetHandle& handle_out);
00380                 virtual inline Error destroyEntSet(EntitySetHandle handle);
00381                 virtual inline Error isList(EntitySetHandle handle, bool& is_list);
00382
00383                 virtual inline Error getNumEntSets(EntitySetHandle set, int num_hops,
00384                                 int& num_sets_out) const;
00385                 virtual inline Error getEntSets(EntitySetHandle set, int num_hops, std::vector<
00386                                 EntitySetHandle>& contained_sets_out) const;
00387
00388                 virtual inline Error addEntToSet(EntityHandle entity, EntitySetHandle set);
00389                 virtual inline Error rmvEntFromSet(EntityHandle entity, EntitySetHandle set);
00390
00391                 virtual inline Error addEntArrToSet(const EntityHandle* entity_handles,
00392                                 int entity_handles_size, EntitySetHandle entity_set);
00393                 virtual inline Error rmvEntArrFromSet(const EntityHandle* entity_handles,
00394                                 int entity_handles_size, EntitySetHandle entity_set);
00395
00396                 virtual inline Error addEntSet(EntitySetHandle to_add, EntitySetHandle add_to);
00397                 virtual inline Error rmvEntSet(EntitySetHandle to_rmv, EntitySetHandle rmv_from);
00398
00399                 virtual inline Error isEntContained(EntitySetHandle set, EntityHandle ent,
00400                                 bool& contained_out) const;
00401                 virtual inline Error isEntArrContained(EntitySetHandle containing_set,
00402                                 const EntityHandle* entity_handles, int num_entity_handles,
00403                                 bool* is_contained_out) const;
00404                 virtual inline Error isEntSetContained(EntitySetHandle containing_set,
00405                                 EntitySetHandle contained_set, bool& contained_out) const;
00406
00407                 virtual inline Error addPrntChld(EntitySetHandle parent, EntitySetHandle child);
00408                 virtual inline Error rmvPrntChld(EntitySetHandle parent, EntitySetHandle child);
00409                 virtual inline Error isChildOf(EntitySetHandle parent, EntitySetHandle child,
00410                                 bool& is_child_out) const;
00411                 virtual inline Error getNumChld(EntitySetHandle parent, int num_hops,
00412                                 int& num_child_out) const;
00413                 virtual inline Error getNumPrnt(EntitySetHandle child, int num_hops,
00414                                 int& num_parent_out) const;
00415                 virtual inline Error getChldn(EntitySetHandle parent, int num_hops, std::vector<
00416                                 EntitySetHandle>& children_out) const;
00417                 virtual inline Error getPrnts(EntitySetHandle child, int num_hops, std::vector<
00418                                 EntitySetHandle>& parents_out) const;
00419
00420                 virtual inline Error subtract(EntitySetHandle set1, EntitySetHandle set2,
00421                                 EntitySetHandle& result_set_out);
00422                 virtual inline Error intersect(EntitySetHandle set1, EntitySetHandle set2,
00423                                 EntitySetHandle& result_set_out);
00424                 virtual inline Error unite(EntitySetHandle set1, EntitySetHandle set2,
00425                                 EntitySetHandle& result_set_out);
00426
00427                 virtual inline Error createTag(const char* tag_name, int tag_num_type_values,
00428                                 TagValueType tag_type, TagHandle& tag_handle_out);
00429
00430                 virtual inline Error destroyTag(TagHandle tag_handle, bool forced);
00431                 virtual inline Error getTagName(TagHandle tag_handle, std::string& name_out) const;
00432                 virtual inline Error getTagSizeValues(TagHandle tag_handle, int& size_out) const;
00433                 virtual inline Error getTagSizeBytes(TagHandle tag_handle, int& size_out) const;
00434                 virtual inline Error getTagHandle(const char* name, TagHandle& handle_out) const;
00435                 virtual inline Error getTagType(TagHandle tag_handle, TagValueType& type_out) const;
00436
00437                 virtual inline Error setEntSetData(EntitySetHandle set_handle, TagHandle tag_handle,
00438                                 const void* tag_value);
00439                 virtual inline Error setEntSetIntData(EntitySetHandle set_handle,
00440                                 TagHandle tag_handle, int value);
00441                 virtual inline Error setEntSetDblData(EntitySetHandle set_handle,
00442                                 TagHandle tag_handle, double value);
00443                 virtual inline Error setEntSetEHData(EntitySetHandle set_handle,
00444                                 TagHandle tag_handle, EntityHandle value);
00445                 virtual inline Error setEntSetESHData(EntitySetHandle set_handle,
00446                                 TagHandle tag_handle, EntitySetHandle value);
00447
00448                 virtual inline Error getEntSetData(EntitySetHandle set_handle, TagHandle tag_handle,
00449                                 void* tag_value_out) const;
00450                 virtual inline Error getEntSetIntData(EntitySetHandle set_handle,
00451                                 TagHandle tag_handle, int& value_out) const;
00452                 virtual inline Error getEntSetDblData(EntitySetHandle set_handle,
00453                                 TagHandle tag_handle, double& value_out) const;
00454                 virtual inline Error getEntSetEHData(EntitySetHandle set_handle,
00455                                 TagHandle tag_handle, EntityHandle& value_out) const;
00456                 virtual inline Error getEntSetESHData(EntitySetHandle set_handle,
00457                                 TagHandle tag_handle, EntitySetHandle& value_out) const;
00458
00459                 virtual inline Error getAllEntSetTags(EntitySetHandle set,
00460                                 std::vector<TagHandle>& tags_out) const;
00461                 virtual inline Error getAllTags(EntityHandle entity,
00462                                 std::vector<TagHandle>& tags_out) const;
00463
00464                 virtual inline Error rmvEntSetTag(EntitySetHandle set, TagHandle tag);
00465                 virtual inline Error rmvTag(EntityHandle entity, TagHandle tag);
00466                 virtual inline Error rmvArrTag(const EntityHandle* handles, int size, TagHandle tag);
00467
00468                 virtual inline Error getArrData(const EntityHandle* entity_handles,
00469                                 int entity_handles_size, TagHandle tag_handle, void* tag_values_out) const;
00470                 virtual inline Error getIntArrData(const EntityHandle* entity_handles,
00471                                 int entity_handles_size, TagHandle tag_handle, int* tag_values_out) const;
00472                 virtual inline Error getDblArrData(const EntityHandle* entity_handles,
00473                                 int entity_handles_size, TagHandle tag_handle, double* tag_values_out) const;
00474                 virtual inline Error getEHArrData(const EntityHandle* entity_handles,
00475                                 int entity_handles_size, TagHandle tag_handle,
00476                                 EntityHandle* tag_values_out) const;
00477                 virtual inline Error getESHArrData(const EntityHandle* entity_handles,
00478                                 int entity_handles_size, TagHandle tag_handle,
00479                                 EntitySetHandle* tag_values_out) const;
00480
00481                 virtual inline Error setArrData(const EntityHandle* entity_handles,
00482                                 int entity_handles_size, TagHandle tag_handle, const void* tag_values);
00483                 virtual inline Error setIntArrData(const EntityHandle* entity_handles,
00484                                 int entity_handles_size, TagHandle tag_handle, const int* tag_values);
00485                 virtual inline Error setDblArrData(const EntityHandle* entity_handles,
00486                                 int entity_handles_size, TagHandle tag_handle, const double* tag_values);
00487                 virtual inline Error setEHArrData(const EntityHandle* entity_handles,
00488                                 int entity_handles_size, TagHandle tag_handle,
00489                                 const EntityHandle* tag_values);
00490                 virtual inline Error setESHArrData(const EntityHandle* entity_handles,
00491                                 int entity_handles_size, TagHandle tag_handle,
00492                                 const EntitySetHandle* tag_values);
00493
00494                 virtual inline Error setData(EntityHandle entity_handle, TagHandle tag_handle,
00495                                 const void* tag_value);
00496                 virtual inline Error setIntData(EntityHandle entity_handle, TagHandle tag_handle,
00497                                 int value);
00498                 virtual inline Error setDblData(EntityHandle entity_handle, TagHandle tag_handle,
00499                                 double value);
00500                 virtual inline Error setEHData(EntityHandle entity_handle, TagHandle tag_handle,
00501                                 EntityHandle value);
00502                 virtual inline Error setESHData(EntityHandle entity_handle, TagHandle tag_handle,
00503                                 EntitySetHandle value);
00504
00505                 virtual inline Error getData(EntityHandle entity_handle, TagHandle tag_handle,
00506                                 void* tag_value_out) const;
00507                 virtual inline Error getFacets(EntityHandle entity_handle, double dist_tolerance,
00508         std::vector<double> &point, std::vector<int> &facets) const;
00509                 virtual inline Error getIntData(EntityHandle entity_handle, TagHandle tag_handle,
00510                                 int& value_out) const;
00511                 virtual inline Error getDblData(EntityHandle entity_handle, TagHandle tag_handle,
00512                                 double& value_out) const;
00513                 virtual inline Error getEHData(EntityHandle entity_handle, TagHandle tag_handle,
00514                                 EntityHandle& value_out) const;
00515                 virtual inline Error getESHData(EntityHandle entity_handle, TagHandle tag_handle,
00516                                 EntitySetHandle& value_out) const;
00517
00518                 virtual bool isFBiGeom() {return true;}
00519                 // end copy from iBaseVirtual.hpp
00523                 class EntArrIter {
00524                         private:
00525                                 friend class FBiGeom;
00526                                 iBase_EntityArrIterator mHandle;
00527                                 FBiGeom_Instance mInstance;
00528                                 int mSize;
00529                         public:
00530                                 EntArrIter() :
00531                                         mHandle(0), mInstance(0), mSize(0) {
00532                                         }
00533                                 inline ~EntArrIter();
00534                                 inline Error getNext(EntityHandle* entity_handles_out, int& size_out,
00535                                                 bool& has_more_data_out);
00536                                 inline Error reset();
00537                 };
00538
00542                 class EntIter {
00543                         private:
00544                                 friend class FBiGeom;
00545                                 iBase_EntityIterator mHandle;
00546                                 FBiGeom_Instance mInstance;
00547                         public:
00548                                 EntIter() :
00549                                         mHandle(0), mInstance(0) {
00550                                         }
00551                                 inline ~EntIter();
00552                                 inline Error getNext(EntityHandle& entity_handle_out,
00553                                                 bool& has_more_data_out);
00554                                 inline Error reset();
00555                 };
00556
00557                 virtual inline Error initEntIter(EntitySetHandle set,
00558                                 EntityType requested_type, EntIter& iter);
00559                 virtual inline Error initEntArrIter(EntitySetHandle set,
00560                                 EntityType requested_type, int requested_array_size, EntArrIter& iter);
00561         private:
00562                 bool FBiGeomInstanceOwner;
00563
00564                 // prohibit copying
00565                 FBiGeom(const FBiGeom&) {
00566                 }
00567                 void operator=(const FBiGeom&) {
00568                 }
00569 };
00570
00571 inline FBiGeom::FBiGeom(const char* options) :
00572         FBiGeomInstanceOwner(true)
00573 {
00574         int err, len = options ? strlen(options) : 0;
00575         FBiGeom_newGeom(options, &mInstance, &err, len);
00576         if (iBase_SUCCESS != err) {
00577                 mInstance = 0;
00578                 FBiGeomInstanceOwner = false;
00579         }
00580 }
00581
00582 inline FBiGeom::FBiGeom(FBiGeom_Instance instance) :
00583         FBiGeomInstanceOwner(false)
00584 {
00585         mInstance = instance;
00586 }
00587 inline FBiGeom::FBiGeom(bool meshBased)
00588 {
00589         mInstance = 0;
00590         FBiGeomInstanceOwner = false;
00591 }
00592 inline FBiGeom::~FBiGeom()
00593 {
00594         if (FBiGeomInstanceOwner) {
00595                 int err;
00596                 FBiGeom_dtor(mInstance, &err);
00597         }
00598 }
00599
00600 inline FBiGeom::Error FBiGeom::load(const char* file_name, const char* options)
00601 {
00602         int err, len = options ? strlen(options) : 0;
00603         FBiGeom_load(mInstance, file_name, options, &err, strlen(file_name), len);
00604         return (Error) err;
00605 }
00606
00607 inline FBiGeom::Error FBiGeom::save(const char* file_name, const char* options)
00608 {
00609         int err, len = options ? strlen(options) : 0;
00610         FBiGeom_save(mInstance, file_name, options, &err, strlen(file_name), len);
00611         return (Error) err;
00612 }
00613
00614 //inline FBiGeom::StorageOrder
00615 //FBiGeom::getDfltStorage()
00616 //{
00617 //  int err, order;
00618 //  FBiGeom_getDfltStorage( mInstance, &order, &err );
00619 //  return (iBase_SUCCESS == err) ? (StorageOrder)order : iBase_UNDETERMINED;
00620 //}
00621
00622 inline FBiGeom::Error FBiGeom::getNumOfType(EntitySetHandle set, EntityType type,
00623                 int& count_out) const
00624 {
00625         int err;
00626         FBiGeom_getNumOfType(mInstance, set, type, &count_out, &err);
00627         return (Error) err;
00628 }
00629
00630 inline FBiGeom::Error FBiGeom::getEntities(EntitySetHandle set, EntityType type,
00631                 std::vector<EntityHandle>& entities_out) const
00632 {
00633         // if input vect has no allocated space, allocate some so
00634         // we don't accidentally ask the impl to allocate an array
00635         if (entities_out.capacity() == 0) {
00636                 int count;
00637                 Error err2 = getNumOfType(set, iBase_ALL_TYPES, count);
00638                 if (err2 != iBase_SUCCESS)
00639                         return err2;
00640                 entities_out.resize(count);
00641         }
00642
00643         // try getting results using whatever space input vector has allocated
00644         int err, size = 0, alloc = entities_out.capacity();
00645         entities_out.resize(entities_out.capacity());
00646         EntityHandle* ptr = &entities_out[0];
00647         FBiGeom_getEntities(mInstance, set, type, &ptr, &alloc, &size, &err);
00648         entities_out.resize(size);
00649
00650         // if input vector was too small, try again with increased size
00651         if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00652                 alloc = entities_out.size();
00653                 ptr = &entities_out[0];
00654                 FBiGeom_getEntities(mInstance, set, type, &ptr, &alloc, &size, &err);
00655         }
00656
00657         return (Error) err;
00658 }
00659
00660 inline FBiGeom::Error FBiGeom::deleteEnt(EntityHandle handle)
00661 {
00662         int err;
00663         FBiGeom_deleteEnt(mInstance, handle, &err);
00664         return (Error) err;
00665 }
00666
00667 //inline FBiGeom::Error
00668 //FBiGeom::deleteEntArr( const EntityHandle* entity_handles, int num_handles )
00669 //{
00670 //  int err;
00671 //  FBiGeom_deleteEntArr( mInstance, entity_handles, num_handles, &err );
00672 //  return (Error)err;
00673 //}
00674
00675 //inline FBiGeom::Error
00676 //FBiGeom::getAdjEntities( EntitySetHandle set,
00677 //                       EntityType type_requestor,
00678 //                       EntityType type_requested,
00679 //                       std::vector<EntityHandle>& adj_entity_handles,
00680 //                       std::vector<int>& offset )
00681 //{
00682 //  std::vector<EntityHandle> entities;
00683 //  Error err = getEntities( set, type_requestor, entities );
00684 //  if (iBase_SUCCESS != err)
00685 //    return err;
00686 //
00687 //  offset.resize( entities.size() + 1 );
00688 //  return getArrAdj( &entities[0], entities.size(), type_requested,
00689 //                    adj_entity_handles, &offset[0] );
00690 //}
00691
00692 inline FBiGeom::Error FBiGeom::initEntIter(EntitySetHandle set,
00693                 EntityType requested_type, FBiGeom::EntIter& iter)
00694 {
00695         int err;
00696         iter.mInstance = mInstance;
00697         FBiGeom_initEntIter(mInstance, set, requested_type, &iter.mHandle, &err);
00698         return (Error) err;
00699 }
00700
00701 inline FBiGeom::Error FBiGeom::initEntArrIter(EntitySetHandle set,
00702                 EntityType requested_type, int requested_array_size,
00703                 FBiGeom::EntArrIter& iter)
00704 {
00705         int err;
00706         iter.mInstance = mInstance;
00707         iter.mSize = requested_array_size;
00708         FBiGeom_initEntArrIter(mInstance, set, requested_type, requested_array_size,
00709                         &iter.mHandle, &err);
00710         return (Error) err;
00711 }
00712
00713 inline FBiGeom::EntArrIter::~EntArrIter()
00714 {
00715         int err;
00716         if (mHandle != 0) {
00717                 FBiGeom_endEntArrIter(mInstance, mHandle, &err);
00718                 mHandle = 0;
00719         }
00720 }
00721
00722 inline FBiGeom::EntIter::~EntIter()
00723 {
00724         int err;
00725         if (mHandle != 0) {
00726                 FBiGeom_endEntIter(mInstance, mHandle, &err);
00727                 mHandle = 0;
00728         }
00729 }
00730
00731 inline FBiGeom::Error FBiGeom::EntArrIter::getNext(EntityHandle* entity_handles,
00732                 int& size_out, bool& has_more_data_out)
00733 {
00734         int err, alloc = mSize, has_data;
00735         FBiGeom_getNextEntArrIter(mInstance, mHandle, &entity_handles, &alloc,
00736                         &size_out, &has_data, &err);
00737         has_more_data_out = (has_data != 0);
00738         return (Error) err;
00739 }
00740
00741 inline FBiGeom::Error FBiGeom::EntIter::getNext(EntityHandle& handle_out,
00742                 bool& has_more_data_out)
00743 {
00744         int err, has_data;
00745         FBiGeom_getNextEntIter(mInstance, mHandle, &handle_out, &has_data, &err);
00746         has_more_data_out = (has_data != 0);
00747         return (Error) err;
00748 }
00749
00750 inline FBiGeom::Error FBiGeom::EntArrIter::reset()
00751 {
00752         int err;
00753         FBiGeom_resetEntArrIter(mInstance, mHandle, &err);
00754         return (Error) err;
00755 }
00756
00757 inline FBiGeom::Error FBiGeom::EntIter::reset()
00758 {
00759         int err;
00760         FBiGeom_resetEntIter(mInstance, mHandle, &err);
00761         return (Error) err;
00762 }
00763
00764 inline FBiGeom::Error FBiGeom::getEntType(EntityHandle handle, EntityType& type_out) const
00765 {
00766         int err, result;
00767         FBiGeom_getEntType(mInstance, handle, &result, &err);
00768         type_out = (EntityType) result;
00769         return (Error) err;
00770 }
00771
00772 inline FBiGeom::Error FBiGeom::getArrType(const EntityHandle* entity_handles,
00773                 int entity_handles_size, EntityType* types_out) const
00774 {
00775         int err, alloc = entity_handles_size, junk, *ptr;
00776         std::vector<int> storage;
00777         if (sizeof(EntityType) == sizeof(int))
00778                 ptr = reinterpret_cast<int*> (types_out);
00779         else {
00780                 storage.resize(entity_handles_size);
00781                 ptr = &storage[0];
00782         }
00783
00784         FBiGeom_getArrType(mInstance, entity_handles, entity_handles_size, &ptr,
00785                         &alloc, &junk, &err);
00786
00787         if (sizeof(EntityType) != sizeof(int))
00788                 for (int i = 0; i < entity_handles_size; ++i)
00789                         types_out[i] = (EntityType) storage[i];
00790
00791         return (Error) err;
00792 }
00793
00794 inline FBiGeom::Error FBiGeom::getEntAdj(EntityHandle handle,
00795                 EntityType type_requested, std::vector<EntityHandle>& adj_entities_out) const
00796 {
00797         if (adj_entities_out.capacity() == 0)
00798                 adj_entities_out.resize(12);
00799         else
00800                 adj_entities_out.resize(adj_entities_out.capacity());
00801
00802         int err, alloc = adj_entities_out.size(), size = 0;
00803         EntityHandle* ptr = &adj_entities_out[0];
00804         FBiGeom_getEntAdj(mInstance, handle, type_requested, &ptr, &alloc, &size, &err);
00805         adj_entities_out.resize(size);
00806
00807         if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00808                 alloc = adj_entities_out.size();
00809                 ptr = &adj_entities_out[0];
00810                 FBiGeom_getEntAdj(mInstance, handle, type_requested, &ptr, &alloc, &size,
00811                                 &err);
00812         }
00813
00814         return (Error) err;
00815 }
00816
00817 inline FBiGeom::Error FBiGeom::getArrAdj(const EntityHandle* entity_handles,
00818                 int entity_handles_size, EntityType type_requested, std::vector<
00819                 EntityHandle>& adj_entities_out, int* offsets_out) const
00820 {
00821         if (adj_entities_out.capacity() == 0)
00822                 adj_entities_out.resize(12 * entity_handles_size);
00823         else
00824                 adj_entities_out.resize(adj_entities_out.capacity());
00825
00826         int err, alloc = adj_entities_out.size(), size = 0;
00827         int off_alloc = entity_handles_size + 1, junk;
00828         EntityHandle* ptr = &adj_entities_out[0];
00829         FBiGeom_getArrAdj(mInstance, entity_handles, entity_handles_size,
00830                         type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
00831                         &err);
00832         adj_entities_out.resize(size);
00833
00834         if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00835                 alloc = adj_entities_out.size();
00836                 ptr = &adj_entities_out[0];
00837                 FBiGeom_getArrAdj(mInstance, entity_handles, entity_handles_size,
00838                                 type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
00839                                 &err);
00840         }
00841
00842         return (Error) err;
00843 }
00844
00845 inline FBiGeom::Error FBiGeom::getEnt2ndAdj(EntityHandle handle,
00846                 EntityType bridge_entity_type, EntityType type_requested, std::vector<
00847                 EntityHandle>& adj_entities_out) const
00848 {
00849         if (adj_entities_out.capacity() == 0)
00850                 adj_entities_out.resize(12);
00851         else
00852                 adj_entities_out.resize(adj_entities_out.capacity());
00853
00854         int err, alloc = adj_entities_out.size(), size = 0;
00855         EntityHandle* ptr = &adj_entities_out[0];
00856         FBiGeom_getEnt2ndAdj(mInstance, handle, bridge_entity_type, type_requested,
00857                         &ptr, &alloc, &size, &err);
00858         adj_entities_out.resize(size);
00859
00860         if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00861                 alloc = adj_entities_out.size();
00862                 ptr = &adj_entities_out[0];
00863                 FBiGeom_getEnt2ndAdj(mInstance, handle, bridge_entity_type, type_requested,
00864                                 &ptr, &alloc, &size, &err);
00865         }
00866
00867         return (Error) err;
00868 }
00869
00870 inline FBiGeom::Error FBiGeom::getArr2ndAdj(const EntityHandle* entity_handles,
00871                 int entity_handles_size, EntityType order_key, EntityType type_requested,
00872                 std::vector<EntityHandle>& adj_entities_out, int* offsets_out) const
00873 {
00874         if (adj_entities_out.capacity() == 0)
00875                 adj_entities_out.resize(12 * entity_handles_size);
00876         else
00877                 adj_entities_out.resize(adj_entities_out.capacity());
00878
00879         int err, alloc = adj_entities_out.size(), size = 0;
00880         int off_alloc = entity_handles_size + 1, junk;
00881         EntityHandle* ptr = &adj_entities_out[0];
00882         FBiGeom_getArr2ndAdj(mInstance, entity_handles, entity_handles_size, order_key,
00883                         type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
00884                         &err);
00885         adj_entities_out.resize(size);
00886
00887         if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00888                 alloc = adj_entities_out.size();
00889                 ptr = &adj_entities_out[0];
00890                 FBiGeom_getArr2ndAdj(mInstance, entity_handles, entity_handles_size,
00891                                 order_key, type_requested, &ptr, &alloc, &size, &offsets_out,
00892                                 &off_alloc, &junk, &err);
00893         }
00894
00895         return (Error) err;
00896 }
00897
00898 inline FBiGeom::Error FBiGeom::getBoundBox(double& min_x, double& min_y,
00899                 double& min_z, double& max_x, double& max_y, double& max_z) const
00900 {
00901         int err;
00902         FBiGeom_getBoundBox(mInstance, &min_x, &min_y, &min_z, &max_x, &max_y, &max_z,
00903                         &err);
00904         return (Error) err;
00905 }
00906
00907 inline int FBiGeom::getParametric()
00908 {
00909         int err, result;
00910         FBiGeom_getParametric(mInstance, &result, &err);
00911         return result;
00912 }
00913
00914 inline FBiGeom::Error FBiGeom::isEntAdj(EntityHandle entity1, EntityHandle entity2,
00915                 bool& adjacent_out) const
00916 {
00917         int err, result;
00918         FBiGeom_isEntAdj(mInstance, entity1, entity2, &result, &err);
00919         adjacent_out = (result != 0);
00920         return (Error) err;
00921 }
00922
00923 inline FBiGeom::Error FBiGeom::isArrAdj(const EntityHandle* entities1,
00924                 const EntityHandle* entities2, int num_entity_pairs, int* is_adj_out) const
00925 {
00926         int err, alloc = num_entity_pairs, size = 0;
00927         FBiGeom_isArrAdj(mInstance, entities1, num_entity_pairs, entities2,
00928                         num_entity_pairs, &is_adj_out, &alloc, &size, &err);
00929         return (Error) err;
00930 }
00931
00932 inline FBiGeom::Error FBiGeom::getEntClosestPt(EntityHandle entity, double near_x,
00933                 double near_y, double near_z, double& on_x, double& on_y, double& on_z) const
00934 {
00935         int err;
00936         FBiGeom_getEntClosestPt(mInstance, entity, near_x, near_y, near_z, &on_x,
00937                         &on_y, &on_z, &err);
00938         return (Error) err;
00939 }
00940
00941 inline FBiGeom::Error FBiGeom::getEntClosestPtTrimmed(EntityHandle entity, double near_x,
00942                                           double near_y, double near_z, double& on_x, double& on_y, double& on_z) const
00943 {
00944     int err=0;
00945     FBiGeom_getEntClosestPtTrimmed(mInstance, entity, near_x, near_y, near_z, &on_x, &on_y, &on_z, &err);
00946     return (Error) err;
00947 }
00948
00949 inline FBiGeom::Error FBiGeom::getArrClosestPt(const EntityHandle* handles,
00950           int handles_size, StorageOrder order, const double* near_coordinates,
00951           int near_coordinates_size, double* on_coordinates) const
00952 {
00953      int err, alloc = std::max(near_coordinates_size, 3 * handles_size), size = 0;
00954      FBiGeom_getArrClosestPt(mInstance, handles, handles_size, order,
00955                            near_coordinates, near_coordinates_size, &on_coordinates, &alloc, &size,
00956                            &err);
00957      return (Error) err;
00958 }
00959
00960 inline FBiGeom::Error FBiGeom::getEntNrmlXYZ(EntityHandle entity, double x,
00961           double y, double z, double& i, double& j, double& k) const
00962 {
00963      int err;
00964      FBiGeom_getEntNrmlXYZ(mInstance, entity, x, y, z, &i, &j, &k, &err);
00965      return (Error) err;
00966 }
00967
00968 inline FBiGeom::Error FBiGeom::getArrNrmlXYZ(const EntityHandle* entities,
00969           int entities_size, StorageOrder order, const double* xyz, int xyz_size,
00970           double* ijk) const
00971 {
00972      int err, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
00973      FBiGeom_getArrNrmlXYZ(mInstance, entities, entities_size, order, xyz, xyz_size,
00974                          &ijk, &alloc, &size, &err);
00975      return (Error) err;
00976 }
00977
00978 inline FBiGeom::Error FBiGeom::getEntNrmlPlXYZ(EntityHandle entity, double x,
00979           double y, double z, double& on_x, double& on_y, double& on_z, double& i,
00980           double& j, double& k) const
00981 {
00982      int err;
00983      FBiGeom_getEntNrmlPlXYZ(mInstance, entity, x, y, z, &on_x, &on_y, &on_z, &i,
00984                            &j, &k, &err);
00985      return (Error) err;
00986 }
00987
00988 inline FBiGeom::Error FBiGeom::getArrNrmlPlXYZ(const EntityHandle* entities,
00989           int entities_size, StorageOrder order, const double* near_xyz,
00990           int near_xyz_size, double* on_xyz, double* nrml_ijk) const
00991 {
00992      int err, alloc = std::max(near_xyz_size, 3 * entities_size), size = 0;
00993      FBiGeom_getArrNrmlPlXYZ(mInstance, entities, entities_size, order, near_xyz,
00994                            near_xyz_size, &on_xyz, &alloc, &size, &nrml_ijk, &alloc, &size, &err);
00995      return (Error) err;
00996 }
00997
00998 inline FBiGeom::Error FBiGeom::getEntTgntXYZ(EntityHandle entity, double x,
00999           double y, double z, double& i, double& j, double& k) const
01000 {
01001      int err;
01002      FBiGeom_getEntTgntXYZ(mInstance, entity, x, y, z, &i, &j, &k, &err);
01003      return (Error) err;
01004 }
01005
01006 inline FBiGeom::Error FBiGeom::getArrTgntXYZ(const EntityHandle* entities,
01007           int entities_size, StorageOrder order, const double* xyz, int xyz_size,
01008           double* ijk) const
01009 {
01010      int err, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
01011      FBiGeom_getArrTgntXYZ(mInstance, entities, entities_size, order, xyz, xyz_size,
01012                          &ijk, &alloc, &size, &err);
01013      return (Error) err;
01014 }
01015
01016 inline FBiGeom::Error FBiGeom::getFcCvtrXYZ(EntityHandle face, double x, double y,
01017                                         double z, double& i1, double& j1, double& k1, double& i2, double& j2,
01018                                         double& k2) const
01019 {
01020      int err=0;
01021      FBiGeom_getFcCvtrXYZ(mInstance, face, x, y, z, &i1, &j1, &k1, &i2, &j2, &k2,
01022                         &err);
01023      return (Error) err;
01024 }
01025
01026 inline FBiGeom::Error FBiGeom::getEgCvtrXYZ(EntityHandle edge, double x, double y,
01027                                         double z, double& i, double& j, double& k) const
01028 {
01029      int err=0;
01030      FBiGeom_getEgCvtrXYZ(mInstance, edge, x, y, z, &i, &j, &k, &err);
01031      return (Error) err;
01032 }
01033
01034 inline FBiGeom::Error FBiGeom::getEntArrCvtrXYZ(const EntityHandle* entities,
01035           int entities_size, StorageOrder order, const double* xyz, int xyz_size,
01036           double* cvtr_1, double* cvtr_2) const
01037 {
01038      int err=0, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
01039      FBiGeom_getEntArrCvtrXYZ(mInstance, entities, entities_size, order, xyz,
01040                             xyz_size, &cvtr_1, &alloc, &size, &cvtr_2, &alloc, &size, &err);
01041      return (Error) err;
01042 }
01043
01044 inline FBiGeom::Error FBiGeom::getEgEvalXYZ(EntityHandle edge, double x, double y,
01045                                         double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
01046                                         double& tngt_j, double& tngt_k, double& cvtr_i, double& cvtr_j,
01047                                         double& cvtr_k) const
01048 {
01049      int err=0;
01050      FBiGeom_getEgEvalXYZ(mInstance, edge, x, y, z, &on_x, &on_y, &on_z, &tngt_i,
01051                         &tngt_j, &tngt_k, &cvtr_i, &cvtr_j, &cvtr_k, &err);
01052      return (Error) err;
01053 }
01054
01055 inline FBiGeom::Error FBiGeom::getFcEvalXYZ(EntityHandle face, double x, double y,
01056                                         double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
01057                                         double& tngt_j, double& tngt_k, double& cvtr1_i, double& cvtr1_j,
01058                                         double& cvtr1_k, double& cvtr2_i, double& cvtr2_j, double& cvtr2_k) const
01059 {
01060      int err=0;
01061      FBiGeom_getFcEvalXYZ(mInstance, face, x, y, z, &on_x, &on_y, &on_z, &tngt_i,
01062                         &tngt_j, &tngt_k, &cvtr1_i, &cvtr1_j, &cvtr1_k, &cvtr2_i, &cvtr2_j,
01063                         &cvtr2_k, &err);
01064      return (Error) err;
01065 }
01066
01067 inline FBiGeom::Error FBiGeom::getArrEgEvalXYZ(const EntityHandle* edges,
01068           int edges_size, StorageOrder order, const double* near_coords,
01069           int near_coords_size, double* on_coords, double* tangent, double* curvature) const
01070 {
01071      int err=0, alloc = std::max(near_coords_size, 3 * edges_size), size = 0;
01072      FBiGeom_getArrEgEvalXYZ(mInstance, edges, edges_size, order, near_coords,
01073                            near_coords_size, &on_coords, &alloc, &size, &tangent, &alloc, &size,
01074                            &curvature, &alloc, &size, &err);
01075      return (Error) err;
01076 }
01077
01078 inline FBiGeom::Error FBiGeom::getArrFcEvalXYZ(const EntityHandle* faces,
01079           int faces_size, StorageOrder order, const double* near_coords,
01080           int near_coords_size, double* on_coords, double* tangent,
01081           double* curvature1, double* curvature2) const
01082 {
01083      int err=0, alloc = std::max(near_coords_size, 3 * faces_size), size = 0;
01084      FBiGeom_getArrFcEvalXYZ(mInstance, faces, faces_size, order, near_coords,
01085                            near_coords_size, &on_coords, &alloc, &size, &tangent, &alloc, &size,
01086                            &curvature1, &alloc, &size, &curvature2, &alloc, &size, &err);
01087      return (Error) err;
01088 }
01089
01090 inline FBiGeom::Error FBiGeom::getEntBoundBox(EntityHandle entity, double& min_x,
01091           double& min_y, double& min_z, double& max_x, double& max_y, double& max_z) const
01092 {
01093      int err;
01094      FBiGeom_getEntBoundBox(mInstance, entity, &min_x, &min_y, &min_z, &max_x,
01095                           &max_y, &max_z, &err);
01096      return (Error) err;
01097 }
01098
01099 inline FBiGeom::Error FBiGeom::getArrBoundBox(const EntityHandle* entities,
01100           int entities_size, StorageOrder order, double* min_corners,
01101           double* max_corners) const
01102 {
01103      int err, alloc = 3 * entities_size, size = 0, order_int = order;
01104      FBiGeom_getArrBoundBox(mInstance, entities, entities_size, order_int,
01105                           &min_corners, &alloc, &size, &max_corners, &alloc, &size, &err);
01106      return (Error) err;
01107 }
01108
01109 inline FBiGeom::Error FBiGeom::getVtxCoord(EntityHandle vertex, double& x,
01110                                        double& y, double& z) const
01111 {
01112      int err;
01113      FBiGeom_getVtxCoord(mInstance, vertex, &x, &y, &z, &err);
01114      return (Error) err;
01115 }
01116
01117 inline FBiGeom::Error FBiGeom::getVtxArrCoords(const EntityHandle* vertices,
01118           int vertices_size, StorageOrder order, double* coords) const
01119 {
01120      int err, alloc = vertices_size, size = 0;
01121      FBiGeom_getVtxArrCoords(mInstance, vertices, vertices_size, order, &coords,
01122                            &alloc, &size, &err);
01123      return (Error) err;
01124 }
01125
01126 inline FBiGeom::Error FBiGeom::getPntRayIntsct(double x, double y, double z,
01127           double i, double j, double k, StorageOrder order,
01128           std::vector<EntityHandle>& entities_out, std::vector<double>& points_out,
01129           std::vector<double>& params_out) const
01130 {
01131      int err, count;
01132      Error err2 = getNumOfType(getRootSet(), iBase_ALL_TYPES, count);
01133      if (err2 != iBase_SUCCESS)
01134           return err2;
01135
01136      entities_out.resize(count);
01137      points_out.resize(3 * count);
01138      params_out.resize(2 * count);
01139      int entities_alloc = entities_out.size(), entities_size = 0;
01140      int points_alloc = points_out.size(), points_size = 0;
01141      int params_alloc = params_out.size(), params_size = 0;
01142      EntityHandle* entities_ptr = &entities_out[0];
01143      double * points_ptr = &points_out[0];
01144      double * params_ptr = &params_out[0];
01145
01146      FBiGeom_getPntRayIntsct(mInstance, x, y, z, i, j, k, &entities_ptr,
01147                            &entities_alloc, &entities_size, order, &points_ptr, &points_alloc,
01148                            &points_size, &params_ptr, &params_alloc, &params_size, &err);
01149      entities_out.resize(entities_size);
01150      points_out.resize(points_size);
01151      params_out.resize(params_size);
01152      if (err == iBase_BAD_ARRAY_SIZE || err == iBase_BAD_ARRAY_DIMENSION) {
01153           entities_alloc = entities_out.size();
01154           points_alloc = points_out.size();
01155           params_alloc = params_out.size();
01156           entities_ptr = &entities_out[0];
01157           points_ptr = &points_out[0];
01158           params_ptr = &params_out[0];
01159           FBiGeom_getPntRayIntsct(mInstance, x, y, z, i, j, k, &entities_ptr,
01160                                 &entities_alloc, &entities_size, order, &points_ptr, &points_alloc,
01161                                 &points_size, &params_ptr, &params_alloc, &params_size, &err);
01162      }
01163
01164      return (Error) err;
01165 }
01166
01167 inline FBiGeom::Error FBiGeom::getPntClsf(double x, double y, double z,
01168                                       EntityHandle& handle_out) const
01169 {
01170      int err=0;
01171      /*FBiGeom_getPntClsf(mInstance, x, y, z, &handle_out, &err);*/
01172      return (Error) err;
01173 }
01174
01175 inline FBiGeom::Error FBiGeom::getPntArrClsf(StorageOrder order,
01176           const double* coords, int coords_size, EntityHandle* entities_out) const
01177 {
01178      int err=0;//, alloc = coords_size / 3, size = 0;
01179      /*FBiGeom_getPntArrClsf(mInstance, order, coords, coords_size, &entities_out,
01180                          &alloc, &size, &err);*/
01181      return (Error) err;
01182 }
01183
01184 inline FBiGeom::Error FBiGeom::getSense(EntityHandle ent, EntityHandle wrt_ent,
01185                                     int &sense) const
01186 {
01187      EntityType tp_wrt, tp_ent;
01188      Error err = getEntType(wrt_ent, tp_wrt);
01189      if (iBase_SUCCESS != err)
01190           return err;
01191      err = getEntType(ent, tp_ent);
01192      if (iBase_SUCCESS != err)
01193           return err;
01194      if (tp_wrt - tp_ent != 1)
01195           return iBase_FAILURE;
01196      switch (tp_wrt) {
01197      case iBase_REGION:
01198           return getEntNrmlSense(ent, wrt_ent, sense);
01199           break;
01200      case iBase_FACE:
01201           return getEgFcSense(ent, wrt_ent, sense);
01202      case iBase_EDGE:
01203           return getEgVtxSense(wrt_ent, ent, ent, sense);
01204      case iBase_VERTEX:
01205      case iBase_ALL_TYPES:
01206           return iBase_FAILURE;
01207      }
01208      return iBase_FAILURE;
01209 }
01210
01211 inline FBiGeom::Error FBiGeom::getArrSense(const EntityHandle *ent, int num_ents,
01212                                        EntityHandle wrt_ent, int *sense) const
01213 {
01214      EntityType tp_wrt, tp_ent;
01215      Error err = getEntType(wrt_ent, tp_wrt);
01216      if (iBase_SUCCESS != err)
01217           return err;
01218      err = getEntType(ent[0], tp_ent);
01219      if (iBase_SUCCESS != err)
01220           return err;
01221      if (tp_wrt - tp_ent != 1)
01222           return iBase_FAILURE;
01223      std::vector<EntityHandle> dum_wrts(num_ents, wrt_ent);
01224      switch (tp_wrt) {
01225      case iBase_REGION:
01226           return getArrNrmlSense(ent, num_ents, &dum_wrts[0], num_ents, sense);
01227           break;
01228      case iBase_FACE:
01229           return getEgFcArrSense(ent, num_ents, &dum_wrts[0], num_ents, sense);
01230           break;
01231      case iBase_EDGE:
01232           return getEgVtxArrSense(&dum_wrts[0], num_ents, ent, num_ents, ent,
01233                                   num_ents, sense);
01234           break;
01235      case iBase_VERTEX:
01236      case iBase_ALL_TYPES:
01237           return iBase_FAILURE;
01238           break;
01239      }
01240      return iBase_FAILURE;
01241 }
01242
01243 inline FBiGeom::Error FBiGeom::getEntNrmlSense(EntityHandle face,
01244           EntityHandle region, int& sense) const
01245 {
01246      int err;
01247      FBiGeom_getEntNrmlSense(mInstance, face, region, &sense, &err);
01248      return (Error) err;
01249 }
01250
01251 inline FBiGeom::Error FBiGeom::getEgFcSense(EntityHandle edge, EntityHandle face,
01252                                         int& sense) const
01253 {
01254      int err;
01255      FBiGeom_getEgFcSense(mInstance, edge, face, &sense, &err);
01256      return (Error) err;
01257 }
01258
01259 inline FBiGeom::Error FBiGeom::getEgVtxSense(EntityHandle edge, EntityHandle vtx1,
01260           EntityHandle vtx2, int& sense) const
01261 {
01262      int err;
01263      FBiGeom_getEgVtxSense(mInstance, edge, vtx1, vtx2, &sense, &err);
01264      return (Error) err;
01265 }
01266
01267 inline FBiGeom::Error FBiGeom::getArrNrmlSense(const EntityHandle* faces,
01268           int faces_size, const EntityHandle* vols, int vols_size, int* senses_out) const
01269 {
01270      int err, alloc = std::max(vols_size, faces_size), size = 0;
01271      FBiGeom_getArrNrmlSense(mInstance, faces, faces_size, vols, vols_size,
01272                            &senses_out, &alloc, &size, &err);
01273      return (Error) err;
01274 }
01275
01276 inline FBiGeom::Error FBiGeom::getEgFcArrSense(const EntityHandle* edges,
01277           int edges_size, const EntityHandle* faces, int faces_size, int* senses_out) const
01278 {
01279      int err, alloc = std::max(edges_size, faces_size), size = 0;
01280      FBiGeom_getEgFcArrSense(mInstance, edges, edges_size, faces, faces_size,
01281                            &senses_out, &alloc, &size, &err);
01282      return (Error) err;
01283 }
01284
01285 inline FBiGeom::Error FBiGeom::getEgVtxArrSense(const EntityHandle* edges,
01286           int edges_size, const EntityHandle* vertices1, int vertices1_size,
01287           const EntityHandle* vertices2, int vertices2_size, int* senses_out) const
01288 {
01289      int err, alloc = std::max(vertices1_size,
01290                                std::max(vertices2_size, edges_size)), size = 0;
01291      FBiGeom_getEgVtxArrSense(mInstance, edges, edges_size, vertices1,
01292                             vertices1_size, vertices2, vertices2_size, &senses_out, &alloc, &size,
01293                             &err);
01294      return (Error) err;
01295 }
01296
01297 inline FBiGeom::Error FBiGeom::measure(const EntityHandle* entities,
01298                                    int entities_size, double* measures) const
01299 {
01300      int err, alloc = entities_size, size = 0;
01301      FBiGeom_measure(mInstance, entities, entities_size, &measures, &alloc, &size,
01302                    &err);
01303      return (Error) err;
01304 }
01305
01306 inline FBiGeom::Error FBiGeom::getFaceType(EntityHandle face, std::string& type) const
01307 {
01308      char buffer[1024];
01309      int err, len = sizeof(buffer);
01310      FBiGeom_getFaceType(mInstance, face, buffer, &err, &len);
01311      type = std::string(buffer, len);
01312      return (Error) err;
01313 }
01314
01315 inline FBiGeom::Error FBiGeom::isEntParametric(EntityHandle entity,
01316           bool& parametric) const
01317 {
01318      int err, result;
01319      FBiGeom_isEntParametric(mInstance, entity, &result, &err);
01320      parametric = (result != 0);
01321      return (Error) err;
01322 }
01323
01324 inline FBiGeom::Error FBiGeom::isArrParametric(const EntityHandle* entities,
01325           int entities_size, int* is_parametric) const
01326 {
01327      int err, alloc = entities_size, size = 1;
01328      FBiGeom_isArrParametric(mInstance, entities, entities_size, &is_parametric,
01329                            &alloc, &size, &err);
01330      return (Error) err;
01331 }
01332
01333 inline FBiGeom::Error FBiGeom::getEntUVtoXYZ(EntityHandle face, double u, double v,
01334           double& x, double& y, double& z) const
01335 {
01336      int err;
01337      FBiGeom_getEntUVtoXYZ(mInstance, face, u, v, &x, &y, &z, &err);
01338      return (Error) err;
01339 }
01340
01341 inline FBiGeom::Error FBiGeom::getEntUtoXYZ(EntityHandle edge, double u, double& x,
01342                                         double& y, double& z) const
01343 {
01344      int err;
01345      FBiGeom_getEntUtoXYZ(mInstance, edge, u, &x, &y, &z, &err);
01346      return (Error) err;
01347 }
01348
01349 inline FBiGeom::Error FBiGeom::getArrUVtoXYZ(const EntityHandle* faces,
01350           int faces_size, StorageOrder order, const double* uv, int uv_size,
01351           double* xyz) const
01352 {
01353      int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
01354      FBiGeom_getArrUVtoXYZ(mInstance, faces, faces_size, order, uv, uv_size, &xyz,
01355                          &alloc, &size, &err);
01356      return (Error) err;
01357 }
01358
01359 inline FBiGeom::Error FBiGeom::getArrUtoXYZ(const EntityHandle* edges,
01360                                         int edges_size, const double* u, int u_size, StorageOrder order,
01361                                         double* xyz) const
01362 {
01363      int err, alloc = std::max(3 * u_size, 3 * edges_size), size = 0;
01364      FBiGeom_getArrUtoXYZ(mInstance, edges, edges_size, u, u_size, order, &xyz,
01365                         &alloc, &size, &err);
01366      return (Error) err;
01367 }
01368
01369 inline FBiGeom::Error FBiGeom::getEntXYZtoUV(EntityHandle face, double x, double y,
01370           double z, double& u, double& v) const
01371 {
01372      int err;
01373      FBiGeom_getEntXYZtoUV(mInstance, face, x, y, z, &u, &v, &err);
01374      return (Error) err;
01375 }
01376
01377 inline FBiGeom::Error FBiGeom::getEntXYZtoU(EntityHandle edge, double x, double y,
01378                                         double z, double& u) const
01379 {
01380      int err;
01381      FBiGeom_getEntXYZtoU(mInstance, edge, x, y, z, &u, &err);
01382      return (Error) err;
01383 }
01384
01385 inline FBiGeom::Error FBiGeom::getArrXYZtoUV(const EntityHandle* faces,
01386           int faces_size, StorageOrder order, const double* coords, int coords_size,
01387           double* uv) const
01388 {
01389      int err, alloc = std::max(2 * coords_size / 3, 2 * faces_size), size = 0;
01390      FBiGeom_getArrXYZtoUV(mInstance, faces, faces_size, order, coords, coords_size,
01391                          &uv, &alloc, &size, &err);
01392      return (Error) err;
01393 }
01394
01395 inline FBiGeom::Error FBiGeom::getArrXYZtoU(const EntityHandle* edges,
01396                                         int edges_size, StorageOrder order, const double* coords, int coords_size,
01397                                         double* u) const
01398 {
01399      int err, alloc = std::max(coords_size / 3, edges_size), size = 0;
01400      FBiGeom_getArrXYZtoU(mInstance, edges, edges_size, order, coords, coords_size,
01401                         &u, &alloc, &size, &err);
01402      return (Error) err;
01403 }
01404
01405 inline FBiGeom::Error FBiGeom::getEntXYZtoUVHint(EntityHandle face, double x,
01406           double y, double z, double& u, double& v) const
01407 {
01408      int err;
01409      FBiGeom_getEntXYZtoUVHint(mInstance, face, x, y, z, &u, &v, &err);
01410      return (Error) err;
01411 }
01412
01413 inline FBiGeom::Error FBiGeom::getArrXYZtoUVHint(const EntityHandle* faces,
01414           int faces_size, StorageOrder order, const double* coords, int coords_size,
01415           double* uv) const
01416 {
01417      int err, alloc = std::max(2 * coords_size / 3, 2 * faces_size), size = 0;
01418      FBiGeom_getArrXYZtoUVHint(mInstance, faces, faces_size, order, coords,
01419                              coords_size, &uv, &alloc, &size, &err);
01420      return (Error) err;
01421 }
01422
01423 inline FBiGeom::Error FBiGeom::getEntNrmlUV(EntityHandle face, double u, double v,
01424                                         double& i, double& j, double& k) const
01425 {
01426      int err;
01427      FBiGeom_getEntNrmlUV(mInstance, face, u, v, &i, &j, &k, &err);
01428      return (Error) err;
01429 }
01430
01431 inline FBiGeom::Error FBiGeom::getArrNrmlUV(const EntityHandle* faces,
01432                                         int faces_size, StorageOrder order, const double* uv, int uv_size,
01433                                         double* normals) const
01434 {
01435      int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
01436      FBiGeom_getArrNrmlUV(mInstance, faces, faces_size, order, uv, uv_size,
01437                         &normals, &alloc, &size, &err);
01438      return (Error) err;
01439 }
01440
01441 inline FBiGeom::Error FBiGeom::getEntTgntU(EntityHandle edge, double u, double& i,
01442                                        double& j, double& k) const
01443 {
01444      int err;
01445      FBiGeom_getEntTgntU(mInstance, edge, u, &i, &j, &k, &err);
01446      return (Error) err;
01447 }
01448
01449 inline FBiGeom::Error FBiGeom::getArrTgntU(const EntityHandle* edges,
01450                                        int edges_size, StorageOrder order, const double* u, int u_size,
01451                                        double* normals) const
01452 {
01453      int err, alloc = std::max(3 * u_size, 3 * edges_size), size = 0;
01454      FBiGeom_getArrTgntU(mInstance, edges, edges_size, order, u, u_size, &normals,
01455                        &alloc, &size, &err);
01456      return (Error) err;
01457 }
01458
01459 inline FBiGeom::Error FBiGeom::getEnt1stDrvt(EntityHandle handle, double u,
01460           double v, double& du_i, double& du_j, double& du_k, double& dv_i,
01461           double& dv_j, double& dv_k) const
01462 {
01463      int err, du_alloc = 3, dv_alloc = 3, du_size = 0, dv_size = 0;
01464      double du[3], dv[3], *du_ptr = du, *dv_ptr = dv;
01465      FBiGeom_getEnt1stDrvt(mInstance, handle, u, v, &du_ptr, &du_alloc, &du_size,
01466                          &dv_ptr, &dv_alloc, &dv_size, &err);
01467      du_i = du[0];
01468      du_j = du[1];
01469      du_k = du[2];
01470      dv_i = dv[0];
01471      dv_j = dv[1];
01472      dv_k = dv[2];
01473      return (Error) err;
01474 }
01475
01476 inline FBiGeom::Error FBiGeom::getEnt2ndDrvt(EntityHandle handle, double u,
01477           double v, double& duu_i, double& duu_j, double& duu_k, double& dvv_i,
01478           double& dvv_j, double& dvv_k, double& duv_i, double& duv_j, double& duv_k) const
01479 {
01480      int err, uu_alloc = 3, uv_alloc = 3, vv_alloc = 3, uu_size = 0, uv_size = 0,
01481                                        vv_size = 0;
01482      double uu[3], uv[3], vv[3], *uu_ptr = uu, *vv_ptr = vv, *uv_ptr = uv;
01483      FBiGeom_getEnt2ndDrvt(mInstance, handle, u, v, &uu_ptr, &uu_alloc, &uu_size,
01484                          &vv_ptr, &vv_alloc, &vv_size, &uv_ptr, &uv_alloc, &uv_size, &err);
01485      duu_i = uu[0];
01486      duu_j = uu[1];
01487      duu_k = uu[2];
01488      dvv_i = vv[0];
01489      dvv_j = vv[1];
01490      dvv_k = vv[2];
01491      duv_i = uv[0];
01492      duv_j = uv[1];
01493      duv_k = uv[2];
01494      return (Error) err;
01495 }
01496
01497 inline FBiGeom::Error FBiGeom::getArr1stDrvt(const EntityHandle* entities,
01498           int entities_size, StorageOrder order, const double* uv, int uv_size,
01499           double* dvtr_u, double* dvtr_v) const
01500 {
01501      int err, allocu = std::max(3 * uv_size / 2, 3 * entities_size), sizeu = 0,
01502                        allocv = allocu, sizev = 0;
01503      std::vector<int> offset1(std::max(uv_size / 2, entities_size) + 1);
01504      std::vector<int> offset2(std::max(uv_size / 2, entities_size) + 1);
01505      int alloc1 = offset1.size(), size1 = 0, *ptr1 = &offset1[0];
01506      int alloc2 = offset2.size(), size2 = 0, *ptr2 = &offset2[0];
01507      FBiGeom_getArr1stDrvt(mInstance, entities, entities_size, order, uv, uv_size,
01508                          &dvtr_u, &allocu, &sizeu, &ptr1, &alloc1, &size1, &dvtr_v, &allocv,
01509                          &sizev, &ptr2, &alloc2, &size2, &err);
01510      return (Error) err;
01511 }
01512
01513 inline FBiGeom::Error FBiGeom::getArr2ndDrvt(const EntityHandle* entities,
01514           int entities_size, StorageOrder order, const double* uv, int uv_size,
01515           double* dvtr_uu, double* dvtr_vv, double* dvtr_uv) const
01516 {
01517      int err, allocuu = std::max(3 * uv_size / 2, 3 * entities_size), sizeuu = 0,
01518                         allocvv = allocuu, sizevv = 0, allocuv = allocuu, sizeuv = 0;
01519      std::vector<int> offset1(std::max(uv_size / 2, entities_size) + 1);
01520      std::vector<int> offset2(std::max(uv_size / 2, entities_size) + 1);
01521      std::vector<int> offset3(std::max(uv_size / 2, entities_size) + 1);
01522      int alloc1 = offset1.size(), size1 = 0, *ptr1 = &offset1[0];
01523      int alloc2 = offset2.size(), size2 = 0, *ptr2 = &offset2[0];
01524      int alloc3 = offset3.size(), size3 = 0, *ptr3 = &offset3[0];
01525      FBiGeom_getArr2ndDrvt(mInstance, entities, entities_size, order, uv, uv_size,
01526                          &dvtr_uu, &allocuu, &sizeuu, &ptr1, &alloc1, &size1, &dvtr_vv, &allocvv,
01527                          &sizevv, &ptr2, &alloc2, &size2, &dvtr_uv, &allocuv, &sizeuv, &ptr3,
01528                          &alloc3, &size3, &err);
01529      return (Error) err;
01530 }
01531
01532 inline FBiGeom::Error FBiGeom::getFcCvtrUV(EntityHandle face, double u, double v,
01533                                        double& i1, double& j1, double& k1, double& i2, double& j2, double& k2) const
01534 {
01535      int err;
01536      FBiGeom_getFcCvtrUV(mInstance, face, u, v, &i1, &j1, &k1, &i2, &j2, &k2, &err);
01537      return (Error) err;
01538 }
01539
01540 inline FBiGeom::Error FBiGeom::getFcArrCvtrUV(const EntityHandle* faces,
01541           int faces_size, StorageOrder order, const double* uv, int uv_size,
01542           double* cvtr1, double* cvtr2) const
01543 {
01544      int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
01545      FBiGeom_getFcArrCvtrUV(mInstance, faces, faces_size, order, uv, uv_size,
01546                           &cvtr1, &alloc, &size, &cvtr2, &alloc, &size, &err);
01547      return (Error) err;
01548 }
01549
01550 inline FBiGeom::Error FBiGeom::isEntPeriodic(EntityHandle entity, bool& in_u,
01551           bool& in_v) const
01552 {
01553      int err, u, v;
01554      FBiGeom_isEntPeriodic(mInstance, entity, &u, &v, &err);
01555      in_u = (u != 0);
01556      in_v = (v != 0);
01557      return (Error) err;
01558 }
01559
01560 inline FBiGeom::Error FBiGeom::isArrPeriodic(const EntityHandle* entities,
01561           int entities_size, int* in_uv) const
01562 {
01563      int err, alloc = 2 * entities_size, size = 0;
01564      FBiGeom_isArrPeriodic(mInstance, entities, entities_size, &in_uv, &alloc,
01565                          &size, &err);
01566      return (Error) err;
01567 }
01568
01569 inline FBiGeom::Error FBiGeom::isFcDegenerate(EntityHandle face,
01570           bool& is_degenerate) const
01571 {
01572      int err, result;
01573      FBiGeom_isFcDegenerate(mInstance, face, &result, &err);
01574      is_degenerate = (result != 0);
01575      return (Error) err;
01576 }
01577
01578 inline FBiGeom::Error FBiGeom::isFcArrDegenerate(const EntityHandle* faces,
01579           int faces_size, int* degenerate) const
01580 {
01581      int err, alloc = faces_size, size = 0;
01582      FBiGeom_isFcArrDegenerate(mInstance, faces, faces_size, &degenerate, &alloc,
01583                              &size, &err);
01584      return (Error) err;
01585 }
01586
01587 inline FBiGeom::Error FBiGeom::getTolerance(int& type_out, double& tolerance_out) const
01588 {
01589      int err=0;
01590      FBiGeom_getTolerance(mInstance, &type_out, &tolerance_out, &err);
01591      return (Error) err;
01592 }
01593
01594 inline FBiGeom::Error FBiGeom::getEntTolerance(EntityHandle entity,
01595           double& tolerance) const
01596 {
01597      int err=0;
01598      FBiGeom_getEntTolerance(mInstance, entity, &tolerance, &err);
01599      return (Error) err;
01600 }
01601
01602 inline FBiGeom::Error FBiGeom::getArrTolerance(const EntityHandle* entities,
01603           int entities_size, double* tolerances) const
01604 {
01605      int err, alloc = entities_size, size = 0;
01606      FBiGeom_getArrTolerance(mInstance, entities, entities_size, &tolerances,
01607                            &alloc, &size, &err);
01608      return (Error) err;
01609 }
01610
01611 inline FBiGeom::Error FBiGeom::getEntUVRange(EntityHandle face, double& u_min,
01612           double& v_min, double& u_max, double& v_max) const
01613 {
01614      int err;
01615      FBiGeom_getEntUVRange(mInstance, face, &u_min, &v_min, &u_max, &v_max, &err);
01616      return (Error) err;
01617 }
01618
01619 inline FBiGeom::Error FBiGeom::getEntURange(EntityHandle edge, double& u_min,
01620                                         double& u_max) const
01621 {
01622      int err;
01623      FBiGeom_getEntURange(mInstance, edge, &u_min, &u_max, &err);
01624      return (Error) err;
01625 }
01626
01627 inline FBiGeom::Error FBiGeom::getArrUVRange(const EntityHandle* faces,
01628           int faces_size, StorageOrder order, double* uv_min, double* uv_max) const
01629 {
01630      int err, alloc = faces_size, size = 0;
01631      FBiGeom_getArrUVRange(mInstance, faces, faces_size, order, &uv_min, &alloc,
01632                          &size, &uv_max, &alloc, &size, &err);
01633      return (Error) err;
01634 }
01635
01636 inline FBiGeom::Error FBiGeom::getArrURange(const EntityHandle* edges,
01637                                         int edges_size, double* u_min, double* u_max) const
01638 {
01639      int err, alloc = edges_size, size = 0;
01640      FBiGeom_getArrURange(mInstance, edges, edges_size, &u_min, &alloc, &size,
01641                         &u_max, &alloc, &size, &err);
01642      return (Error) err;
01643 }
01644
01645 inline FBiGeom::Error FBiGeom::getEntUtoUV(EntityHandle edge, EntityHandle face,
01646                                        double edge_u, double& face_u, double& face_v) const
01647 {
01648      int err;
01649      FBiGeom_getEntUtoUV(mInstance, edge, face, edge_u, &face_u, &face_v, &err);
01650      return (Error) err;
01651 }
01652
01653 inline FBiGeom::Error FBiGeom::getVtxToUV(EntityHandle vertex, EntityHandle face,
01654                                       double& u, double& v) const
01655 {
01656      int err;
01657      FBiGeom_getVtxToUV(mInstance, vertex, face, &u, &v, &err);
01658      return (Error) err;
01659 }
01660
01661 inline FBiGeom::Error FBiGeom::getVtxToU(EntityHandle vertex, EntityHandle edge,
01662                                      double& u) const
01663 {
01664      int err;
01665      FBiGeom_getVtxToU(mInstance, vertex, edge, &u, &err);
01666      return (Error) err;
01667 }
01668
01669 inline FBiGeom::Error FBiGeom::getArrUtoUV(const EntityHandle* edges,
01670                                        int edges_size, const EntityHandle* faces, int faces_size,
01671                                        const double* edge_u, int edge_u_size, StorageOrder order, double* face_uv) const
01672 {
01673      int err, alloc = std::max(edge_u_size, std::max(edges_size, faces_size));
01674      int size = 0;
01675      FBiGeom_getArrUtoUV(mInstance, edges, edges_size, faces, faces_size, edge_u,
01676                        edge_u_size, order, &face_uv, &alloc, &size, &err);
01677      return (Error) err;
01678 }
01679
01680 inline FBiGeom::Error FBiGeom::getVtxArrToUV(const EntityHandle* vertices,
01681           int vertices_size, const EntityHandle* faces, int faces_size,
01682           StorageOrder order, double* face_uv) const
01683 {
01684      int err, alloc = std::max(vertices_size, faces_size), size = 0;
01685      FBiGeom_getVtxArrToUV(mInstance, vertices, vertices_size, faces, faces_size,
01686                          order, &face_uv, &alloc, &size, &err);
01687      return (Error) err;
01688 }
01689
01690 inline FBiGeom::Error FBiGeom::getVtxArrToU(const EntityHandle* vertices,
01691                                         int vertices_size, const EntityHandle* edges, int edges_size,
01692                                         double* edge_u) const
01693 {
01694      int err, alloc = std::max(vertices_size, edges_size), size = 0;
01695      FBiGeom_getVtxArrToU(mInstance, vertices, vertices_size, edges, edges_size,
01696                         &edge_u, &alloc, &size, &err);
01697      return (Error) err;
01698 }
01699
01700 inline FBiGeom::Error FBiGeom::deleteAll()
01701 {
01702      int err;
01703      FBiGeom_deleteAll(mInstance, &err);
01704      return (Error) err;
01705 }
01706
01707 inline FBiGeom::Error FBiGeom::copyEnt(EntityHandle source, EntityHandle& copy)
01708 {
01709      int err;
01710      FBiGeom_copyEnt(mInstance, source, &copy, &err);
01711      return (Error) err;
01712 }
01713
01714 inline FBiGeom::Error FBiGeom::createSphere(double radius, EntityHandle& sphere)
01715 {
01716      int err;
01717      FBiGeom_createSphere(mInstance, radius, &sphere, &err);
01718      return (Error) err;
01719 }
01720
01721 inline FBiGeom::Error FBiGeom::createPrism(double height, int num_sides,
01722                                        double maj_radius, double min_radius, EntityHandle& prism)
01723 {
01724      int err;
01725      FBiGeom_createPrism(mInstance, height, num_sides, maj_radius, min_radius,
01726                        &prism, &err);
01727      return (Error) err;
01728 }
01729
01730 inline FBiGeom::Error FBiGeom::createBrick(double x, double y, double z,
01731                                        EntityHandle& brick)
01732 {
01733      int err;
01734      FBiGeom_createBrick(mInstance, x, y, z, &brick, &err);
01735      return (Error) err;
01736 }
01737
01738 inline FBiGeom::Error FBiGeom::createCylinder(double height, double maj_rad,
01739           double min_rad, EntityHandle& cylinder)
01740 {
01741      int err;
01742      FBiGeom_createCylinder(mInstance, height, maj_rad, min_rad, &cylinder, &err);
01743      return (Error) err;
01744 }
01745
01746 inline FBiGeom::Error FBiGeom::createTorus(double maj_rad, double min_rad,
01747                                        EntityHandle& torus)
01748 {
01749      int err;
01750      FBiGeom_createTorus(mInstance, maj_rad, min_rad, &torus, &err);
01751      return (Error) err;
01752 }
01753
01754 inline FBiGeom::Error FBiGeom::moveEnt(EntityHandle entity, double x, double y,
01755                                    double z)
01756 {
01757      int err;
01758      FBiGeom_moveEnt(mInstance, entity, x, y, z, &err);
01759      return (Error) err;
01760 }
01761
01762 inline FBiGeom::Error FBiGeom::rotateEnt(EntityHandle entity, double angle,
01763                                      double axis_x, double axis_y, double axis_z)
01764 {
01765      int err;
01766      FBiGeom_rotateEnt(mInstance, entity, angle, axis_x, axis_y, axis_z, &err);
01767      return (Error) err;
01768 }
01769
01770 inline FBiGeom::Error FBiGeom::reflectEnt(EntityHandle entity, double norm_x,
01771                                       double norm_y, double norm_z)
01772 {
01773      int err;
01774      FBiGeom_reflectEnt(mInstance, entity, norm_x, norm_y, norm_z, &err);
01775      return (Error) err;
01776 }
01777
01778 inline FBiGeom::Error FBiGeom::scaleEnt(EntityHandle entity, double x_factor,
01779                                     double y_factor, double z_factor)
01780 {
01781      int err;
01782      FBiGeom_scaleEnt(mInstance, entity, x_factor, y_factor, z_factor, &err);
01783      return (Error) err;
01784 }
01785
01786 inline FBiGeom::Error FBiGeom::uniteEnts(const EntityHandle* entities,
01787                                      int entities_size, EntityHandle& result_entity)
01788 {
01789      int err;
01790      FBiGeom_uniteEnts(mInstance, entities, entities_size, &result_entity, &err);
01791      return (Error) err;
01792 }
01793
01794 inline FBiGeom::Error FBiGeom::subtractEnts(EntityHandle blank, EntityHandle tool,
01795                                         EntityHandle& result)
01796 {
01797      int err;
01798      FBiGeom_subtractEnts(mInstance, blank, tool, &result, &err);
01799      return (Error) err;
01800 }
01801
01802 inline FBiGeom::Error FBiGeom::intersectEnts(EntityHandle entity1,
01803           EntityHandle entity2, EntityHandle& result)
01804 {
01805      int err;
01806      FBiGeom_intersectEnts(mInstance, entity1, entity2, &result, &err);
01807      return (Error) err;
01808 }
01809
01810 inline FBiGeom::Error FBiGeom::sectionEnt(EntityHandle entity, double plane_x,
01811                                       double plane_y, double plane_z, double offset, bool reverse,
01812                                       EntityHandle& result)
01813 {
01814      int err;
01815      FBiGeom_sectionEnt(mInstance, entity, plane_x, plane_y, plane_z, offset,
01816                       reverse, &result, &err);
01817      return (Error) err;
01818 }
01819
01820 inline FBiGeom::Error FBiGeom::sweepEntAboutAxis(EntityHandle entity, double angle,
01821           double axis_x, double axis_y, double axis_z, EntityHandle& swept_entity)
01822 {
01823      int err;
01824      FBiGeom_sweepEntAboutAxis(mInstance, entity, angle, axis_x, axis_y, axis_z,
01825                              &swept_entity, &err);
01826      return (Error) err;
01827 }
01828
01829 inline FBiGeom::Error FBiGeom::imprintEnts(const EntityHandle* entities,
01830                                        int entities_size)
01831 {
01832      int err;
01833      FBiGeom_imprintEnts(mInstance, entities, entities_size, &err);
01834      return (Error) err;
01835 }
01836
01837 inline FBiGeom::Error FBiGeom::mergeEnts(const EntityHandle* entities,
01838                                      int entities_size, double tolerance)
01839 {
01840      int err;
01841      FBiGeom_mergeEnts(mInstance, entities, entities_size, tolerance, &err);
01842      return (Error) err;
01843 }
01844
01845
01846 FBiGeom::Error
01847 FBiGeom::getErrorType() const
01848 {
01849      int err;
01850      FBiGeom_getErrorType( mInstance, &err );
01851      return (Error)err;
01852 }
01853
01854 std::string
01855 FBiGeom::getDescription() const
01856 {
01857      std::vector<char> buffer(1024);
01858      FBiGeom_getDescription( mInstance, &buffer[0], buffer.size() );
01859      return std::string(&buffer[0]);
01860 }
01861
01862
01863
01864
01865 FBiGeom::EntitySetHandle
01866 FBiGeom::getRootSet() const
01867 {
01868      int err;
01869      EntitySetHandle result;
01870      FBiGeom_getRootSet( mInstance, &result, &err );
01871      return iBase_SUCCESS == err ? result : 0;
01872 }
01873
01874
01875
01876 FBiGeom::Error
01877 FBiGeom::createEntSet( bool is_list, EntitySetHandle& handle_out )
01878 {
01879      int err;
01880      FBiGeom_createEntSet( mInstance, is_list, &handle_out, &err );
01881      return (Error)err;
01882 }
01883
01884 FBiGeom::Error
01885 FBiGeom::destroyEntSet( EntitySetHandle handle )
01886 {
01887      int err;
01888      FBiGeom_destroyEntSet( mInstance, handle, &err );
01889      return (Error)err;
01890 }
01891
01892 FBiGeom::Error
01893 FBiGeom::isList( EntitySetHandle handle, bool& is_list )
01894 {
01895      int err, result;
01896      FBiGeom_isList( mInstance, handle, &result, &err );
01897      is_list = (result != 0);
01898      return (Error)err;
01899 }
01900
01901 FBiGeom::Error
01902 FBiGeom::getNumEntSets( EntitySetHandle set, int num_hops, int& num_sets_out ) const
01903 {
01904      int err;
01905      FBiGeom_getNumEntSets( mInstance, set, num_hops, &num_sets_out, &err );
01906      return (Error)err;
01907 }
01908
01909 FBiGeom::Error
01910 FBiGeom::getEntSets( EntitySetHandle set, int num_hops,
01911                    std::vector<EntitySetHandle>& contained_sets_out ) const
01912 {
01913      int err, count;
01914      FBiGeom_getNumEntSets( mInstance, set, num_hops, &count, &err );
01915      if (iBase_SUCCESS != err)
01916           return (Error)err;
01917      contained_sets_out.resize(count);
01918      int alloc = contained_sets_out.size(), size;
01919      EntitySetHandle* ptr = &contained_sets_out[0];
01920      FBiGeom_getEntSets( mInstance, set, num_hops, &ptr, &alloc, &size, &err );
01921      return (Error)err;
01922 }
01923
01924 FBiGeom::Error
01925 FBiGeom::addEntToSet( EntityHandle entity, EntitySetHandle set )
01926 {
01927      int err;
01928      FBiGeom_addEntToSet( mInstance, entity,set, &err );
01929      return (Error)err;
01930 }
01931
01932 FBiGeom::Error
01933 FBiGeom::rmvEntFromSet( EntityHandle entity, EntitySetHandle set )
01934 {
01935      int err;
01936      FBiGeom_rmvEntFromSet( mInstance, entity,set, &err );
01937      return (Error)err;
01938 }
01939
01940 FBiGeom::Error
01941 FBiGeom::addEntArrToSet( const EntityHandle* entity_handles,
01942                        int entity_handles_size,
01943                        EntitySetHandle entity_set )
01944 {
01945      int err;
01946      FBiGeom_addEntArrToSet( mInstance, entity_handles, entity_handles_size, entity_set, &err );
01947      return (Error)err;
01948 }
01949
01950 FBiGeom::Error
01951 FBiGeom::rmvEntArrFromSet( const EntityHandle* entity_handles,
01952                          int entity_handles_size,
01953                          EntitySetHandle entity_set )
01954 {
01955      int err;
01956      FBiGeom_rmvEntArrFromSet( mInstance, entity_handles, entity_handles_size, entity_set, &err );
01957      return (Error)err;
01958 }
01959
01960 FBiGeom::Error
01961 FBiGeom::addEntSet( EntitySetHandle to_add, EntitySetHandle add_to )
01962 {
01963      int err;
01964      FBiGeom_addEntSet( mInstance, to_add, add_to, &err );
01965      return (Error)err;
01966 }
01967
01968 FBiGeom::Error
01969 FBiGeom::rmvEntSet( EntitySetHandle to_rmv, EntitySetHandle rmv_from )
01970 {
01971      int err;
01972      FBiGeom_rmvEntSet( mInstance, to_rmv, rmv_from, &err );
01973      return (Error)err;
01974 }
01975
01976 FBiGeom::Error
01977 FBiGeom::isEntContained( EntitySetHandle set, EntityHandle ent, bool& contained_out ) const
01978 {
01979      int err, result;
01980      FBiGeom_isEntContained( mInstance, set, ent, &result, &err );
01981      contained_out = (result != 0);
01982      return (Error)err;
01983 }
01984
01985 FBiGeom::Error
01986 FBiGeom::isEntArrContained( EntitySetHandle containing_set,
01987                           const EntityHandle* entity_handles,
01988                           int num_entity_handles,
01989                           bool* is_contained_out ) const
01990 {
01991      int err, *ptr = 0, alloc = 0, size = 0;
01992      FBiGeom_isEntArrContained( mInstance, containing_set,
01993                               entity_handles, num_entity_handles,
01994                               &ptr, &alloc, &size, &err );
01995      if (iBase_SUCCESS != err)
01996           return (Error)err;
01997      for (int i = 0; i < num_entity_handles; ++i)
01998           is_contained_out[i] = (ptr[i] != 0);
01999      free(ptr);
02000      return iBase_SUCCESS;
02001 }
02002
02003 FBiGeom::Error
02004 FBiGeom::isEntSetContained( EntitySetHandle containing_set,
02005                           EntitySetHandle contained_set,
02006                           bool& contained_out ) const
02007 {
02008      int err, result;
02009      FBiGeom_isEntSetContained( mInstance, containing_set, contained_set, &result, &err );
02010      contained_out = (result != 0);
02011      return (Error)err;
02012 }
02013
02014 FBiGeom::Error
02015 FBiGeom::addPrntChld( EntitySetHandle parent, EntitySetHandle child )
02016 {
02017      int err;
02018      FBiGeom_addPrntChld( mInstance, parent, child, &err );
02019      return (Error)err;
02020 }
02021
02022 FBiGeom::Error
02023 FBiGeom::rmvPrntChld( EntitySetHandle parent, EntitySetHandle child )
02024 {
02025      int err;
02026      FBiGeom_rmvPrntChld( mInstance, parent, child, &err );
02027      return (Error)err;
02028 }
02029
02030 FBiGeom::Error
02031 FBiGeom::isChildOf( EntitySetHandle parent, EntitySetHandle child, bool& is_child_out ) const
02032 {
02033      int err, result;
02034      FBiGeom_isChildOf( mInstance, parent, child, &result, &err );
02035      is_child_out = (result != 0);
02036      return (Error)err;
02037 }
02038
02039 FBiGeom::Error
02040 FBiGeom::getNumChld( EntitySetHandle parent, int num_hops, int& num_child_out ) const
02041 {
02042      int err;
02043      FBiGeom_getNumChld( mInstance, parent, num_hops, &num_child_out, &err );
02044      return (Error)err;
02045 }
02046
02047 FBiGeom::Error
02048 FBiGeom::getNumPrnt( EntitySetHandle child, int num_hops, int& num_parent_out ) const
02049 {
02050      int err;
02051      FBiGeom_getNumPrnt( mInstance, child, num_hops, &num_parent_out, &err );
02052      return (Error)err;
02053 }
02054
02055 FBiGeom::Error
02056 FBiGeom::getChldn( EntitySetHandle parent, int num_hops,
02057                  std::vector<EntitySetHandle>& children_out ) const
02058 {
02059      int err, count;
02060      FBiGeom_getNumChld( mInstance, parent, num_hops, &count, &err );
02061      if (iBase_SUCCESS != err)
02062           return (Error)err;
02063      children_out.resize(count);
02064      int alloc = children_out.size(), size;
02065      EntitySetHandle* ptr = &children_out[0];
02066      FBiGeom_getEntSets( mInstance, parent, num_hops, &ptr, &alloc, &size, &err );
02067      return (Error)err;
02068 }
02069
02070 FBiGeom::Error
02071 FBiGeom::getPrnts( EntitySetHandle child, int num_hops,
02072                  std::vector<EntitySetHandle>& parents_out ) const
02073 {
02074      int err, count;
02075      FBiGeom_getNumPrnt( mInstance, child, num_hops, &count, &err );
02076      if (iBase_SUCCESS != err)
02077           return (Error)err;
02078      parents_out.resize(count);
02079      int alloc = parents_out.size(), size;
02080      EntitySetHandle* ptr = &parents_out[0];
02081      FBiGeom_getEntSets( mInstance, child, num_hops, &ptr, &alloc, &size, &err );
02082      return (Error)err;
02083 }
02084
02085
02086 FBiGeom::Error
02087 FBiGeom::subtract( EntitySetHandle set1, EntitySetHandle set2,
02088                  EntitySetHandle& result_set_out )
02089 {
02090      int err;
02091      FBiGeom_subtract( mInstance, set1, set1, &result_set_out, &err );
02092      return (Error)err;
02093 }
02094
02095 FBiGeom::Error
02096 FBiGeom::intersect( EntitySetHandle set1, EntitySetHandle set2,
02097                   EntitySetHandle& result_set_out )
02098 {
02099      int err;
02100      FBiGeom_intersect( mInstance, set1, set1, &result_set_out, &err );
02101      return (Error)err;
02102 }
02103
02104 FBiGeom::Error
02105 FBiGeom::unite( EntitySetHandle set1, EntitySetHandle set2,
02106               EntitySetHandle& result_set_out )
02107 {
02108      int err;
02109      FBiGeom_unite( mInstance, set1, set1, &result_set_out, &err );
02110      return (Error)err;
02111 }
02112
02113
02114 FBiGeom::Error
02115 FBiGeom::createTag( const char* tag_name,
02116                   int tag_num_type_values,
02117                   TagValueType tag_type,
02118                   TagHandle& tag_handle_out )
02119 {
02120      int err;
02121      FBiGeom_createTag( mInstance, tag_name, tag_num_type_values, tag_type,
02122                       &tag_handle_out, &err, strlen(tag_name) );
02123      return (Error)err;
02124 }
02125
02126
02127 FBiGeom::Error
02128 FBiGeom::destroyTag( TagHandle tag_handle, bool forced )
02129 {
02130      int err;
02131      FBiGeom_destroyTag( mInstance, tag_handle, forced, &err );
02132      return (Error)err;
02133 }
02134
02135 FBiGeom::Error
02136 FBiGeom::getTagName( TagHandle tag_handle, std::string& name_out ) const
02137 {
02138      int err;
02139      char buffer[1024];
02140      memset( buffer, 0, sizeof(buffer) );
02141      FBiGeom_getTagName( mInstance, tag_handle, buffer, &err, sizeof(buffer) );
02142      name_out = buffer;
02143      return (Error)err;
02144 }
02145
02146 FBiGeom::Error
02147 FBiGeom::getTagSizeValues( TagHandle tag_handle, int& size_out ) const
02148 {
02149      int err;
02150      FBiGeom_getTagSizeValues( mInstance, tag_handle, &size_out, &err );
02151      return (Error)err;
02152 }
02153
02154 FBiGeom::Error
02155 FBiGeom::getTagSizeBytes( TagHandle tag_handle, int& size_out ) const
02156 {
02157      int err;
02158      FBiGeom_getTagSizeBytes( mInstance, tag_handle, &size_out, &err );
02159      return (Error)err;
02160 }
02161
02162 FBiGeom::Error
02163 FBiGeom::getTagHandle( const char* name, TagHandle& handle_out ) const
02164 {
02165      int err;
02166      FBiGeom_getTagHandle( mInstance, name, &handle_out, &err, strlen(name) );
02167      return (Error)err;
02168 }
02169
02170 FBiGeom::Error
02171 FBiGeom::getTagType( TagHandle tag_handle, TagValueType& type_out ) const
02172 {
02173      int err, result;
02174      FBiGeom_getTagType( mInstance, tag_handle, &result, &err );
02175      type_out = (TagValueType)result;
02176      return (Error)err;
02177 }
02178
02179
02180 FBiGeom::Error
02181 FBiGeom::setEntSetData( EntitySetHandle set_handle,
02182                       TagHandle tag_handle,
02183                       const void* tag_value )
02184 {
02185      int err, size = 1;
02186      FBiGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
02187      FBiGeom_setEntSetData( mInstance, set_handle, tag_handle,
02188                           tag_value, size, &err);
02189      return (Error)err;
02190 }
02191
02192 FBiGeom::Error
02193 FBiGeom::setEntSetIntData( EntitySetHandle set_handle,
02194                          TagHandle tag_handle,
02195                          int value )
02196 {
02197      int err;
02198      FBiGeom_setEntSetIntData( mInstance, set_handle, tag_handle, value, &err );
02199      return (Error)err;
02200 }
02201
02202 FBiGeom::Error
02203 FBiGeom::setEntSetDblData( EntitySetHandle set_handle,
02204                          TagHandle tag_handle,
02205                          double value )
02206 {
02207      int err;
02208      FBiGeom_setEntSetDblData( mInstance, set_handle, tag_handle, value, &err );
02209      return (Error)err;
02210 }
02211
02212 FBiGeom::Error
02213 FBiGeom::setEntSetEHData( EntitySetHandle set_handle,
02214                         TagHandle tag_handle,
02215                         EntityHandle value )
02216
02217 {
02218      int err;
02219      FBiGeom_setEntSetEHData( mInstance, set_handle, tag_handle, value, &err );
02220      return (Error)err;
02221 }
02222
02223 FBiGeom::Error
02224 FBiGeom::setEntSetESHData( EntitySetHandle set_handle,
02225                          TagHandle tag_handle,
02226                          EntitySetHandle value )
02227
02228 {
02229      int err;
02230      FBiGeom_setEntSetESHData( mInstance, set_handle, tag_handle, value, &err );
02231      return (Error)err;
02232 }
02233
02234 FBiGeom::Error
02235 FBiGeom::getEntSetData( EntitySetHandle set_handle,
02236                       TagHandle tag_handle,
02237                       void* tag_value_out ) const
02238 {
02239      int err, alloc = std::numeric_limits<int>::max(), size;
02240      FBiGeom_getEntSetData( mInstance, set_handle, tag_handle,
02241                           &tag_value_out, &alloc, &size, &err);
02242      return (Error)err;
02243 }
02244
02245 FBiGeom::Error
02246 FBiGeom::getEntSetIntData( EntitySetHandle set_handle,
02247                          TagHandle tag_handle,
02248                          int& value_out ) const
02249 {
02250      int err;
02251      FBiGeom_getEntSetIntData( mInstance, set_handle, tag_handle, &value_out, &err );
02252      return (Error)err;
02253 }
02254
02255 FBiGeom::Error
02256 FBiGeom::getEntSetDblData( EntitySetHandle set_handle,
02257                          TagHandle tag_handle,
02258                          double& value_out ) const
02259 {
02260      int err;
02261      FBiGeom_getEntSetDblData( mInstance, set_handle, tag_handle, &value_out, &err );
02262      return (Error)err;
02263 }
02264
02265 FBiGeom::Error
02266 FBiGeom::getEntSetEHData( EntitySetHandle set_handle,
02267                         TagHandle tag_handle,
02268                         EntityHandle& value_out ) const
02269
02270 {
02271      int err;
02272      FBiGeom_getEntSetEHData( mInstance, set_handle, tag_handle, &value_out, &err );
02273      return (Error)err;
02274 }
02275
02276 FBiGeom::Error
02277 FBiGeom::getEntSetESHData( EntitySetHandle set_handle,
02278                          TagHandle tag_handle,
02279                          EntitySetHandle& value_out ) const
02280
02281 {
02282      int err;
02283      FBiGeom_getEntSetESHData( mInstance, set_handle, tag_handle, &value_out, &err );
02284      return (Error)err;
02285 }
02286
02287 FBiGeom::Error
02288 FBiGeom::getAllEntSetTags( EntitySetHandle set,
02289                          std::vector<TagHandle>& tags_out ) const
02290 {
02291      if (tags_out.capacity() == 0)
02292           tags_out.resize( 32 );
02293      else
02294           tags_out.resize( tags_out.capacity() );
02295
02296      int err, alloc = tags_out.size(), size = 0;
02297      TagHandle* ptr = &tags_out[0];
02298      FBiGeom_getAllEntSetTags( mInstance, set, &ptr, &alloc, &size, &err );
02299      tags_out.resize(size);
02300
02301      if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
02302           alloc = tags_out.size();
02303           ptr = &tags_out[0];
02304           FBiGeom_getAllEntSetTags( mInstance, set, &ptr, &alloc, &size, &err );
02305      }
02306
02307      return (Error)err;
02308 }
02309
02310 FBiGeom::Error
02311 FBiGeom::getAllTags( EntityHandle entity,
02312                    std::vector<TagHandle>& tags_out ) const
02313
02314 {
02315      if (tags_out.capacity() == 0)
02316           tags_out.resize( 32 );
02317      else
02318           tags_out.resize( tags_out.capacity() );
02319
02320      int err, alloc = tags_out.size(), size = 0;
02321      TagHandle* ptr = &tags_out[0];
02322      FBiGeom_getAllTags( mInstance, entity, &ptr, &alloc, &size, &err );
02323      tags_out.resize(size);
02324
02325      if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
02326           alloc = tags_out.size();
02327           ptr = &tags_out[0];
02328           FBiGeom_getAllTags( mInstance, entity, &ptr, &alloc, &size, &err );
02329      }
02330
02331      return (Error)err;
02332 }
02333
02334 FBiGeom::Error
02335 FBiGeom::rmvEntSetTag( EntitySetHandle set, TagHandle tag )
02336 {
02337      int err;
02338      FBiGeom_rmvEntSetTag( mInstance, set, tag, &err );
02339      return (Error)err;
02340 }
02341
02342 FBiGeom::Error
02343 FBiGeom::rmvTag( EntityHandle entity, TagHandle tag )
02344 {
02345      int err;
02346      FBiGeom_rmvTag( mInstance, entity, tag, &err );
02347      return (Error)err;
02348 }
02349
02350 FBiGeom::Error
02351 FBiGeom::rmvArrTag( const EntityHandle* handles, int size, TagHandle tag )
02352 {
02353      int err;
02354      FBiGeom_rmvArrTag( mInstance, handles, size, tag, &err );
02355      return (Error)err;
02356 }
02357
02358
02359 FBiGeom::Error
02360 FBiGeom::getArrData( const EntityHandle* entity_handles,
02361                    int entity_handles_size,
02362                    TagHandle tag_handle,
02363                    void* tag_values_out ) const
02364 {
02365      int err, alloc = std::numeric_limits<int>::max(), size;
02366      FBiGeom_getArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02367                        &tag_values_out, &alloc, &size, &err);
02368      return (Error)err;
02369 }
02370
02371 FBiGeom::Error
02372 FBiGeom::getIntArrData( const EntityHandle* entity_handles,
02373                       int entity_handles_size,
02374                       TagHandle tag_handle,
02375                       int* tag_values_out ) const
02376 {
02377      int err, alloc = std::numeric_limits<int>::max(), size;
02378      FBiGeom_getIntArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02379                           &tag_values_out, &alloc, &size, &err);
02380      return (Error)err;
02381 }
02382
02383 FBiGeom::Error FBiGeom::getFacets(EntityHandle entity_handle, double dist_tolerance,
02384                                   std::vector<double> &point, std::vector<int> &facets) const
02385 {
02386      int err=1; //, alloc_f = std::numeric_limits<int>::max(),
02387                         //alloc_p = std::numeric_limits<double>::max(), size_f, size_p;
02388      /*FBiGeom_getFacets(mInstance, entity_handle, dist_tolerance, &point, &alloc_p, &size_p,
02389                      &facets, &alloc_f, &size_f, &err);*/
02390
02391      return (Error)err;
02392 }
02393
02394 FBiGeom::Error
02395 FBiGeom::getDblArrData( const EntityHandle* entity_handles,
02396                       int entity_handles_size,
02397                       TagHandle tag_handle,
02398                       double* tag_values_out ) const
02399 {
02400      int err, alloc = std::numeric_limits<int>::max(), size;
02401      FBiGeom_getDblArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02402                           &tag_values_out, &alloc, &size, &err);
02403      return (Error)err;
02404 }
02405
02406 FBiGeom::Error
02407 FBiGeom::getEHArrData( const EntityHandle* entity_handles,
02408                      int entity_handles_size,
02409                      TagHandle tag_handle,
02410                      EntityHandle* tag_values_out ) const
02411
02412 {
02413      int err, alloc = std::numeric_limits<int>::max(), size;
02414      FBiGeom_getEHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02415                          &tag_values_out, &alloc, &size, &err);
02416      return (Error)err;
02417 }
02418
02419 FBiGeom::Error
02420 FBiGeom::getESHArrData( const EntityHandle* entity_handles,
02421                       int entity_handles_size,
02422                       TagHandle tag_handle,
02423                       EntitySetHandle* tag_values_out ) const
02424
02425 {
02426      int err, alloc = std::numeric_limits<int>::max(), size;
02427      FBiGeom_getESHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02428                           &tag_values_out, &alloc, &size, &err);
02429      return (Error)err;
02430 }
02431
02432 FBiGeom::Error
02433 FBiGeom::setArrData( const EntityHandle* entity_handles,
02434                    int entity_handles_size,
02435                    TagHandle tag_handle,
02436                    const void* tag_values )
02437 {
02438      int err, size = 1;
02439      FBiGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
02440      FBiGeom_setArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02441                        tag_values, size*entity_handles_size,
02442                        &err );
02443      return (Error)err;
02444 }
02445
02446 FBiGeom::Error
02447 FBiGeom::setIntArrData( const EntityHandle* entity_handles,
02448                       int entity_handles_size,
02449                       TagHandle tag_handle,
02450                       const int* tag_values )
02451 {
02452      int err, size = 1;
02453      FBiGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
02454      FBiGeom_setIntArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02455                           tag_values, size*entity_handles_size, &err );
02456      return (Error)err;
02457 }
02458
02459 FBiGeom::Error
02460 FBiGeom::setDblArrData( const EntityHandle* entity_handles,
02461                       int entity_handles_size,
02462                       TagHandle tag_handle,
02463                       const double* tag_values )
02464 {
02465      int err, size = 1;
02466      FBiGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
02467      FBiGeom_setDblArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02468                           tag_values, size*entity_handles_size, &err );
02469      return (Error)err;
02470 }
02471
02472 FBiGeom::Error
02473 FBiGeom::setEHArrData( const EntityHandle* entity_handles,
02474                      int entity_handles_size,
02475                      TagHandle tag_handle,
02476                      const EntityHandle* tag_values )
02477 {
02478      int err, size = 1;
02479      FBiGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
02480      FBiGeom_setEHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02481                          tag_values, size*entity_handles_size, &err );
02482      return (Error)err;
02483 }
02484
02485 FBiGeom::Error
02486 FBiGeom::setESHArrData( const EntityHandle* entity_handles,
02487                       int entity_handles_size,
02488                       TagHandle tag_handle,
02489                       const EntitySetHandle* tag_values )
02490 {
02491      int err, size = 1;
02492      FBiGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
02493      FBiGeom_setESHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
02494                           tag_values, size*entity_handles_size, &err );
02495      return (Error)err;
02496 }
02497
02498
02499
02500 FBiGeom::Error
02501 FBiGeom::setData( EntityHandle entity_handle,
02502                 TagHandle tag_handle,
02503                 const void* tag_value )
02504 {
02505      int err, size = 1;
02506      FBiGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
02507      FBiGeom_setData( mInstance, entity_handle, tag_handle,
02508                     tag_value, size, &err);
02509      return (Error)err;
02510 }
02511
02512 FBiGeom::Error
02513 FBiGeom::setIntData( EntityHandle entity_handle,
02514                    TagHandle tag_handle,
02515                    int value )
02516 {
02517      int err;
02518      FBiGeom_setIntData( mInstance, entity_handle, tag_handle, value, &err );
02519      return (Error)err;
02520 }
02521
02522 FBiGeom::Error
02523 FBiGeom::setDblData( EntityHandle entity_handle,
02524                    TagHandle tag_handle,
02525                    double value )
02526 {
02527      int err;
02528      FBiGeom_setDblData( mInstance, entity_handle, tag_handle, value, &err );
02529      return (Error)err;
02530 }
02531
02532 FBiGeom::Error
02533 FBiGeom::setEHData( EntityHandle entity_handle,
02534                   TagHandle tag_handle,
02535                   EntityHandle value )
02536
02537 {
02538      int err;
02539      FBiGeom_setEHData( mInstance, entity_handle, tag_handle, value, &err );
02540      return (Error)err;
02541 }
02542
02543 FBiGeom::Error
02544 FBiGeom::setESHData( EntityHandle entity_handle,
02545                    TagHandle tag_handle,
02546                    EntitySetHandle value )
02547
02548 {
02549      int err;
02550      FBiGeom_setESHData( mInstance, entity_handle, tag_handle, value, &err );
02551      return (Error)err;
02552 }
02553
02554 FBiGeom::Error
02555 FBiGeom::getData( EntityHandle entity_handle,
02556                 TagHandle tag_handle,
02557                 void* tag_value_out ) const
02558 {
02559      int err, alloc = std::numeric_limits<int>::max(), size;
02560      FBiGeom_getData( mInstance, entity_handle, tag_handle,
02561                     &tag_value_out, &alloc, &size, &err);
02562      return (Error)err;
02563 }
02564
02565 FBiGeom::Error
02566 FBiGeom::getIntData( EntityHandle entity_handle,
02567                    TagHandle tag_handle,
02568                    int& value_out ) const
02569 {
02570      int err;
02571      FBiGeom_getIntData( mInstance, entity_handle, tag_handle, &value_out, &err );
02572      return (Error)err;
02573 }
02574
02575 FBiGeom::Error
02576 FBiGeom::getDblData( EntityHandle entity_handle,
02577                    TagHandle tag_handle,
02578                    double& value_out ) const
02579 {
02580      int err;
02581      FBiGeom_getDblData( mInstance, entity_handle, tag_handle, &value_out, &err );
02582      return (Error)err;
02583 }
02584
02585 FBiGeom::Error
02586 FBiGeom::getEHData( EntityHandle entity_handle,
02587                   TagHandle tag_handle,
02588                   EntityHandle& value_out ) const
02589 {
02590      int err;
02591      FBiGeom_getEHData( mInstance, entity_handle, tag_handle, &value_out, &err );
02592      return (Error)err;
02593 }
02594
02595 FBiGeom::Error
02596 FBiGeom::getESHData( EntityHandle entity_handle,
02597                    TagHandle tag_handle,
02598                    EntitySetHandle& value_out ) const
02599 {
02600      int err;
02601      FBiGeom_getESHData( mInstance, entity_handle, tag_handle, &value_out, &err );
02602      return (Error)err;
02603 }
02604
02605 #endif