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