Branch data Line data Source code
1 : : #ifndef MESHKIT_ITAPS_GEOM_HPP
2 : : #define MESHKIT_ITAPS_GEOM_HPP
3 : :
4 : : /** \file iGeom.hpp
5 : : */
6 : :
7 : : #include "iGeom.h"
8 : : #include "iRel.hpp"
9 : :
10 : : #include <string.h>
11 : : #include <stdlib.h>
12 : : #include <vector>
13 : : #include <limits>
14 : : #include <string>
15 : :
16 : : /** \class iGeom
17 : : * \brief C++ interface to ITAPS iGeom interface
18 : : *
19 : : * This class is a simple wrapper for the ITAPS iGeom interface. The primary benefit to using this class
20 : : * instead of iGeom directly is that lists of handles are passed as std::vectors instead of pointers to
21 : : * handle arrays. This file includes both declaration and definition of all iGeom class functions, i.e.
22 : : * all functions are inlined. The class can be constructed and destructed in the standard C++ way; the
23 : : * implementation of those functions call into the standard iGeom C functions newGeom and dtor.
24 : : *
25 : : * For complete documentation of these functions, see the iGeom header in the CGM source
26 : : * [http://ftp.mcs.anl.gov/pub/fathom/cgm-docs/iGeom_8h.html iGeom]
27 : : */
28 : :
29 : : class iGeom {
30 : : protected:
31 : : iGeom_Instance mInstance;
32 : : public:
33 : 0 : virtual inline iRel::IfaceType iface_type() const {
34 : 0 : return iRel::IGEOM_IFACE;
35 : : }
36 : :
37 : : typedef iBase_EntitySetHandle EntitySetHandle;
38 : : typedef iBase_EntityHandle EntityHandle;
39 : : typedef iBase_TagHandle TagHandle;
40 : : typedef iBase_ErrorType Error;
41 : : typedef iBase_EntityType EntityType;
42 : : typedef iBase_StorageOrder StorageOrder;
43 : : typedef iBase_TagValueType TagValueType;
44 : :
45 : : inline iGeom(const char* options = 0);
46 : : inline iGeom(iGeom_Instance instance);
47 : :
48 : : inline iGeom(bool meshBased);
49 : :
50 : : virtual inline ~iGeom();
51 : :
52 : : virtual inline Error load(const char* file_name, const char* options = 0);
53 : :
54 : : virtual inline Error save(const char* file_name, const char* options = 0);
55 : :
56 : : virtual inline Error getBoundBox(double& min_x, double& min_y, double& min_z,
57 : : double& max_x, double& max_y, double& max_z) const;
58 : :
59 : : virtual inline int getParametric();
60 : :
61 : : virtual inline Error getNumOfType(EntitySetHandle set, EntityType type,
62 : : int& count_out) const;
63 : :
64 : : virtual inline Error getEntities(EntitySetHandle set, EntityType type,
65 : : std::vector<EntityHandle>& entities_out) const;
66 : :
67 : : virtual inline Error getEntType(EntityHandle handle, EntityType& type_out) const;
68 : :
69 : : virtual inline Error getArrType(const EntityHandle* entity_handles,
70 : : int entity_handles_Size, EntityType* types_out) const;
71 : :
72 : : virtual inline Error getEntAdj(EntityHandle handle,
73 : : EntityType type_requested, std::vector<EntityHandle>& adj_entities_out) const;
74 : :
75 : : virtual inline Error getArrAdj(const EntityHandle* entity_handles,
76 : : int entity_handles_size, EntityType type_requested, std::vector<
77 : : EntityHandle>& adjacent_entity_handles_out, int* offsets_out) const;
78 : :
79 : : virtual inline Error getEnt2ndAdj(EntityHandle handle,
80 : : EntityType bridge_dimension, EntityType type_requested, std::vector<
81 : : EntityHandle>& adj_entities_out) const;
82 : :
83 : : virtual inline Error getArr2ndAdj(const EntityHandle* entity_handles,
84 : : int entity_handles_size, EntityType order_adjacent_key,
85 : : EntityType type_requested,
86 : : std::vector<EntityHandle>& adjacent_entity_handles_out, int* offsets_out) const;
87 : :
88 : : virtual inline Error isEntAdj(EntityHandle entity1, EntityHandle entity2,
89 : : bool& adjacent_out) const;
90 : :
91 : : virtual inline Error isArrAdj(const EntityHandle* entities1,
92 : : const EntityHandle* entities2, int num_entity_pairs, int* is_adj_out) const;
93 : :
94 : : virtual inline Error getEntClosestPt(EntityHandle entity, double near_x,
95 : : double near_y, double near_z, double& on_x, double& on_y, double& on_z) const;
96 : :
97 : : virtual inline Error getEntClosestPtTrimmed(EntityHandle entity, double near_x,
98 : : double near_y, double near_z, double& on_x, double& on_y, double& on_z) const;
99 : :
100 : : virtual inline Error getArrClosestPt(const EntityHandle* handles,
101 : : int handles_size, StorageOrder order, const double* near_coordinates,
102 : : int near_coordinates_size, double* on_coordinates) const;
103 : :
104 : : virtual inline Error getEntNrmlXYZ(EntityHandle entity, double x, double y,
105 : : double z, double& i, double& j, double& k) const;
106 : :
107 : : virtual inline Error getArrNrmlXYZ(const EntityHandle* entities,
108 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
109 : : double* ijk) const;
110 : :
111 : : virtual inline Error getEntNrmlPlXYZ(EntityHandle entity, double x, double y,
112 : : double z, double& on_x, double& on_y, double& on_z, double& i, double& j,
113 : : double& k) const;
114 : :
115 : : virtual inline Error getArrNrmlPlXYZ(const EntityHandle* entities,
116 : : int entities_size, StorageOrder order, const double* near_xyz,
117 : : int near_xyz_size, double* on_xyz, double* nrml_ijk) const;
118 : :
119 : : virtual inline Error getEntTgntXYZ(EntityHandle entity, double x, double y,
120 : : double z, double& i, double& j, double& k) const;
121 : :
122 : : virtual inline Error getArrTgntXYZ(const EntityHandle* entities,
123 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
124 : : double* ijk) const;
125 : :
126 : : virtual inline Error getFcCvtrXYZ(EntityHandle face, double x, double y,
127 : : double z, double& i1, double& j1, double& k1, double& i2, double& j2,
128 : : double& k2) const;
129 : :
130 : : virtual inline Error getEgCvtrXYZ(EntityHandle edge, double x, double y,
131 : : double z, double& i, double& j, double& k) const;
132 : :
133 : : virtual inline Error getEntArrCvtrXYZ(const EntityHandle* entities,
134 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
135 : : double* cvtr_1, double* cvtr_2) const;
136 : :
137 : : virtual inline Error getEgEvalXYZ(EntityHandle edge, double x, double y,
138 : : double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
139 : : double& tngt_j, double& tngt_k, double& cvtr_i, double& cvtr_j,
140 : : double& cvtr_k) const;
141 : :
142 : : virtual inline Error getFcEvalXYZ(EntityHandle face, double x, double y,
143 : : double z, double& on_x, double& on_y, double& on_z, double& nrml_i,
144 : : double& nrml_j, double& nrml_k, double& cvtr1_i, double& cvtr1_j,
145 : : double& cvtr1_k, double& cvtr2_i, double& cvtr2_j, double& cvtr2_k) const;
146 : :
147 : : virtual inline Error getArrEgEvalXYZ(const EntityHandle* edges,
148 : : int edges_size, StorageOrder order, const double* near_coords,
149 : : int near_coords_size, double* on_coords, double* tangent,
150 : : double* curvature) const;
151 : :
152 : : virtual inline Error getArrFcEvalXYZ(const EntityHandle* faces,
153 : : int faces_size, StorageOrder order, const double* near_coords,
154 : : int near_coords_size, double* on_coords, double* normal,
155 : : double* curvature1, double* curvature2) const;
156 : :
157 : : virtual inline Error
158 : : getEntBoundBox(EntityHandle entity, double& min_x, double& min_y,
159 : : double& min_z, double& max_x, double& max_y, double& max_z) const;
160 : :
161 : : virtual inline Error getArrBoundBox(const EntityHandle* entities,
162 : : int entities_size, StorageOrder order, double* min_corners,
163 : : double* max_corners) const;
164 : :
165 : : virtual inline Error getVtxCoord(EntityHandle vertex, double& x, double& y,
166 : : double& z) const;
167 : :
168 : : virtual inline Error getVtxArrCoords(const EntityHandle* vertices,
169 : : int vertices_size, StorageOrder order, double* coords) const;
170 : :
171 : : virtual inline Error getPntRayIntsct(double x, double y, double z, double i,
172 : : double j, double k, StorageOrder order,
173 : : std::vector<EntityHandle>& entities_out, std::vector<double>& points_out,
174 : : std::vector<double>& params_out) const;
175 : :
176 : : virtual inline Error getPntClsf(double x, double y, double z,
177 : : EntityHandle& handle_out)const;
178 : :
179 : : virtual inline Error getPntArrClsf(StorageOrder order, const double* coords,
180 : : int coords_size, EntityHandle* entities_out) const;
181 : :
182 : : virtual inline Error getEntNrmlSense(EntityHandle face, EntityHandle region,
183 : : int& sense) const;
184 : :
185 : : virtual inline Error getEgFcSense(EntityHandle edge, EntityHandle face,
186 : : int& sense) const;
187 : :
188 : : virtual inline Error getEgVtxSense(EntityHandle edge, EntityHandle vtx1,
189 : : EntityHandle vtx2, int& sense) const;
190 : :
191 : : virtual inline Error getArrNrmlSense(const EntityHandle* faces,
192 : : int faces_size, const EntityHandle* vols, int vols_size, int* senses_out)const;
193 : :
194 : : virtual inline Error getEgFcArrSense(const EntityHandle* edges,
195 : : int edges_size, const EntityHandle* faces, int faces_size,
196 : : int* senses_out) const;
197 : :
198 : : virtual inline Error getEgVtxArrSense(const EntityHandle* edges,
199 : : int edges_size, const EntityHandle* vertices1, int vertices1_size,
200 : : const EntityHandle* vertices2, int vertices2_size, int* senses_out) const;
201 : :
202 : : virtual inline Error getSense(EntityHandle ent, EntityHandle wrt_ent,
203 : : int &sense) const;
204 : :
205 : : virtual inline Error getArrSense(const EntityHandle *ent, int num_ents,
206 : : EntityHandle wrt_ent, int *sense) const;
207 : :
208 : : virtual inline Error measure(const EntityHandle* entities, int entities_size,
209 : : double* measures) const;
210 : :
211 : : virtual inline Error getFaceType(EntityHandle face, std::string& type) const;
212 : :
213 : : virtual inline Error isEntParametric(EntityHandle entity, bool& parametric) const;
214 : :
215 : : virtual inline Error isArrParametric(const EntityHandle* entities,
216 : : int entities_size, int* is_parametric) const;
217 : :
218 : : virtual inline Error getEntUVtoXYZ(EntityHandle face, double u, double v,
219 : : double& x, double& y, double& z) const;
220 : :
221 : : virtual inline Error getEntUtoXYZ(EntityHandle edge, double u, double& x,
222 : : double& y, double& z) const;
223 : :
224 : : virtual inline Error getArrUVtoXYZ(const EntityHandle* faces, int faces_size,
225 : : StorageOrder order, const double* uv, int uv_size, double* xyz) const;
226 : :
227 : : virtual inline Error getArrUtoXYZ(const EntityHandle* edges, int edges_size,
228 : : const double* u, int u_size, StorageOrder order, double* xyz) const;
229 : :
230 : : virtual inline Error getEntXYZtoUV(EntityHandle face, double x, double y,
231 : : double z, double& u, double& v) const;
232 : :
233 : : virtual inline Error getEntXYZtoU(EntityHandle edge, double x, double y,
234 : : double z, double& u) const;
235 : :
236 : : virtual inline Error getArrXYZtoUV(const EntityHandle* faces, int faces_size,
237 : : StorageOrder order, const double* coords, int coords_size, double* uv) const;
238 : :
239 : : virtual inline Error getArrXYZtoU(const EntityHandle* edges, int edges_size,
240 : : StorageOrder order, const double* coords, int coords_size, double* u) const;
241 : :
242 : : virtual inline Error getEntXYZtoUVHint(EntityHandle face, double x, double y,
243 : : double z, double& u, double& v) const;
244 : :
245 : : virtual inline Error getArrXYZtoUVHint(const EntityHandle* faces,
246 : : int faces_size, StorageOrder order, const double* coords,
247 : : int coords_size, double* uv) const;
248 : :
249 : : virtual inline Error getEntNrmlUV(EntityHandle face, double u, double v,
250 : : double& i, double& j, double& k) const;
251 : :
252 : : virtual inline Error getArrNrmlUV(const EntityHandle* faces, int faces_size,
253 : : StorageOrder order, const double* uv, int uv_size, double* normals) const;
254 : :
255 : : virtual inline Error getEntTgntU(EntityHandle edge, double u, double& i,
256 : : double& j, double& k) const;
257 : :
258 : : virtual inline Error getArrTgntU(const EntityHandle* edges, int edges_size,
259 : : StorageOrder order, const double* u, int u_size, double* normals) const;
260 : :
261 : : virtual inline Error getEnt1stDrvt(EntityHandle handle, double u, double v,
262 : : double& du_i, double& du_j, double& du_k, double& dv_i, double& dv_j,
263 : : double& dv_k) const;
264 : : virtual inline Error
265 : : getEnt2ndDrvt(EntityHandle handle, double u, double v, double& duu_i,
266 : : double& duu_j, double& duu_k, double& dvv_i, double& dvv_j,
267 : : double& dvv_k, double& duv_i, double& duv_j, double& duv_k) const;
268 : :
269 : : virtual inline Error getArr1stDrvt(const EntityHandle* entities,
270 : : int entities_size, StorageOrder order, const double* uv, int uv_size,
271 : : double* dvtr_u, double* dvtr_v) const;
272 : :
273 : : virtual inline Error getArr2ndDrvt(const EntityHandle* entities,
274 : : int entities_size, StorageOrder order, const double* uv, int uv_size,
275 : : double* dvtr_uu, double* dvtr_vv, double* dvtr_uv) const;
276 : :
277 : : virtual inline Error getFcCvtrUV(EntityHandle face, double u, double v,
278 : : double& i1, double& j1, double& k1, double& i2, double& j2, double& k2) const;
279 : :
280 : : virtual inline Error getFcArrCvtrUV(const EntityHandle* faces,
281 : : int faces_size, StorageOrder order, const double* uv, int uv_size,
282 : : double* cvtr1, double* cvtr2) const;
283 : :
284 : : virtual inline Error isEntPeriodic(EntityHandle entity, bool& in_u,
285 : : bool& in_v) const;
286 : :
287 : : virtual inline Error isArrPeriodic(const EntityHandle* entities,
288 : : int entities_size, int* in_uv) const;
289 : :
290 : : virtual inline Error isFcDegenerate(EntityHandle face, bool& is_degenerate) const;
291 : :
292 : : virtual inline Error isFcArrDegenerate(const EntityHandle* faces,
293 : : int faces_size, int* degenerate) const;
294 : :
295 : : virtual inline Error getTolerance(int& type_out, double& tolerance_out) const;
296 : : virtual inline Error getEntTolerance(EntityHandle entity, double& tolerance) const;
297 : : virtual inline Error getArrTolerance(const EntityHandle* entities,
298 : : int entities_size, double* tolerances) const;
299 : :
300 : : virtual inline Error getEntUVRange(EntityHandle face, double& u_min,
301 : : double& v_min, double& u_max, double& v_max) const;
302 : : virtual inline Error getEntURange(EntityHandle edge, double& u_min,
303 : : double& u_max) const;
304 : : virtual inline Error getArrUVRange(const EntityHandle* faces, int faces_size,
305 : : StorageOrder order, double* uv_min, double* uv_max) const;
306 : : virtual inline Error getArrURange(const EntityHandle* edges, int edges_size,
307 : : double* u_min, double* u_max) const;
308 : :
309 : : virtual inline Error getEntUtoUV(EntityHandle edge, EntityHandle face,
310 : : double edge_u, double& face_u, double& face_v) const;
311 : : virtual inline Error getVtxToUV(EntityHandle vertex, EntityHandle face,
312 : : double& u, double& v) const;
313 : : virtual inline Error getVtxToU(EntityHandle vertex, EntityHandle edge,
314 : : double& u) const;
315 : : virtual inline Error getArrUtoUV(const EntityHandle* edges, int edges_size,
316 : : const EntityHandle* faces, int faces_size, const double* edge_u,
317 : : int edge_u_size, StorageOrder order, double* face_uv) const;
318 : : virtual inline Error getVtxArrToUV(const EntityHandle* vertices,
319 : : int vertices_size, const EntityHandle* faces, int faces_size,
320 : : StorageOrder order, double* face_uv) const;
321 : : virtual inline Error getVtxArrToU(const EntityHandle* vertices,
322 : : int vertices_size, const EntityHandle* edges, int edges_size,
323 : : double* edge_u) const;
324 : :
325 : : virtual inline Error deleteAll();
326 : :
327 : : virtual inline Error deleteEnt(EntityHandle entity);
328 : :
329 : : virtual inline Error copyEnt(EntityHandle source, EntityHandle& copy);
330 : :
331 : : virtual inline Error createSphere(double radius, EntityHandle& sphere);
332 : : virtual inline Error createPrism(double height, int num_sides,
333 : : double maj_radius, double min_radius, EntityHandle& prism);
334 : : virtual inline Error createBrick(double x, double y, double z,
335 : : EntityHandle& brick);
336 : : virtual inline Error createCylinder(double height, double maj_rad,
337 : : double min_rad, EntityHandle& cylinder);
338 : : virtual inline Error createCone(double height, double maj_rad,
339 : : double min_rad, double top_rad, EntityHandle& cone);
340 : : virtual inline Error createTorus(double maj_rad, double min_rad,
341 : : EntityHandle& torus);
342 : :
343 : : virtual inline Error moveEnt(EntityHandle entity, double x, double y,
344 : : double z);
345 : : virtual inline Error rotateEnt(EntityHandle entity, double angle,
346 : : double axis_x, double axis_y, double axis_z);
347 : : virtual inline Error reflectEnt(EntityHandle entity, double x,
348 : : double y, double z, double norm_x,
349 : : double norm_y, double norm_z);
350 : : virtual inline Error scaleEnt(EntityHandle entity, double x,
351 : : double y, double z, double x_factor,
352 : : double y_factor, double z_factor);
353 : :
354 : : virtual inline Error uniteEnts(const EntityHandle* entities,
355 : : int entities_size, EntityHandle& result_entity);
356 : : virtual inline Error subtractEnts(EntityHandle blank, EntityHandle tool,
357 : : EntityHandle& result);
358 : : virtual inline Error intersectEnts(EntityHandle entity1,
359 : : EntityHandle entity2, EntityHandle& result);
360 : :
361 : : virtual inline Error sectionEnt(EntityHandle entity, double plane_x,
362 : : double plane_y, double plane_z, double offset, bool reverse,
363 : : EntityHandle& result);
364 : :
365 : : virtual inline Error sweepEntAboutAxis(EntityHandle entity, double angle,
366 : : double axis_x, double axis_y, double axis_z, EntityHandle& swept_entity);
367 : :
368 : : virtual inline Error imprintEnts(const EntityHandle* entities,
369 : : int entities_size);
370 : : virtual inline Error mergeEnts(const EntityHandle* entities,
371 : : int entities_size, double tolerance);
372 : :
373 : : // copied from iBaseVirtual.hpp
374 : 196 : iGeom_Instance instance() {
375 : 196 : return mInstance;
376 : : }
377 : :
378 : : virtual inline std::string getDescription() const;
379 : :
380 : : virtual inline Error getErrorType() const;
381 : :
382 : : virtual inline EntitySetHandle getRootSet() const;
383 : :
384 : : virtual inline Error createEntSet(bool is_list, EntitySetHandle& handle_out);
385 : : virtual inline Error destroyEntSet(EntitySetHandle handle);
386 : : virtual inline Error isList(EntitySetHandle handle, bool& is_list);
387 : :
388 : : virtual inline Error getNumEntSets(EntitySetHandle set, int num_hops,
389 : : int& num_sets_out) const;
390 : : virtual inline Error getEntSets(EntitySetHandle set, int num_hops, std::vector<
391 : : EntitySetHandle>& contained_sets_out) const;
392 : :
393 : : virtual inline Error addEntToSet(EntityHandle entity, EntitySetHandle set);
394 : : virtual inline Error rmvEntFromSet(EntityHandle entity, EntitySetHandle set);
395 : :
396 : : virtual inline Error addEntArrToSet(const EntityHandle* entity_handles,
397 : : int entity_handles_size, EntitySetHandle entity_set);
398 : : virtual inline Error rmvEntArrFromSet(const EntityHandle* entity_handles,
399 : : int entity_handles_size, EntitySetHandle entity_set);
400 : :
401 : : virtual inline Error addEntSet(EntitySetHandle to_add, EntitySetHandle add_to);
402 : : virtual inline Error rmvEntSet(EntitySetHandle to_rmv, EntitySetHandle rmv_from);
403 : :
404 : : virtual inline Error isEntContained(EntitySetHandle set, EntityHandle ent,
405 : : bool& contained_out) const;
406 : : virtual inline Error isEntArrContained(EntitySetHandle containing_set,
407 : : const EntityHandle* entity_handles, int num_entity_handles,
408 : : bool* is_contained_out) const;
409 : : virtual inline Error isEntSetContained(EntitySetHandle containing_set,
410 : : EntitySetHandle contained_set, bool& contained_out) const;
411 : :
412 : : virtual inline Error addPrntChld(EntitySetHandle parent, EntitySetHandle child);
413 : : virtual inline Error rmvPrntChld(EntitySetHandle parent, EntitySetHandle child);
414 : : virtual inline Error isChildOf(EntitySetHandle parent, EntitySetHandle child,
415 : : bool& is_child_out) const;
416 : : virtual inline Error getNumChld(EntitySetHandle parent, int num_hops,
417 : : int& num_child_out) const;
418 : : virtual inline Error getNumPrnt(EntitySetHandle child, int num_hops,
419 : : int& num_parent_out) const;
420 : : virtual inline Error getChldn(EntitySetHandle parent, int num_hops, std::vector<
421 : : EntitySetHandle>& children_out) const;
422 : : virtual inline Error getPrnts(EntitySetHandle child, int num_hops, std::vector<
423 : : EntitySetHandle>& parents_out) const;
424 : :
425 : : virtual inline Error subtract(EntitySetHandle set1, EntitySetHandle set2,
426 : : EntitySetHandle& result_set_out);
427 : : virtual inline Error intersect(EntitySetHandle set1, EntitySetHandle set2,
428 : : EntitySetHandle& result_set_out);
429 : : virtual inline Error unite(EntitySetHandle set1, EntitySetHandle set2,
430 : : EntitySetHandle& result_set_out);
431 : :
432 : : virtual inline Error createTag(const char* tag_name, int tag_num_type_values,
433 : : TagValueType tag_type, TagHandle& tag_handle_out);
434 : :
435 : : virtual inline Error destroyTag(TagHandle tag_handle, bool forced);
436 : : virtual inline Error getTagName(TagHandle tag_handle, std::string& name_out) const;
437 : : virtual inline Error getTagSizeValues(TagHandle tag_handle, int& size_out) const;
438 : : virtual inline Error getTagSizeBytes(TagHandle tag_handle, int& size_out) const;
439 : : virtual inline Error getTagHandle(const char* name, TagHandle& handle_out) const;
440 : : virtual inline Error getTagType(TagHandle tag_handle, TagValueType& type_out) const;
441 : :
442 : : virtual inline Error setEntSetData(EntitySetHandle set_handle, TagHandle tag_handle,
443 : : const void* tag_value);
444 : : virtual inline Error setEntSetIntData(EntitySetHandle set_handle,
445 : : TagHandle tag_handle, int value);
446 : : virtual inline Error setEntSetDblData(EntitySetHandle set_handle,
447 : : TagHandle tag_handle, double value);
448 : : virtual inline Error setEntSetEHData(EntitySetHandle set_handle,
449 : : TagHandle tag_handle, EntityHandle value);
450 : : virtual inline Error setEntSetESHData(EntitySetHandle set_handle,
451 : : TagHandle tag_handle, EntitySetHandle value);
452 : :
453 : : virtual inline Error getEntSetData(EntitySetHandle set_handle, TagHandle tag_handle,
454 : : void* tag_value_out) const;
455 : : virtual inline Error getEntSetIntData(EntitySetHandle set_handle,
456 : : TagHandle tag_handle, int& value_out) const;
457 : : virtual inline Error getEntSetDblData(EntitySetHandle set_handle,
458 : : TagHandle tag_handle, double& value_out) const;
459 : : virtual inline Error getEntSetEHData(EntitySetHandle set_handle,
460 : : TagHandle tag_handle, EntityHandle& value_out) const;
461 : : virtual inline Error getEntSetESHData(EntitySetHandle set_handle,
462 : : TagHandle tag_handle, EntitySetHandle& value_out) const;
463 : :
464 : : virtual inline Error getAllEntSetTags(EntitySetHandle set,
465 : : std::vector<TagHandle>& tags_out) const;
466 : : virtual inline Error getAllTags(EntityHandle entity,
467 : : std::vector<TagHandle>& tags_out) const;
468 : :
469 : : virtual inline Error rmvEntSetTag(EntitySetHandle set, TagHandle tag);
470 : : virtual inline Error rmvTag(EntityHandle entity, TagHandle tag);
471 : : virtual inline Error rmvArrTag(const EntityHandle* handles, int size, TagHandle tag);
472 : :
473 : : virtual inline Error getArrData(const EntityHandle* entity_handles,
474 : : int entity_handles_size, TagHandle tag_handle, void* tag_values_out) const;
475 : : virtual inline Error getIntArrData(const EntityHandle* entity_handles,
476 : : int entity_handles_size, TagHandle tag_handle, int* tag_values_out) const;
477 : : virtual inline Error getDblArrData(const EntityHandle* entity_handles,
478 : : int entity_handles_size, TagHandle tag_handle, double* tag_values_out) const;
479 : : virtual inline Error getEHArrData(const EntityHandle* entity_handles,
480 : : int entity_handles_size, TagHandle tag_handle,
481 : : EntityHandle* tag_values_out) const;
482 : : virtual inline Error getESHArrData(const EntityHandle* entity_handles,
483 : : int entity_handles_size, TagHandle tag_handle,
484 : : EntitySetHandle* tag_values_out) const;
485 : :
486 : : virtual inline Error setArrData(const EntityHandle* entity_handles,
487 : : int entity_handles_size, TagHandle tag_handle, const void* tag_values);
488 : : virtual inline Error setIntArrData(const EntityHandle* entity_handles,
489 : : int entity_handles_size, TagHandle tag_handle, const int* tag_values);
490 : : virtual inline Error setDblArrData(const EntityHandle* entity_handles,
491 : : int entity_handles_size, TagHandle tag_handle, const double* tag_values);
492 : : virtual inline Error setEHArrData(const EntityHandle* entity_handles,
493 : : int entity_handles_size, TagHandle tag_handle,
494 : : const EntityHandle* tag_values);
495 : : virtual inline Error setESHArrData(const EntityHandle* entity_handles,
496 : : int entity_handles_size, TagHandle tag_handle,
497 : : const EntitySetHandle* tag_values);
498 : :
499 : : virtual inline Error setData(EntityHandle entity_handle, TagHandle tag_handle,
500 : : const void* tag_value);
501 : : virtual inline Error setIntData(EntityHandle entity_handle, TagHandle tag_handle,
502 : : int value);
503 : : virtual inline Error setDblData(EntityHandle entity_handle, TagHandle tag_handle,
504 : : double value);
505 : : virtual inline Error setEHData(EntityHandle entity_handle, TagHandle tag_handle,
506 : : EntityHandle value);
507 : : virtual inline Error setESHData(EntityHandle entity_handle, TagHandle tag_handle,
508 : : EntitySetHandle value);
509 : :
510 : : virtual inline Error getData(EntityHandle entity_handle, TagHandle tag_handle,
511 : : void* tag_value_out) const;
512 : : virtual inline Error getFacets(EntityHandle entity_handle, double dist_tolerance,
513 : : std::vector<double> &point, std::vector<int> &facets) const;
514 : : virtual inline Error getIntData(EntityHandle entity_handle, TagHandle tag_handle,
515 : : int& value_out) const;
516 : : virtual inline Error getDblData(EntityHandle entity_handle, TagHandle tag_handle,
517 : : double& value_out) const;
518 : : virtual inline Error getEHData(EntityHandle entity_handle, TagHandle tag_handle,
519 : : EntityHandle& value_out) const;
520 : : virtual inline Error getESHData(EntityHandle entity_handle, TagHandle tag_handle,
521 : : EntitySetHandle& value_out) const;
522 : :
523 : 42 : virtual bool isFBiGeom() {return false;}
524 : : // end copy from iBaseVirtual.hpp
525 : : /** \class EntArrIter iGeom.hpp "iGeom.hpp"
526 : : * \brief Class for iterating over %iGeom entity arrays.
527 : : */
528 : : class EntArrIter {
529 : : private:
530 : : friend class iGeom;
531 : : iBase_EntityArrIterator mHandle;
532 : : iGeom_Instance mInstance;
533 : : int mSize;
534 : : public:
535 : : EntArrIter() :
536 : : mHandle(0), mInstance(0), mSize(0) {
537 : : }
538 : : inline ~EntArrIter();
539 : : inline Error getNext(EntityHandle* entity_handles_out, int& size_out,
540 : : bool& has_more_data_out);
541 : : inline Error reset();
542 : : };
543 : :
544 : : /** \class EntIter iGeom.hpp "iGeom.hpp"
545 : : * \brief Class for iterating over %iGeom entities.
546 : : */
547 : : class EntIter {
548 : : private:
549 : : friend class iGeom;
550 : : iBase_EntityIterator mHandle;
551 : : iGeom_Instance mInstance;
552 : : public:
553 : : EntIter() :
554 : : mHandle(0), mInstance(0) {
555 : : }
556 : : inline ~EntIter();
557 : : inline Error getNext(EntityHandle& entity_handle_out,
558 : : bool& has_more_data_out);
559 : : inline Error reset();
560 : : };
561 : :
562 : : virtual inline Error initEntIter(EntitySetHandle set,
563 : : EntityType requested_type, EntIter& iter);
564 : : virtual inline Error initEntArrIter(EntitySetHandle set,
565 : : EntityType requested_type, int requested_array_size, EntArrIter& iter);
566 : : private:
567 : : bool iGeomInstanceOwner;
568 : :
569 : : // prohibit copying
570 : : iGeom(const iGeom&) {
571 : : }
572 : : void operator=(const iGeom&) {
573 : : }
574 : : };
575 : :
576 : 43 : inline iGeom::iGeom(const char* options) :
577 : 43 : iGeomInstanceOwner(true)
578 : : {
579 [ - + ]: 43 : int err, len = options ? strlen(options) : 0;
580 [ + - ]: 43 : iGeom_newGeom(options, &mInstance, &err, len);
581 [ - + ]: 43 : if (iBase_SUCCESS != err) {
582 : 0 : mInstance = 0;
583 : 0 : iGeomInstanceOwner = false;
584 : : }
585 : 43 : }
586 : :
587 : : inline iGeom::iGeom(iGeom_Instance instance) :
588 : : iGeomInstanceOwner(false)
589 : : {
590 : : mInstance = instance;
591 : : }
592 : : inline iGeom::iGeom(bool meshBased)
593 : : {
594 : : mInstance = 0;
595 : : iGeomInstanceOwner = false;
596 : : }
597 : 46 : inline iGeom::~iGeom()
598 : : {
599 [ + - ]: 25 : if (iGeomInstanceOwner) {
600 : : int err;
601 : 25 : iGeom_dtor(mInstance, &err);
602 : : }
603 [ - + ]: 46 : }
604 : :
605 : 39 : inline iGeom::Error iGeom::load(const char* file_name, const char* options)
606 : : {
607 [ - + ]: 39 : int err, len = options ? strlen(options) : 0;
608 [ + - ]: 39 : iGeom_load(mInstance, file_name, options, &err, strlen(file_name), len);
609 : 39 : return (Error) err;
610 : : }
611 : :
612 : 0 : inline iGeom::Error iGeom::save(const char* file_name, const char* options)
613 : : {
614 [ # # ]: 0 : int err, len = options ? strlen(options) : 0;
615 [ # # ]: 0 : iGeom_save(mInstance, file_name, options, &err, strlen(file_name), len);
616 : 0 : return (Error) err;
617 : : }
618 : :
619 : : //inline iGeom::StorageOrder
620 : : //iGeom::getDfltStorage()
621 : : //{
622 : : // int err, order;
623 : : // iGeom_getDfltStorage( mInstance, &order, &err );
624 : : // return (iBase_SUCCESS == err) ? (StorageOrder)order : iBase_UNDETERMINED;
625 : : //}
626 : :
627 : 72 : inline iGeom::Error iGeom::getNumOfType(EntitySetHandle set, EntityType type,
628 : : int& count_out) const
629 : : {
630 : : int err;
631 [ + - ]: 72 : iGeom_getNumOfType(mInstance, set, type, &count_out, &err);
632 : 72 : return (Error) err;
633 : : }
634 : :
635 : 198 : inline iGeom::Error iGeom::getEntities(EntitySetHandle set, EntityType type,
636 : : std::vector<EntityHandle>& entities_out) const
637 : : {
638 : : // if input vect has no allocated space, allocate some so
639 : : // we don't accidentally ask the impl to allocate an array
640 [ + + ]: 198 : if (entities_out.capacity() == 0) {
641 : : int count;
642 [ + - ]: 72 : Error err2 = getNumOfType(set, iBase_ALL_TYPES, count);
643 [ - + ]: 72 : if (err2 != iBase_SUCCESS)
644 : 0 : return err2;
645 [ + - ]: 72 : entities_out.resize(count);
646 : : }
647 : :
648 : : // try getting results using whatever space input vector has allocated
649 : 198 : int err, size = 0, alloc = entities_out.capacity();
650 [ + - ]: 198 : entities_out.resize(entities_out.capacity());
651 [ + - ]: 198 : EntityHandle* ptr = &entities_out[0];
652 [ + - ]: 198 : iGeom_getEntities(mInstance, set, type, &ptr, &alloc, &size, &err);
653 [ + - ]: 198 : entities_out.resize(size);
654 : :
655 : : // if input vector was too small, try again with increased size
656 [ + - ][ - + ]: 198 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
657 : 0 : alloc = entities_out.size();
658 [ # # ]: 0 : ptr = &entities_out[0];
659 [ # # ]: 0 : iGeom_getEntities(mInstance, set, type, &ptr, &alloc, &size, &err);
660 : : }
661 : :
662 : 198 : return (Error) err;
663 : : }
664 : :
665 : 0 : inline iGeom::Error iGeom::deleteEnt(EntityHandle handle)
666 : : {
667 : : int err;
668 [ # # ]: 0 : iGeom_deleteEnt(mInstance, handle, &err);
669 : 0 : return (Error) err;
670 : : }
671 : :
672 : : //inline iGeom::Error
673 : : //iGeom::deleteEntArr( const EntityHandle* entity_handles, int num_handles )
674 : : //{
675 : : // int err;
676 : : // iGeom_deleteEntArr( mInstance, entity_handles, num_handles, &err );
677 : : // return (Error)err;
678 : : //}
679 : :
680 : : //inline iGeom::Error
681 : : //iGeom::getAdjEntities( EntitySetHandle set,
682 : : // EntityType type_requestor,
683 : : // EntityType type_requested,
684 : : // std::vector<EntityHandle>& adj_entity_handles,
685 : : // std::vector<int>& offset )
686 : : //{
687 : : // std::vector<EntityHandle> entities;
688 : : // Error err = getEntities( set, type_requestor, entities );
689 : : // if (iBase_SUCCESS != err)
690 : : // return err;
691 : : //
692 : : // offset.resize( entities.size() + 1 );
693 : : // return getArrAdj( &entities[0], entities.size(), type_requested,
694 : : // adj_entity_handles, &offset[0] );
695 : : //}
696 : :
697 : 0 : inline iGeom::Error iGeom::initEntIter(EntitySetHandle set,
698 : : EntityType requested_type, iGeom::EntIter& iter)
699 : : {
700 : : int err;
701 : 0 : iter.mInstance = mInstance;
702 [ # # ]: 0 : iGeom_initEntIter(mInstance, set, requested_type, &iter.mHandle, &err);
703 : 0 : return (Error) err;
704 : : }
705 : :
706 : 0 : inline iGeom::Error iGeom::initEntArrIter(EntitySetHandle set,
707 : : EntityType requested_type, int requested_array_size,
708 : : iGeom::EntArrIter& iter)
709 : : {
710 : : int err;
711 : 0 : iter.mInstance = mInstance;
712 : 0 : iter.mSize = requested_array_size;
713 : : iGeom_initEntArrIter(mInstance, set, requested_type, requested_array_size,
714 [ # # ]: 0 : &iter.mHandle, &err);
715 : 0 : return (Error) err;
716 : : }
717 : :
718 : : inline iGeom::EntArrIter::~EntArrIter()
719 : : {
720 : : int err;
721 : : if (mHandle != 0) {
722 : : iGeom_endEntArrIter(mInstance, mHandle, &err);
723 : : mHandle = 0;
724 : : }
725 : : }
726 : :
727 : : inline iGeom::EntIter::~EntIter()
728 : : {
729 : : int err;
730 : : if (mHandle != 0) {
731 : : iGeom_endEntIter(mInstance, mHandle, &err);
732 : : mHandle = 0;
733 : : }
734 : : }
735 : :
736 : : inline iGeom::Error iGeom::EntArrIter::getNext(EntityHandle* entity_handles,
737 : : int& size_out, bool& has_more_data_out)
738 : : {
739 : : int err, alloc = mSize, has_data;
740 : : iGeom_getNextEntArrIter(mInstance, mHandle, &entity_handles, &alloc,
741 : : &size_out, &has_data, &err);
742 : : has_more_data_out = (has_data != 0);
743 : : return (Error) err;
744 : : }
745 : :
746 : : inline iGeom::Error iGeom::EntIter::getNext(EntityHandle& handle_out,
747 : : bool& has_more_data_out)
748 : : {
749 : : int err, has_data;
750 : : iGeom_getNextEntIter(mInstance, mHandle, &handle_out, &has_data, &err);
751 : : has_more_data_out = (has_data != 0);
752 : : return (Error) err;
753 : : }
754 : :
755 : : inline iGeom::Error iGeom::EntArrIter::reset()
756 : : {
757 : : int err;
758 : : iGeom_resetEntArrIter(mInstance, mHandle, &err);
759 : : return (Error) err;
760 : : }
761 : :
762 : : inline iGeom::Error iGeom::EntIter::reset()
763 : : {
764 : : int err;
765 : : iGeom_resetEntIter(mInstance, mHandle, &err);
766 : : return (Error) err;
767 : : }
768 : :
769 : 70494 : inline iGeom::Error iGeom::getEntType(EntityHandle handle, EntityType& type_out) const
770 : : {
771 : : int err, result;
772 [ + - ]: 70494 : iGeom_getEntType(mInstance, handle, &result, &err);
773 : 70494 : type_out = (EntityType) result;
774 : 70494 : return (Error) err;
775 : : }
776 : :
777 : 0 : inline iGeom::Error iGeom::getArrType(const EntityHandle* entity_handles,
778 : : int entity_handles_size, EntityType* types_out) const
779 : : {
780 : 0 : int err, alloc = entity_handles_size, junk, *ptr;
781 [ # # ]: 0 : std::vector<int> storage;
782 : : if (sizeof(EntityType) == sizeof(int))
783 : 0 : ptr = reinterpret_cast<int*> (types_out);
784 : : else {
785 : : storage.resize(entity_handles_size);
786 : : ptr = &storage[0];
787 : : }
788 : :
789 : : iGeom_getArrType(mInstance, entity_handles, entity_handles_size, &ptr,
790 [ # # ]: 0 : &alloc, &junk, &err);
791 : :
792 : : if (sizeof(EntityType) != sizeof(int))
793 : : for (int i = 0; i < entity_handles_size; ++i)
794 : : types_out[i] = (EntityType) storage[i];
795 : :
796 : 0 : return (Error) err;
797 : : }
798 : :
799 : 5290 : inline iGeom::Error iGeom::getEntAdj(EntityHandle handle,
800 : : EntityType type_requested, std::vector<EntityHandle>& adj_entities_out) const
801 : : {
802 [ + + ]: 5290 : if (adj_entities_out.capacity() == 0)
803 [ + - ]: 4709 : adj_entities_out.resize(12);
804 : : else
805 [ + - ]: 581 : adj_entities_out.resize(adj_entities_out.capacity());
806 : :
807 : 5290 : int err, alloc = adj_entities_out.size(), size = 0;
808 [ + - ]: 5290 : EntityHandle* ptr = &adj_entities_out[0];
809 [ + - ]: 5290 : iGeom_getEntAdj(mInstance, handle, type_requested, &ptr, &alloc, &size, &err);
810 [ + - ]: 5290 : adj_entities_out.resize(size);
811 : :
812 [ + + ][ - + ]: 5290 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
813 : 10 : alloc = adj_entities_out.size();
814 [ + - ]: 10 : ptr = &adj_entities_out[0];
815 : : iGeom_getEntAdj(mInstance, handle, type_requested, &ptr, &alloc, &size,
816 [ + - ]: 10 : &err);
817 : : }
818 : :
819 : 5290 : return (Error) err;
820 : : }
821 : :
822 : 0 : inline iGeom::Error iGeom::getArrAdj(const EntityHandle* entity_handles,
823 : : int entity_handles_size, EntityType type_requested, std::vector<
824 : : EntityHandle>& adj_entities_out, int* offsets_out) const
825 : : {
826 [ # # ]: 0 : if (adj_entities_out.capacity() == 0)
827 [ # # ]: 0 : adj_entities_out.resize(12 * entity_handles_size);
828 : : else
829 [ # # ]: 0 : adj_entities_out.resize(adj_entities_out.capacity());
830 : :
831 : 0 : int err, alloc = adj_entities_out.size(), size = 0;
832 : 0 : int off_alloc = entity_handles_size + 1, junk;
833 [ # # ]: 0 : EntityHandle* ptr = &adj_entities_out[0];
834 : : iGeom_getArrAdj(mInstance, entity_handles, entity_handles_size,
835 : : type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
836 [ # # ]: 0 : &err);
837 [ # # ]: 0 : adj_entities_out.resize(size);
838 : :
839 [ # # ][ # # ]: 0 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
840 : 0 : alloc = adj_entities_out.size();
841 [ # # ]: 0 : ptr = &adj_entities_out[0];
842 : : iGeom_getArrAdj(mInstance, entity_handles, entity_handles_size,
843 : : type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
844 [ # # ]: 0 : &err);
845 : : }
846 : :
847 : 0 : return (Error) err;
848 : : }
849 : :
850 : 0 : inline iGeom::Error iGeom::getEnt2ndAdj(EntityHandle handle,
851 : : EntityType bridge_entity_type, EntityType type_requested, std::vector<
852 : : EntityHandle>& adj_entities_out) const
853 : : {
854 [ # # ]: 0 : if (adj_entities_out.capacity() == 0)
855 [ # # ]: 0 : adj_entities_out.resize(12);
856 : : else
857 [ # # ]: 0 : adj_entities_out.resize(adj_entities_out.capacity());
858 : :
859 : 0 : int err, alloc = adj_entities_out.size(), size = 0;
860 [ # # ]: 0 : EntityHandle* ptr = &adj_entities_out[0];
861 : : iGeom_getEnt2ndAdj(mInstance, handle, bridge_entity_type, type_requested,
862 [ # # ]: 0 : &ptr, &alloc, &size, &err);
863 [ # # ]: 0 : adj_entities_out.resize(size);
864 : :
865 [ # # ][ # # ]: 0 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
866 : 0 : alloc = adj_entities_out.size();
867 [ # # ]: 0 : ptr = &adj_entities_out[0];
868 : : iGeom_getEnt2ndAdj(mInstance, handle, bridge_entity_type, type_requested,
869 [ # # ]: 0 : &ptr, &alloc, &size, &err);
870 : : }
871 : :
872 : 0 : return (Error) err;
873 : : }
874 : :
875 : 0 : inline iGeom::Error iGeom::getArr2ndAdj(const EntityHandle* entity_handles,
876 : : int entity_handles_size, EntityType order_key, EntityType type_requested,
877 : : std::vector<EntityHandle>& adj_entities_out, int* offsets_out) const
878 : : {
879 [ # # ]: 0 : if (adj_entities_out.capacity() == 0)
880 [ # # ]: 0 : adj_entities_out.resize(12 * entity_handles_size);
881 : : else
882 [ # # ]: 0 : adj_entities_out.resize(adj_entities_out.capacity());
883 : :
884 : 0 : int err, alloc = adj_entities_out.size(), size = 0;
885 : 0 : int off_alloc = entity_handles_size + 1, junk;
886 [ # # ]: 0 : EntityHandle* ptr = &adj_entities_out[0];
887 : : iGeom_getArr2ndAdj(mInstance, entity_handles, entity_handles_size, order_key,
888 : : type_requested, &ptr, &alloc, &size, &offsets_out, &off_alloc, &junk,
889 [ # # ]: 0 : &err);
890 [ # # ]: 0 : adj_entities_out.resize(size);
891 : :
892 [ # # ][ # # ]: 0 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
893 : 0 : alloc = adj_entities_out.size();
894 [ # # ]: 0 : ptr = &adj_entities_out[0];
895 : : iGeom_getArr2ndAdj(mInstance, entity_handles, entity_handles_size,
896 : : order_key, type_requested, &ptr, &alloc, &size, &offsets_out,
897 [ # # ]: 0 : &off_alloc, &junk, &err);
898 : : }
899 : :
900 : 0 : return (Error) err;
901 : : }
902 : :
903 : 6 : inline iGeom::Error iGeom::getBoundBox(double& min_x, double& min_y,
904 : : double& min_z, double& max_x, double& max_y, double& max_z) const
905 : : {
906 : : int err;
907 : : iGeom_getBoundBox(mInstance, &min_x, &min_y, &min_z, &max_x, &max_y, &max_z,
908 [ + - ]: 6 : &err);
909 : 6 : return (Error) err;
910 : : }
911 : :
912 : 0 : inline int iGeom::getParametric()
913 : : {
914 : : int err, result;
915 [ # # ]: 0 : iGeom_getParametric(mInstance, &result, &err);
916 : 0 : return result;
917 : : }
918 : :
919 : 76 : inline iGeom::Error iGeom::isEntAdj(EntityHandle entity1, EntityHandle entity2,
920 : : bool& adjacent_out) const
921 : : {
922 : : int err, result;
923 [ + - ]: 76 : iGeom_isEntAdj(mInstance, entity1, entity2, &result, &err);
924 : 76 : adjacent_out = (result != 0);
925 : 76 : return (Error) err;
926 : : }
927 : :
928 : 0 : inline iGeom::Error iGeom::isArrAdj(const EntityHandle* entities1,
929 : : const EntityHandle* entities2, int num_entity_pairs, int* is_adj_out) const
930 : : {
931 : 0 : int err, alloc = num_entity_pairs, size = 0;
932 : : iGeom_isArrAdj(mInstance, entities1, num_entity_pairs, entities2,
933 [ # # ]: 0 : num_entity_pairs, &is_adj_out, &alloc, &size, &err);
934 : 0 : return (Error) err;
935 : : }
936 : :
937 : 601 : inline iGeom::Error iGeom::getEntClosestPt(EntityHandle entity, double near_x,
938 : : double near_y, double near_z, double& on_x, double& on_y, double& on_z) const
939 : : {
940 : : int err;
941 : : iGeom_getEntClosestPt(mInstance, entity, near_x, near_y, near_z, &on_x,
942 [ + - ]: 601 : &on_y, &on_z, &err);
943 : 601 : return (Error) err;
944 : : }
945 : :
946 : 469 : inline iGeom::Error iGeom::getEntClosestPtTrimmed(EntityHandle entity, double near_x,
947 : : double near_y, double near_z, double& on_x, double& on_y, double& on_z) const
948 : : {
949 : : int err;
950 [ + - ]: 469 : iGeom_getEntClosestPtTrimmed(mInstance, entity, near_x, near_y, near_z, &on_x, &on_y, &on_z, &err);
951 : 469 : return (Error) err;
952 : : }
953 : :
954 : 0 : inline iGeom::Error iGeom::getArrClosestPt(const EntityHandle* handles,
955 : : int handles_size, StorageOrder order, const double* near_coordinates,
956 : : int near_coordinates_size, double* on_coordinates) const
957 : : {
958 [ # # ]: 0 : int err, alloc = std::max(near_coordinates_size, 3 * handles_size), size = 0;
959 : : iGeom_getArrClosestPt(mInstance, handles, handles_size, order,
960 : : near_coordinates, near_coordinates_size, &on_coordinates, &alloc, &size,
961 [ # # ]: 0 : &err);
962 : 0 : return (Error) err;
963 : : }
964 : :
965 : 308937 : inline iGeom::Error iGeom::getEntNrmlXYZ(EntityHandle entity, double x,
966 : : double y, double z, double& i, double& j, double& k) const
967 : : {
968 : : int err;
969 [ + - ]: 308937 : iGeom_getEntNrmlXYZ(mInstance, entity, x, y, z, &i, &j, &k, &err);
970 : 308937 : return (Error) err;
971 : : }
972 : :
973 : 0 : inline iGeom::Error iGeom::getArrNrmlXYZ(const EntityHandle* entities,
974 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
975 : : double* ijk) const
976 : : {
977 [ # # ]: 0 : int err, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
978 : : iGeom_getArrNrmlXYZ(mInstance, entities, entities_size, order, xyz, xyz_size,
979 [ # # ]: 0 : &ijk, &alloc, &size, &err);
980 : 0 : return (Error) err;
981 : : }
982 : :
983 : 0 : inline iGeom::Error iGeom::getEntNrmlPlXYZ(EntityHandle entity, double x,
984 : : double y, double z, double& on_x, double& on_y, double& on_z, double& i,
985 : : double& j, double& k) const
986 : : {
987 : : int err;
988 : : iGeom_getEntNrmlPlXYZ(mInstance, entity, x, y, z, &on_x, &on_y, &on_z, &i,
989 [ # # ]: 0 : &j, &k, &err);
990 : 0 : return (Error) err;
991 : : }
992 : :
993 : 0 : inline iGeom::Error iGeom::getArrNrmlPlXYZ(const EntityHandle* entities,
994 : : int entities_size, StorageOrder order, const double* near_xyz,
995 : : int near_xyz_size, double* on_xyz, double* nrml_ijk) const
996 : : {
997 [ # # ]: 0 : int err, alloc = std::max(near_xyz_size, 3 * entities_size), size = 0;
998 : : iGeom_getArrNrmlPlXYZ(mInstance, entities, entities_size, order, near_xyz,
999 [ # # ]: 0 : near_xyz_size, &on_xyz, &alloc, &size, &nrml_ijk, &alloc, &size, &err);
1000 : 0 : return (Error) err;
1001 : : }
1002 : :
1003 : 0 : inline iGeom::Error iGeom::getEntTgntXYZ(EntityHandle entity, double x,
1004 : : double y, double z, double& i, double& j, double& k) const
1005 : : {
1006 : : int err;
1007 [ # # ]: 0 : iGeom_getEntTgntXYZ(mInstance, entity, x, y, z, &i, &j, &k, &err);
1008 : 0 : return (Error) err;
1009 : : }
1010 : :
1011 : 0 : inline iGeom::Error iGeom::getArrTgntXYZ(const EntityHandle* entities,
1012 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
1013 : : double* ijk) const
1014 : : {
1015 [ # # ]: 0 : int err, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
1016 : : iGeom_getArrTgntXYZ(mInstance, entities, entities_size, order, xyz, xyz_size,
1017 [ # # ]: 0 : &ijk, &alloc, &size, &err);
1018 : 0 : return (Error) err;
1019 : : }
1020 : :
1021 : 0 : inline iGeom::Error iGeom::getFcCvtrXYZ(EntityHandle face, double x, double y,
1022 : : double z, double& i1, double& j1, double& k1, double& i2, double& j2,
1023 : : double& k2) const
1024 : : {
1025 : : int err;
1026 : : iGeom_getFcCvtrXYZ(mInstance, face, x, y, z, &i1, &j1, &k1, &i2, &j2, &k2,
1027 [ # # ]: 0 : &err);
1028 : 0 : return (Error) err;
1029 : : }
1030 : :
1031 : 0 : inline iGeom::Error iGeom::getEgCvtrXYZ(EntityHandle edge, double x, double y,
1032 : : double z, double& i, double& j, double& k) const
1033 : : {
1034 : : int err;
1035 [ # # ]: 0 : iGeom_getEgCvtrXYZ(mInstance, edge, x, y, z, &i, &j, &k, &err);
1036 : 0 : return (Error) err;
1037 : : }
1038 : :
1039 : 0 : inline iGeom::Error iGeom::getEntArrCvtrXYZ(const EntityHandle* entities,
1040 : : int entities_size, StorageOrder order, const double* xyz, int xyz_size,
1041 : : double* cvtr_1, double* cvtr_2) const
1042 : : {
1043 [ # # ]: 0 : int err, alloc = std::max(xyz_size, 3 * entities_size), size = 0;
1044 : : iGeom_getEntArrCvtrXYZ(mInstance, entities, entities_size, order, xyz,
1045 [ # # ]: 0 : xyz_size, &cvtr_1, &alloc, &size, &cvtr_2, &alloc, &size, &err);
1046 : 0 : return (Error) err;
1047 : : }
1048 : :
1049 : 0 : inline iGeom::Error iGeom::getEgEvalXYZ(EntityHandle edge, double x, double y,
1050 : : double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
1051 : : double& tngt_j, double& tngt_k, double& cvtr_i, double& cvtr_j,
1052 : : double& cvtr_k) const
1053 : : {
1054 : : int err;
1055 : : iGeom_getEgEvalXYZ(mInstance, edge, x, y, z, &on_x, &on_y, &on_z, &tngt_i,
1056 [ # # ]: 0 : &tngt_j, &tngt_k, &cvtr_i, &cvtr_j, &cvtr_k, &err);
1057 : 0 : return (Error) err;
1058 : : }
1059 : :
1060 : 6912 : inline iGeom::Error iGeom::getFcEvalXYZ(EntityHandle face, double x, double y,
1061 : : double z, double& on_x, double& on_y, double& on_z, double& tngt_i,
1062 : : double& tngt_j, double& tngt_k, double& cvtr1_i, double& cvtr1_j,
1063 : : double& cvtr1_k, double& cvtr2_i, double& cvtr2_j, double& cvtr2_k) const
1064 : : {
1065 : : int err;
1066 : : iGeom_getFcEvalXYZ(mInstance, face, x, y, z, &on_x, &on_y, &on_z, &tngt_i,
1067 : : &tngt_j, &tngt_k, &cvtr1_i, &cvtr1_j, &cvtr1_k, &cvtr2_i, &cvtr2_j,
1068 [ + - ]: 6912 : &cvtr2_k, &err);
1069 : 6912 : return (Error) err;
1070 : : }
1071 : :
1072 : 0 : inline iGeom::Error iGeom::getArrEgEvalXYZ(const EntityHandle* edges,
1073 : : int edges_size, StorageOrder order, const double* near_coords,
1074 : : int near_coords_size, double* on_coords, double* tangent, double* curvature) const
1075 : : {
1076 [ # # ]: 0 : int err, alloc = std::max(near_coords_size, 3 * edges_size), size = 0;
1077 : : iGeom_getArrEgEvalXYZ(mInstance, edges, edges_size, order, near_coords,
1078 : : near_coords_size, &on_coords, &alloc, &size, &tangent, &alloc, &size,
1079 [ # # ]: 0 : &curvature, &alloc, &size, &err);
1080 : 0 : return (Error) err;
1081 : : }
1082 : :
1083 : 0 : inline iGeom::Error iGeom::getArrFcEvalXYZ(const EntityHandle* faces,
1084 : : int faces_size, StorageOrder order, const double* near_coords,
1085 : : int near_coords_size, double* on_coords, double* tangent,
1086 : : double* curvature1, double* curvature2) const
1087 : : {
1088 [ # # ]: 0 : int err, alloc = std::max(near_coords_size, 3 * faces_size), size = 0;
1089 : : iGeom_getArrFcEvalXYZ(mInstance, faces, faces_size, order, near_coords,
1090 : : near_coords_size, &on_coords, &alloc, &size, &tangent, &alloc, &size,
1091 [ # # ]: 0 : &curvature1, &alloc, &size, &curvature2, &alloc, &size, &err);
1092 : 0 : return (Error) err;
1093 : : }
1094 : :
1095 : 51 : inline iGeom::Error iGeom::getEntBoundBox(EntityHandle entity, double& min_x,
1096 : : double& min_y, double& min_z, double& max_x, double& max_y, double& max_z) const
1097 : : {
1098 : : int err;
1099 : : iGeom_getEntBoundBox(mInstance, entity, &min_x, &min_y, &min_z, &max_x,
1100 [ + - ]: 51 : &max_y, &max_z, &err);
1101 : 51 : return (Error) err;
1102 : : }
1103 : :
1104 : 0 : inline iGeom::Error iGeom::getArrBoundBox(const EntityHandle* entities,
1105 : : int entities_size, StorageOrder order, double* min_corners,
1106 : : double* max_corners) const
1107 : : {
1108 : 0 : int err, alloc = 3 * entities_size, size = 0, order_int = order;
1109 : : iGeom_getArrBoundBox(mInstance, entities, entities_size, order_int,
1110 [ # # ]: 0 : &min_corners, &alloc, &size, &max_corners, &alloc, &size, &err);
1111 : 0 : return (Error) err;
1112 : : }
1113 : :
1114 : 14574 : inline iGeom::Error iGeom::getVtxCoord(EntityHandle vertex, double& x,
1115 : : double& y, double& z) const
1116 : : {
1117 : : int err;
1118 [ + - ]: 14574 : iGeom_getVtxCoord(mInstance, vertex, &x, &y, &z, &err);
1119 : 14574 : return (Error) err;
1120 : : }
1121 : :
1122 : 0 : inline iGeom::Error iGeom::getVtxArrCoords(const EntityHandle* vertices,
1123 : : int vertices_size, StorageOrder order, double* coords) const
1124 : : {
1125 : 0 : int err, alloc = vertices_size, size = 0;
1126 : : iGeom_getVtxArrCoords(mInstance, vertices, vertices_size, order, &coords,
1127 [ # # ]: 0 : &alloc, &size, &err);
1128 : 0 : return (Error) err;
1129 : : }
1130 : :
1131 : 0 : inline iGeom::Error iGeom::getPntRayIntsct(double x, double y, double z,
1132 : : double i, double j, double k, StorageOrder order,
1133 : : std::vector<EntityHandle>& entities_out, std::vector<double>& points_out,
1134 : : std::vector<double>& params_out) const
1135 : : {
1136 : : int err, count;
1137 [ # # ][ # # ]: 0 : Error err2 = getNumOfType(getRootSet(), iBase_ALL_TYPES, count);
1138 [ # # ]: 0 : if (err2 != iBase_SUCCESS)
1139 : 0 : return err2;
1140 : :
1141 [ # # ]: 0 : entities_out.resize(count);
1142 [ # # ]: 0 : points_out.resize(3 * count);
1143 [ # # ]: 0 : params_out.resize(2 * count);
1144 : 0 : int entities_alloc = entities_out.size(), entities_size = 0;
1145 : 0 : int points_alloc = points_out.size(), points_size = 0;
1146 : 0 : int params_alloc = params_out.size(), params_size = 0;
1147 [ # # ]: 0 : EntityHandle* entities_ptr = &entities_out[0];
1148 [ # # ]: 0 : double * points_ptr = &points_out[0];
1149 [ # # ]: 0 : double * params_ptr = ¶ms_out[0];
1150 : :
1151 : : iGeom_getPntRayIntsct(mInstance, x, y, z, i, j, k, &entities_ptr,
1152 : : &entities_alloc, &entities_size, order, &points_ptr, &points_alloc,
1153 [ # # ]: 0 : &points_size, ¶ms_ptr, ¶ms_alloc, ¶ms_size, &err);
1154 [ # # ]: 0 : entities_out.resize(entities_size);
1155 [ # # ]: 0 : points_out.resize(points_size);
1156 [ # # ]: 0 : params_out.resize(params_size);
1157 [ # # ][ # # ]: 0 : if (err == iBase_BAD_ARRAY_SIZE || err == iBase_BAD_ARRAY_DIMENSION) {
1158 : 0 : entities_alloc = entities_out.size();
1159 : 0 : points_alloc = points_out.size();
1160 : 0 : params_alloc = params_out.size();
1161 [ # # ]: 0 : entities_ptr = &entities_out[0];
1162 [ # # ]: 0 : points_ptr = &points_out[0];
1163 [ # # ]: 0 : params_ptr = ¶ms_out[0];
1164 : : iGeom_getPntRayIntsct(mInstance, x, y, z, i, j, k, &entities_ptr,
1165 : : &entities_alloc, &entities_size, order, &points_ptr, &points_alloc,
1166 [ # # ]: 0 : &points_size, ¶ms_ptr, ¶ms_alloc, ¶ms_size, &err);
1167 : : }
1168 : :
1169 : 0 : return (Error) err;
1170 : : }
1171 : :
1172 : 0 : inline iGeom::Error iGeom::getPntClsf(double x, double y, double z,
1173 : : EntityHandle& handle_out) const
1174 : : {
1175 : : int err;
1176 [ # # ]: 0 : iGeom_getPntClsf(mInstance, x, y, z, &handle_out, &err);
1177 : 0 : return (Error) err;
1178 : : }
1179 : :
1180 : 0 : inline iGeom::Error iGeom::getPntArrClsf(StorageOrder order,
1181 : : const double* coords, int coords_size, EntityHandle* entities_out) const
1182 : : {
1183 : 0 : int err, alloc = coords_size / 3, size = 0;
1184 : : iGeom_getPntArrClsf(mInstance, order, coords, coords_size, &entities_out,
1185 [ # # ]: 0 : &alloc, &size, &err);
1186 : 0 : return (Error) err;
1187 : : }
1188 : :
1189 : 1727 : inline iGeom::Error iGeom::getSense(EntityHandle ent, EntityHandle wrt_ent,
1190 : : int &sense) const
1191 : : {
1192 : : EntityType tp_wrt, tp_ent;
1193 [ + - ]: 1727 : Error err = getEntType(wrt_ent, tp_wrt);
1194 [ - + ]: 1727 : if (iBase_SUCCESS != err)
1195 : 0 : return err;
1196 [ + - ]: 1727 : err = getEntType(ent, tp_ent);
1197 [ - + ]: 1727 : if (iBase_SUCCESS != err)
1198 : 0 : return err;
1199 [ - + ]: 1727 : if (tp_wrt - tp_ent != 1)
1200 : 0 : return iBase_FAILURE;
1201 [ + + - - : 1727 : switch (tp_wrt) {
- ]
1202 : : case iBase_REGION:
1203 [ + - ]: 287 : return getEntNrmlSense(ent, wrt_ent, sense);
1204 : : break;
1205 : : case iBase_FACE:
1206 [ + - ]: 1440 : return getEgFcSense(ent, wrt_ent, sense);
1207 : : case iBase_EDGE:
1208 [ # # ]: 0 : return getEgVtxSense(wrt_ent, ent, ent, sense);
1209 : : case iBase_VERTEX:
1210 : : case iBase_ALL_TYPES:
1211 : 0 : return iBase_FAILURE;
1212 : : }
1213 : 1727 : return iBase_FAILURE;
1214 : : }
1215 : :
1216 : 0 : inline iGeom::Error iGeom::getArrSense(const EntityHandle *ent, int num_ents,
1217 : : EntityHandle wrt_ent, int *sense) const
1218 : : {
1219 : : EntityType tp_wrt, tp_ent;
1220 [ # # ]: 0 : Error err = getEntType(wrt_ent, tp_wrt);
1221 [ # # ]: 0 : if (iBase_SUCCESS != err)
1222 : 0 : return err;
1223 [ # # ]: 0 : err = getEntType(ent[0], tp_ent);
1224 [ # # ]: 0 : if (iBase_SUCCESS != err)
1225 : 0 : return err;
1226 [ # # ]: 0 : if (tp_wrt - tp_ent != 1)
1227 : 0 : return iBase_FAILURE;
1228 [ # # ]: 0 : std::vector<EntityHandle> dum_wrts(num_ents, wrt_ent);
1229 [ # # # # : 0 : switch (tp_wrt) {
# ]
1230 : : case iBase_REGION:
1231 [ # # ][ # # ]: 0 : return getArrNrmlSense(ent, num_ents, &dum_wrts[0], num_ents, sense);
1232 : : break;
1233 : : case iBase_FACE:
1234 [ # # ][ # # ]: 0 : return getEgFcArrSense(ent, num_ents, &dum_wrts[0], num_ents, sense);
1235 : : break;
1236 : : case iBase_EDGE:
1237 [ # # ]: 0 : return getEgVtxArrSense(&dum_wrts[0], num_ents, ent, num_ents, ent,
1238 [ # # ]: 0 : num_ents, sense);
1239 : : break;
1240 : : case iBase_VERTEX:
1241 : : case iBase_ALL_TYPES:
1242 : 0 : return iBase_FAILURE;
1243 : : break;
1244 : : }
1245 : 0 : return iBase_FAILURE;
1246 : : }
1247 : :
1248 : 287 : inline iGeom::Error iGeom::getEntNrmlSense(EntityHandle face,
1249 : : EntityHandle region, int& sense) const
1250 : : {
1251 : : int err;
1252 [ + - ]: 287 : iGeom_getEntNrmlSense(mInstance, face, region, &sense, &err);
1253 : 287 : return (Error) err;
1254 : : }
1255 : :
1256 : 1440 : inline iGeom::Error iGeom::getEgFcSense(EntityHandle edge, EntityHandle face,
1257 : : int& sense) const
1258 : : {
1259 : : int err;
1260 [ + - ]: 1440 : iGeom_getEgFcSense(mInstance, edge, face, &sense, &err);
1261 : 1440 : return (Error) err;
1262 : : }
1263 : :
1264 : 1146 : inline iGeom::Error iGeom::getEgVtxSense(EntityHandle edge, EntityHandle vtx1,
1265 : : EntityHandle vtx2, int& sense) const
1266 : : {
1267 : : int err;
1268 [ + - ]: 1146 : iGeom_getEgVtxSense(mInstance, edge, vtx1, vtx2, &sense, &err);
1269 : 1146 : return (Error) err;
1270 : : }
1271 : :
1272 : 0 : inline iGeom::Error iGeom::getArrNrmlSense(const EntityHandle* faces,
1273 : : int faces_size, const EntityHandle* vols, int vols_size, int* senses_out) const
1274 : : {
1275 [ # # ]: 0 : int err, alloc = std::max(vols_size, faces_size), size = 0;
1276 : : iGeom_getArrNrmlSense(mInstance, faces, faces_size, vols, vols_size,
1277 [ # # ]: 0 : &senses_out, &alloc, &size, &err);
1278 : 0 : return (Error) err;
1279 : : }
1280 : :
1281 : 0 : inline iGeom::Error iGeom::getEgFcArrSense(const EntityHandle* edges,
1282 : : int edges_size, const EntityHandle* faces, int faces_size, int* senses_out) const
1283 : : {
1284 [ # # ]: 0 : int err, alloc = std::max(edges_size, faces_size), size = 0;
1285 : : iGeom_getEgFcArrSense(mInstance, edges, edges_size, faces, faces_size,
1286 [ # # ]: 0 : &senses_out, &alloc, &size, &err);
1287 : 0 : return (Error) err;
1288 : : }
1289 : :
1290 : 0 : inline iGeom::Error iGeom::getEgVtxArrSense(const EntityHandle* edges,
1291 : : int edges_size, const EntityHandle* vertices1, int vertices1_size,
1292 : : const EntityHandle* vertices2, int vertices2_size, int* senses_out) const
1293 : : {
1294 : : int err, alloc = std::max(vertices1_size,
1295 [ # # ][ # # ]: 0 : std::max(vertices2_size, edges_size)), size = 0;
1296 : : iGeom_getEgVtxArrSense(mInstance, edges, edges_size, vertices1,
1297 : : vertices1_size, vertices2, vertices2_size, &senses_out, &alloc, &size,
1298 [ # # ]: 0 : &err);
1299 : 0 : return (Error) err;
1300 : : }
1301 : :
1302 : 600 : inline iGeom::Error iGeom::measure(const EntityHandle* entities,
1303 : : int entities_size, double* measures) const
1304 : : {
1305 : 600 : int err, alloc = entities_size, size = 0;
1306 : : iGeom_measure(mInstance, entities, entities_size, &measures, &alloc, &size,
1307 [ + - ]: 600 : &err);
1308 : 600 : return (Error) err;
1309 : : }
1310 : :
1311 : 70 : inline iGeom::Error iGeom::getFaceType(EntityHandle face, std::string& type) const
1312 : : {
1313 : : char buffer[1024];
1314 : 70 : int err, len = sizeof(buffer);
1315 [ + - ]: 70 : iGeom_getFaceType(mInstance, face, buffer, &err, &len);
1316 [ + - ][ + - ]: 70 : type = std::string(buffer, len);
1317 : 70 : return (Error) err;
1318 : : }
1319 : :
1320 : 12 : inline iGeom::Error iGeom::isEntParametric(EntityHandle entity,
1321 : : bool& parametric) const
1322 : : {
1323 : : int err, result;
1324 [ + - ]: 12 : iGeom_isEntParametric(mInstance, entity, &result, &err);
1325 : 12 : parametric = (result != 0);
1326 : 12 : return (Error) err;
1327 : : }
1328 : :
1329 : 0 : inline iGeom::Error iGeom::isArrParametric(const EntityHandle* entities,
1330 : : int entities_size, int* is_parametric) const
1331 : : {
1332 : 0 : int err, alloc = entities_size, size = 1;
1333 : : iGeom_isArrParametric(mInstance, entities, entities_size, &is_parametric,
1334 [ # # ]: 0 : &alloc, &size, &err);
1335 : 0 : return (Error) err;
1336 : : }
1337 : :
1338 : 0 : inline iGeom::Error iGeom::getEntUVtoXYZ(EntityHandle face, double u, double v,
1339 : : double& x, double& y, double& z) const
1340 : : {
1341 : : int err;
1342 [ # # ]: 0 : iGeom_getEntUVtoXYZ(mInstance, face, u, v, &x, &y, &z, &err);
1343 : 0 : return (Error) err;
1344 : : }
1345 : :
1346 : 2297 : inline iGeom::Error iGeom::getEntUtoXYZ(EntityHandle edge, double u, double& x,
1347 : : double& y, double& z) const
1348 : : {
1349 : : int err;
1350 [ + - ]: 2297 : iGeom_getEntUtoXYZ(mInstance, edge, u, &x, &y, &z, &err);
1351 : 2297 : return (Error) err;
1352 : : }
1353 : :
1354 : 0 : inline iGeom::Error iGeom::getArrUVtoXYZ(const EntityHandle* faces,
1355 : : int faces_size, StorageOrder order, const double* uv, int uv_size,
1356 : : double* xyz) const
1357 : : {
1358 [ # # ]: 0 : int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
1359 : : iGeom_getArrUVtoXYZ(mInstance, faces, faces_size, order, uv, uv_size, &xyz,
1360 [ # # ]: 0 : &alloc, &size, &err);
1361 : 0 : return (Error) err;
1362 : : }
1363 : :
1364 : 0 : inline iGeom::Error iGeom::getArrUtoXYZ(const EntityHandle* edges,
1365 : : int edges_size, const double* u, int u_size, StorageOrder order,
1366 : : double* xyz) const
1367 : : {
1368 [ # # ]: 0 : int err, alloc = std::max(3 * u_size, 3 * edges_size), size = 0;
1369 : : iGeom_getArrUtoXYZ(mInstance, edges, edges_size, u, u_size, order, &xyz,
1370 [ # # ]: 0 : &alloc, &size, &err);
1371 : 0 : return (Error) err;
1372 : : }
1373 : :
1374 : 0 : inline iGeom::Error iGeom::getEntXYZtoUV(EntityHandle face, double x, double y,
1375 : : double z, double& u, double& v) const
1376 : : {
1377 : : int err;
1378 [ # # ]: 0 : iGeom_getEntXYZtoUV(mInstance, face, x, y, z, &u, &v, &err);
1379 : 0 : return (Error) err;
1380 : : }
1381 : :
1382 : 0 : inline iGeom::Error iGeom::getEntXYZtoU(EntityHandle edge, double x, double y,
1383 : : double z, double& u) const
1384 : : {
1385 : : int err;
1386 [ # # ]: 0 : iGeom_getEntXYZtoU(mInstance, edge, x, y, z, &u, &err);
1387 : 0 : return (Error) err;
1388 : : }
1389 : :
1390 : 0 : inline iGeom::Error iGeom::getArrXYZtoUV(const EntityHandle* faces,
1391 : : int faces_size, StorageOrder order, const double* coords, int coords_size,
1392 : : double* uv) const
1393 : : {
1394 [ # # ]: 0 : int err, alloc = std::max(2 * coords_size / 3, 2 * faces_size), size = 0;
1395 : : iGeom_getArrXYZtoUV(mInstance, faces, faces_size, order, coords, coords_size,
1396 [ # # ]: 0 : &uv, &alloc, &size, &err);
1397 : 0 : return (Error) err;
1398 : : }
1399 : :
1400 : 0 : inline iGeom::Error iGeom::getArrXYZtoU(const EntityHandle* edges,
1401 : : int edges_size, StorageOrder order, const double* coords, int coords_size,
1402 : : double* u) const
1403 : : {
1404 [ # # ]: 0 : int err, alloc = std::max(coords_size / 3, edges_size), size = 0;
1405 : : iGeom_getArrXYZtoU(mInstance, edges, edges_size, order, coords, coords_size,
1406 [ # # ]: 0 : &u, &alloc, &size, &err);
1407 : 0 : return (Error) err;
1408 : : }
1409 : :
1410 : 0 : inline iGeom::Error iGeom::getEntXYZtoUVHint(EntityHandle face, double x,
1411 : : double y, double z, double& u, double& v) const
1412 : : {
1413 : : int err;
1414 [ # # ]: 0 : iGeom_getEntXYZtoUVHint(mInstance, face, x, y, z, &u, &v, &err);
1415 : 0 : return (Error) err;
1416 : : }
1417 : :
1418 : 0 : inline iGeom::Error iGeom::getArrXYZtoUVHint(const EntityHandle* faces,
1419 : : int faces_size, StorageOrder order, const double* coords, int coords_size,
1420 : : double* uv) const
1421 : : {
1422 [ # # ]: 0 : int err, alloc = std::max(2 * coords_size / 3, 2 * faces_size), size = 0;
1423 : : iGeom_getArrXYZtoUVHint(mInstance, faces, faces_size, order, coords,
1424 [ # # ]: 0 : coords_size, &uv, &alloc, &size, &err);
1425 : 0 : return (Error) err;
1426 : : }
1427 : :
1428 : 0 : inline iGeom::Error iGeom::getEntNrmlUV(EntityHandle face, double u, double v,
1429 : : double& i, double& j, double& k) const
1430 : : {
1431 : : int err;
1432 [ # # ]: 0 : iGeom_getEntNrmlUV(mInstance, face, u, v, &i, &j, &k, &err);
1433 : 0 : return (Error) err;
1434 : : }
1435 : :
1436 : 0 : inline iGeom::Error iGeom::getArrNrmlUV(const EntityHandle* faces,
1437 : : int faces_size, StorageOrder order, const double* uv, int uv_size,
1438 : : double* normals) const
1439 : : {
1440 [ # # ]: 0 : int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
1441 : : iGeom_getArrNrmlUV(mInstance, faces, faces_size, order, uv, uv_size,
1442 [ # # ]: 0 : &normals, &alloc, &size, &err);
1443 : 0 : return (Error) err;
1444 : : }
1445 : :
1446 : 120 : inline iGeom::Error iGeom::getEntTgntU(EntityHandle edge, double u, double& i,
1447 : : double& j, double& k) const
1448 : : {
1449 : : int err;
1450 [ + - ]: 120 : iGeom_getEntTgntU(mInstance, edge, u, &i, &j, &k, &err);
1451 : 120 : return (Error) err;
1452 : : }
1453 : :
1454 : 0 : inline iGeom::Error iGeom::getArrTgntU(const EntityHandle* edges,
1455 : : int edges_size, StorageOrder order, const double* u, int u_size,
1456 : : double* normals) const
1457 : : {
1458 [ # # ]: 0 : int err, alloc = std::max(3 * u_size, 3 * edges_size), size = 0;
1459 : : iGeom_getArrTgntU(mInstance, edges, edges_size, order, u, u_size, &normals,
1460 [ # # ]: 0 : &alloc, &size, &err);
1461 : 0 : return (Error) err;
1462 : : }
1463 : :
1464 : 0 : inline iGeom::Error iGeom::getEnt1stDrvt(EntityHandle handle, double u,
1465 : : double v, double& du_i, double& du_j, double& du_k, double& dv_i,
1466 : : double& dv_j, double& dv_k) const
1467 : : {
1468 : 0 : int err, du_alloc = 3, dv_alloc = 3, du_size = 0, dv_size = 0;
1469 : 0 : double du[3], dv[3], *du_ptr = du, *dv_ptr = dv;
1470 : : iGeom_getEnt1stDrvt(mInstance, handle, u, v, &du_ptr, &du_alloc, &du_size,
1471 [ # # ]: 0 : &dv_ptr, &dv_alloc, &dv_size, &err);
1472 : 0 : du_i = du[0];
1473 : 0 : du_j = du[1];
1474 : 0 : du_k = du[2];
1475 : 0 : dv_i = dv[0];
1476 : 0 : dv_j = dv[1];
1477 : 0 : dv_k = dv[2];
1478 : 0 : return (Error) err;
1479 : : }
1480 : :
1481 : 0 : inline iGeom::Error iGeom::getEnt2ndDrvt(EntityHandle handle, double u,
1482 : : double v, double& duu_i, double& duu_j, double& duu_k, double& dvv_i,
1483 : : double& dvv_j, double& dvv_k, double& duv_i, double& duv_j, double& duv_k) const
1484 : : {
1485 : 0 : int err, uu_alloc = 3, uv_alloc = 3, vv_alloc = 3, uu_size = 0, uv_size = 0,
1486 : 0 : vv_size = 0;
1487 : 0 : double uu[3], uv[3], vv[3], *uu_ptr = uu, *vv_ptr = vv, *uv_ptr = uv;
1488 : : iGeom_getEnt2ndDrvt(mInstance, handle, u, v, &uu_ptr, &uu_alloc, &uu_size,
1489 [ # # ]: 0 : &vv_ptr, &vv_alloc, &vv_size, &uv_ptr, &uv_alloc, &uv_size, &err);
1490 : 0 : duu_i = uu[0];
1491 : 0 : duu_j = uu[1];
1492 : 0 : duu_k = uu[2];
1493 : 0 : dvv_i = vv[0];
1494 : 0 : dvv_j = vv[1];
1495 : 0 : dvv_k = vv[2];
1496 : 0 : duv_i = uv[0];
1497 : 0 : duv_j = uv[1];
1498 : 0 : duv_k = uv[2];
1499 : 0 : return (Error) err;
1500 : : }
1501 : :
1502 : 0 : inline iGeom::Error iGeom::getArr1stDrvt(const EntityHandle* entities,
1503 : : int entities_size, StorageOrder order, const double* uv, int uv_size,
1504 : : double* dvtr_u, double* dvtr_v) const
1505 : : {
1506 [ # # ]: 0 : int err, allocu = std::max(3 * uv_size / 2, 3 * entities_size), sizeu = 0,
1507 : 0 : allocv = allocu, sizev = 0;
1508 [ # # ][ # # ]: 0 : std::vector<int> offset1(std::max(uv_size / 2, entities_size) + 1);
1509 [ # # ][ # # ]: 0 : std::vector<int> offset2(std::max(uv_size / 2, entities_size) + 1);
1510 [ # # ]: 0 : int alloc1 = offset1.size(), size1 = 0, *ptr1 = &offset1[0];
1511 [ # # ]: 0 : int alloc2 = offset2.size(), size2 = 0, *ptr2 = &offset2[0];
1512 : : iGeom_getArr1stDrvt(mInstance, entities, entities_size, order, uv, uv_size,
1513 : : &dvtr_u, &allocu, &sizeu, &ptr1, &alloc1, &size1, &dvtr_v, &allocv,
1514 [ # # ]: 0 : &sizev, &ptr2, &alloc2, &size2, &err);
1515 : 0 : return (Error) err;
1516 : : }
1517 : :
1518 : 0 : inline iGeom::Error iGeom::getArr2ndDrvt(const EntityHandle* entities,
1519 : : int entities_size, StorageOrder order, const double* uv, int uv_size,
1520 : : double* dvtr_uu, double* dvtr_vv, double* dvtr_uv) const
1521 : : {
1522 [ # # ]: 0 : int err, allocuu = std::max(3 * uv_size / 2, 3 * entities_size), sizeuu = 0,
1523 : 0 : allocvv = allocuu, sizevv = 0, allocuv = allocuu, sizeuv = 0;
1524 [ # # ][ # # ]: 0 : std::vector<int> offset1(std::max(uv_size / 2, entities_size) + 1);
1525 [ # # ][ # # ]: 0 : std::vector<int> offset2(std::max(uv_size / 2, entities_size) + 1);
1526 [ # # ][ # # ]: 0 : std::vector<int> offset3(std::max(uv_size / 2, entities_size) + 1);
1527 [ # # ]: 0 : int alloc1 = offset1.size(), size1 = 0, *ptr1 = &offset1[0];
1528 [ # # ]: 0 : int alloc2 = offset2.size(), size2 = 0, *ptr2 = &offset2[0];
1529 [ # # ]: 0 : int alloc3 = offset3.size(), size3 = 0, *ptr3 = &offset3[0];
1530 : : iGeom_getArr2ndDrvt(mInstance, entities, entities_size, order, uv, uv_size,
1531 : : &dvtr_uu, &allocuu, &sizeuu, &ptr1, &alloc1, &size1, &dvtr_vv, &allocvv,
1532 : : &sizevv, &ptr2, &alloc2, &size2, &dvtr_uv, &allocuv, &sizeuv, &ptr3,
1533 [ # # ]: 0 : &alloc3, &size3, &err);
1534 : 0 : return (Error) err;
1535 : : }
1536 : :
1537 : 0 : inline iGeom::Error iGeom::getFcCvtrUV(EntityHandle face, double u, double v,
1538 : : double& i1, double& j1, double& k1, double& i2, double& j2, double& k2) const
1539 : : {
1540 : : int err;
1541 [ # # ]: 0 : iGeom_getFcCvtrUV(mInstance, face, u, v, &i1, &j1, &k1, &i2, &j2, &k2, &err);
1542 : 0 : return (Error) err;
1543 : : }
1544 : :
1545 : 0 : inline iGeom::Error iGeom::getFcArrCvtrUV(const EntityHandle* faces,
1546 : : int faces_size, StorageOrder order, const double* uv, int uv_size,
1547 : : double* cvtr1, double* cvtr2) const
1548 : : {
1549 [ # # ]: 0 : int err, alloc = std::max(3 * uv_size / 2, 3 * faces_size), size = 0;
1550 : : iGeom_getFcArrCvtrUV(mInstance, faces, faces_size, order, uv, uv_size,
1551 [ # # ]: 0 : &cvtr1, &alloc, &size, &cvtr2, &alloc, &size, &err);
1552 : 0 : return (Error) err;
1553 : : }
1554 : :
1555 : 24 : inline iGeom::Error iGeom::isEntPeriodic(EntityHandle entity, bool& in_u,
1556 : : bool& in_v) const
1557 : : {
1558 : : int err, u, v;
1559 [ + - ]: 24 : iGeom_isEntPeriodic(mInstance, entity, &u, &v, &err);
1560 : 24 : in_u = (u != 0);
1561 : 24 : in_v = (v != 0);
1562 : 24 : return (Error) err;
1563 : : }
1564 : :
1565 : 0 : inline iGeom::Error iGeom::isArrPeriodic(const EntityHandle* entities,
1566 : : int entities_size, int* in_uv) const
1567 : : {
1568 : 0 : int err, alloc = 2 * entities_size, size = 0;
1569 : : iGeom_isArrPeriodic(mInstance, entities, entities_size, &in_uv, &alloc,
1570 [ # # ]: 0 : &size, &err);
1571 : 0 : return (Error) err;
1572 : : }
1573 : :
1574 : 0 : inline iGeom::Error iGeom::isFcDegenerate(EntityHandle face,
1575 : : bool& is_degenerate) const
1576 : : {
1577 : : int err, result;
1578 [ # # ]: 0 : iGeom_isFcDegenerate(mInstance, face, &result, &err);
1579 : 0 : is_degenerate = (result != 0);
1580 : 0 : return (Error) err;
1581 : : }
1582 : :
1583 : 0 : inline iGeom::Error iGeom::isFcArrDegenerate(const EntityHandle* faces,
1584 : : int faces_size, int* degenerate) const
1585 : : {
1586 : 0 : int err, alloc = faces_size, size = 0;
1587 : : iGeom_isFcArrDegenerate(mInstance, faces, faces_size, °enerate, &alloc,
1588 [ # # ]: 0 : &size, &err);
1589 : 0 : return (Error) err;
1590 : : }
1591 : :
1592 : 0 : inline iGeom::Error iGeom::getTolerance(int& type_out, double& tolerance_out) const
1593 : : {
1594 : : int err;
1595 [ # # ]: 0 : iGeom_getTolerance(mInstance, &type_out, &tolerance_out, &err);
1596 : 0 : return (Error) err;
1597 : : }
1598 : :
1599 : 0 : inline iGeom::Error iGeom::getEntTolerance(EntityHandle entity,
1600 : : double& tolerance) const
1601 : : {
1602 : : int err;
1603 [ # # ]: 0 : iGeom_getEntTolerance(mInstance, entity, &tolerance, &err);
1604 : 0 : return (Error) err;
1605 : : }
1606 : :
1607 : 0 : inline iGeom::Error iGeom::getArrTolerance(const EntityHandle* entities,
1608 : : int entities_size, double* tolerances) const
1609 : : {
1610 : 0 : int err, alloc = entities_size, size = 0;
1611 : : iGeom_getArrTolerance(mInstance, entities, entities_size, &tolerances,
1612 [ # # ]: 0 : &alloc, &size, &err);
1613 : 0 : return (Error) err;
1614 : : }
1615 : :
1616 : 12 : inline iGeom::Error iGeom::getEntUVRange(EntityHandle face, double& u_min,
1617 : : double& v_min, double& u_max, double& v_max) const
1618 : : {
1619 : : int err;
1620 [ + - ]: 12 : iGeom_getEntUVRange(mInstance, face, &u_min, &v_min, &u_max, &v_max, &err);
1621 : 12 : return (Error) err;
1622 : : }
1623 : :
1624 : 274 : inline iGeom::Error iGeom::getEntURange(EntityHandle edge, double& u_min,
1625 : : double& u_max) const
1626 : : {
1627 : : int err;
1628 [ + - ]: 274 : iGeom_getEntURange(mInstance, edge, &u_min, &u_max, &err);
1629 : 274 : return (Error) err;
1630 : : }
1631 : :
1632 : 0 : inline iGeom::Error iGeom::getArrUVRange(const EntityHandle* faces,
1633 : : int faces_size, StorageOrder order, double* uv_min, double* uv_max) const
1634 : : {
1635 : 0 : int err, alloc = faces_size, size = 0;
1636 : : iGeom_getArrUVRange(mInstance, faces, faces_size, order, &uv_min, &alloc,
1637 [ # # ]: 0 : &size, &uv_max, &alloc, &size, &err);
1638 : 0 : return (Error) err;
1639 : : }
1640 : :
1641 : 0 : inline iGeom::Error iGeom::getArrURange(const EntityHandle* edges,
1642 : : int edges_size, double* u_min, double* u_max) const
1643 : : {
1644 : 0 : int err, alloc = edges_size, size = 0;
1645 : : iGeom_getArrURange(mInstance, edges, edges_size, &u_min, &alloc, &size,
1646 [ # # ]: 0 : &u_max, &alloc, &size, &err);
1647 : 0 : return (Error) err;
1648 : : }
1649 : :
1650 : 0 : inline iGeom::Error iGeom::getEntUtoUV(EntityHandle edge, EntityHandle face,
1651 : : double edge_u, double& face_u, double& face_v) const
1652 : : {
1653 : : int err;
1654 [ # # ]: 0 : iGeom_getEntUtoUV(mInstance, edge, face, edge_u, &face_u, &face_v, &err);
1655 : 0 : return (Error) err;
1656 : : }
1657 : :
1658 : 0 : inline iGeom::Error iGeom::getVtxToUV(EntityHandle vertex, EntityHandle face,
1659 : : double& u, double& v) const
1660 : : {
1661 : : int err;
1662 [ # # ]: 0 : iGeom_getVtxToUV(mInstance, vertex, face, &u, &v, &err);
1663 : 0 : return (Error) err;
1664 : : }
1665 : :
1666 : 0 : inline iGeom::Error iGeom::getVtxToU(EntityHandle vertex, EntityHandle edge,
1667 : : double& u) const
1668 : : {
1669 : : int err;
1670 [ # # ]: 0 : iGeom_getVtxToU(mInstance, vertex, edge, &u, &err);
1671 : 0 : return (Error) err;
1672 : : }
1673 : :
1674 : 0 : inline iGeom::Error iGeom::getArrUtoUV(const EntityHandle* edges,
1675 : : int edges_size, const EntityHandle* faces, int faces_size,
1676 : : const double* edge_u, int edge_u_size, StorageOrder order, double* face_uv) const
1677 : : {
1678 [ # # ][ # # ]: 0 : int err, alloc = std::max(edge_u_size, std::max(edges_size, faces_size));
1679 : 0 : int size = 0;
1680 : : iGeom_getArrUtoUV(mInstance, edges, edges_size, faces, faces_size, edge_u,
1681 [ # # ]: 0 : edge_u_size, order, &face_uv, &alloc, &size, &err);
1682 : 0 : return (Error) err;
1683 : : }
1684 : :
1685 : 0 : inline iGeom::Error iGeom::getVtxArrToUV(const EntityHandle* vertices,
1686 : : int vertices_size, const EntityHandle* faces, int faces_size,
1687 : : StorageOrder order, double* face_uv) const
1688 : : {
1689 [ # # ]: 0 : int err, alloc = std::max(vertices_size, faces_size), size = 0;
1690 : : iGeom_getVtxArrToUV(mInstance, vertices, vertices_size, faces, faces_size,
1691 [ # # ]: 0 : order, &face_uv, &alloc, &size, &err);
1692 : 0 : return (Error) err;
1693 : : }
1694 : :
1695 : 0 : inline iGeom::Error iGeom::getVtxArrToU(const EntityHandle* vertices,
1696 : : int vertices_size, const EntityHandle* edges, int edges_size,
1697 : : double* edge_u) const
1698 : : {
1699 [ # # ]: 0 : int err, alloc = std::max(vertices_size, edges_size), size = 0;
1700 : : iGeom_getVtxArrToU(mInstance, vertices, vertices_size, edges, edges_size,
1701 [ # # ]: 0 : &edge_u, &alloc, &size, &err);
1702 : 0 : return (Error) err;
1703 : : }
1704 : :
1705 : 6 : inline iGeom::Error iGeom::deleteAll()
1706 : : {
1707 : : int err;
1708 [ + - ]: 6 : iGeom_deleteAll(mInstance, &err);
1709 : 6 : return (Error) err;
1710 : : }
1711 : :
1712 : 1 : inline iGeom::Error iGeom::copyEnt(EntityHandle source, EntityHandle& copy)
1713 : : {
1714 : : int err;
1715 [ + - ]: 1 : iGeom_copyEnt(mInstance, source, ©, &err);
1716 : 1 : return (Error) err;
1717 : : }
1718 : :
1719 : 0 : inline iGeom::Error iGeom::createSphere(double radius, EntityHandle& sphere)
1720 : : {
1721 : : int err;
1722 [ # # ]: 0 : iGeom_createSphere(mInstance, radius, &sphere, &err);
1723 : 0 : return (Error) err;
1724 : : }
1725 : :
1726 : 0 : inline iGeom::Error iGeom::createPrism(double height, int num_sides,
1727 : : double maj_radius, double min_radius, EntityHandle& prism)
1728 : : {
1729 : : int err;
1730 : : iGeom_createPrism(mInstance, height, num_sides, maj_radius, min_radius,
1731 [ # # ]: 0 : &prism, &err);
1732 : 0 : return (Error) err;
1733 : : }
1734 : :
1735 : 3 : inline iGeom::Error iGeom::createBrick(double x, double y, double z,
1736 : : EntityHandle& brick)
1737 : : {
1738 : : int err;
1739 [ + - ]: 3 : iGeom_createBrick(mInstance, x, y, z, &brick, &err);
1740 : 3 : return (Error) err;
1741 : : }
1742 : :
1743 : 0 : inline iGeom::Error iGeom::createCylinder(double height, double maj_rad,
1744 : : double min_rad, EntityHandle& cylinder)
1745 : : {
1746 : : int err;
1747 [ # # ]: 0 : iGeom_createCylinder(mInstance, height, maj_rad, min_rad, &cylinder, &err);
1748 : 0 : return (Error) err;
1749 : : }
1750 : :
1751 : 0 : inline iGeom::Error iGeom::createCone(double height, double maj_rad,
1752 : : double min_rad, double rad_top, EntityHandle& cone)
1753 : : {
1754 : : int err;
1755 [ # # ]: 0 : iGeom_createCone(mInstance, height, maj_rad, min_rad, rad_top, &cone, &err);
1756 : 0 : return (Error) err;
1757 : : }
1758 : :
1759 : :
1760 : 0 : inline iGeom::Error iGeom::createTorus(double maj_rad, double min_rad,
1761 : : EntityHandle& torus)
1762 : : {
1763 : : int err;
1764 [ # # ]: 0 : iGeom_createTorus(mInstance, maj_rad, min_rad, &torus, &err);
1765 : 0 : return (Error) err;
1766 : : }
1767 : :
1768 : 1 : inline iGeom::Error iGeom::moveEnt(EntityHandle entity, double x, double y,
1769 : : double z)
1770 : : {
1771 : : int err;
1772 [ + - ]: 1 : iGeom_moveEnt(mInstance, entity, x, y, z, &err);
1773 : 1 : return (Error) err;
1774 : : }
1775 : :
1776 : 0 : inline iGeom::Error iGeom::rotateEnt(EntityHandle entity, double angle,
1777 : : double axis_x, double axis_y, double axis_z)
1778 : : {
1779 : : int err;
1780 [ # # ]: 0 : iGeom_rotateEnt(mInstance, entity, angle, axis_x, axis_y, axis_z, &err);
1781 : 0 : return (Error) err;
1782 : : }
1783 : 0 : inline iGeom::Error iGeom::reflectEnt(EntityHandle entity, double x,
1784 : : double y, double z, double norm_x,
1785 : : double norm_y, double norm_z)
1786 : : {
1787 : : int err;
1788 [ # # ]: 0 : iGeom_reflectEnt(mInstance, entity, x, y, z, norm_x, norm_y, norm_z, &err);
1789 : 0 : return (Error) err;
1790 : : }
1791 : :
1792 : 0 : inline iGeom::Error iGeom::scaleEnt(EntityHandle entity, double x,
1793 : : double y, double z, double x_factor,
1794 : : double y_factor, double z_factor)
1795 : : {
1796 : : int err;
1797 [ # # ]: 0 : iGeom_scaleEnt(mInstance, entity, x, y, z, x_factor, y_factor, z_factor, &err);
1798 : 0 : return (Error) err;
1799 : : }
1800 : :
1801 : 0 : inline iGeom::Error iGeom::uniteEnts(const EntityHandle* entities,
1802 : : int entities_size, EntityHandle& result_entity)
1803 : : {
1804 : : int err;
1805 [ # # ]: 0 : iGeom_uniteEnts(mInstance, entities, entities_size, &result_entity, &err);
1806 : 0 : return (Error) err;
1807 : : }
1808 : :
1809 : 0 : inline iGeom::Error iGeom::subtractEnts(EntityHandle blank, EntityHandle tool,
1810 : : EntityHandle& result)
1811 : : {
1812 : : int err;
1813 [ # # ]: 0 : iGeom_subtractEnts(mInstance, blank, tool, &result, &err);
1814 : 0 : return (Error) err;
1815 : : }
1816 : :
1817 : 0 : inline iGeom::Error iGeom::intersectEnts(EntityHandle entity1,
1818 : : EntityHandle entity2, EntityHandle& result)
1819 : : {
1820 : : int err;
1821 [ # # ]: 0 : iGeom_intersectEnts(mInstance, entity1, entity2, &result, &err);
1822 : 0 : return (Error) err;
1823 : : }
1824 : :
1825 : 0 : inline iGeom::Error iGeom::sectionEnt(EntityHandle entity, double plane_x,
1826 : : double plane_y, double plane_z, double offset, bool reverse,
1827 : : EntityHandle& result)
1828 : : {
1829 : : int err;
1830 : : iGeom_sectionEnt(mInstance, entity, plane_x, plane_y, plane_z, offset,
1831 [ # # ]: 0 : reverse, &result, &err);
1832 : 0 : return (Error) err;
1833 : : }
1834 : :
1835 : 0 : inline iGeom::Error iGeom::sweepEntAboutAxis(EntityHandle entity, double angle,
1836 : : double axis_x, double axis_y, double axis_z, EntityHandle& swept_entity)
1837 : : {
1838 : : int err;
1839 : : iGeom_sweepEntAboutAxis(mInstance, entity, angle, axis_x, axis_y, axis_z,
1840 [ # # ]: 0 : &swept_entity, &err);
1841 : 0 : return (Error) err;
1842 : : }
1843 : :
1844 : 1 : inline iGeom::Error iGeom::imprintEnts(const EntityHandle* entities,
1845 : : int entities_size)
1846 : : {
1847 : : int err;
1848 [ + - ]: 1 : iGeom_imprintEnts(mInstance, entities, entities_size, &err);
1849 : 1 : return (Error) err;
1850 : : }
1851 : :
1852 : 1 : inline iGeom::Error iGeom::mergeEnts(const EntityHandle* entities,
1853 : : int entities_size, double tolerance)
1854 : : {
1855 : : int err;
1856 [ + - ]: 1 : iGeom_mergeEnts(mInstance, entities, entities_size, tolerance, &err);
1857 : 1 : return (Error) err;
1858 : : }
1859 : :
1860 : :
1861 : : iGeom::Error
1862 : 0 : iGeom::getErrorType() const
1863 : : {
1864 : : int err;
1865 [ # # ]: 0 : iGeom_getErrorType( mInstance, &err );
1866 : 0 : return (Error)err;
1867 : : }
1868 : :
1869 : : std::string
1870 : 0 : iGeom::getDescription() const
1871 : : {
1872 [ # # ]: 0 : std::vector<char> buffer(1024);
1873 [ # # ][ # # ]: 0 : iGeom_getDescription( mInstance, &buffer[0], buffer.size() );
1874 [ # # ][ # # ]: 0 : return std::string(&buffer[0]);
1875 : : }
1876 : :
1877 : :
1878 : :
1879 : :
1880 : : iGeom::EntitySetHandle
1881 : 246 : iGeom::getRootSet() const
1882 : : {
1883 : : int err;
1884 : : EntitySetHandle result;
1885 [ + - ]: 246 : iGeom_getRootSet( mInstance, &result, &err );
1886 [ + - ]: 246 : return iBase_SUCCESS == err ? result : 0;
1887 : : }
1888 : :
1889 : :
1890 : :
1891 : : iGeom::Error
1892 : 1 : iGeom::createEntSet( bool is_list, EntitySetHandle& handle_out )
1893 : : {
1894 : : int err;
1895 [ + - ]: 1 : iGeom_createEntSet( mInstance, is_list, &handle_out, &err );
1896 : 1 : return (Error)err;
1897 : : }
1898 : :
1899 : : iGeom::Error
1900 : 0 : iGeom::destroyEntSet( EntitySetHandle handle )
1901 : : {
1902 : : int err;
1903 [ # # ]: 0 : iGeom_destroyEntSet( mInstance, handle, &err );
1904 : 0 : return (Error)err;
1905 : : }
1906 : :
1907 : : iGeom::Error
1908 : 0 : iGeom::isList( EntitySetHandle handle, bool& is_list )
1909 : : {
1910 : : int err, result;
1911 [ # # ]: 0 : iGeom_isList( mInstance, handle, &result, &err );
1912 : 0 : is_list = (result != 0);
1913 : 0 : return (Error)err;
1914 : : }
1915 : :
1916 : : iGeom::Error
1917 : 0 : iGeom::getNumEntSets( EntitySetHandle set, int num_hops, int& num_sets_out ) const
1918 : : {
1919 : : int err;
1920 [ # # ]: 0 : iGeom_getNumEntSets( mInstance, set, num_hops, &num_sets_out, &err );
1921 : 0 : return (Error)err;
1922 : : }
1923 : :
1924 : : iGeom::Error
1925 : 49 : iGeom::getEntSets( EntitySetHandle set, int num_hops,
1926 : : std::vector<EntitySetHandle>& contained_sets_out ) const
1927 : : {
1928 : : int err, count;
1929 [ + - ]: 49 : iGeom_getNumEntSets( mInstance, set, num_hops, &count, &err );
1930 [ - + ]: 49 : if (iBase_SUCCESS != err)
1931 : 0 : return (Error)err;
1932 [ + - ]: 49 : contained_sets_out.resize(count);
1933 : 49 : int alloc = contained_sets_out.size(), size;
1934 [ + - ]: 49 : EntitySetHandle* ptr = &contained_sets_out[0];
1935 [ + - ]: 49 : iGeom_getEntSets( mInstance, set, num_hops, &ptr, &alloc, &size, &err );
1936 : 49 : return (Error)err;
1937 : : }
1938 : :
1939 : : iGeom::Error
1940 : 1 : iGeom::addEntToSet( EntityHandle entity, EntitySetHandle set )
1941 : : {
1942 : : int err;
1943 [ + - ]: 1 : iGeom_addEntToSet( mInstance, entity,set, &err );
1944 : 1 : return (Error)err;
1945 : : }
1946 : :
1947 : : iGeom::Error
1948 : 0 : iGeom::rmvEntFromSet( EntityHandle entity, EntitySetHandle set )
1949 : : {
1950 : : int err;
1951 [ # # ]: 0 : iGeom_rmvEntFromSet( mInstance, entity,set, &err );
1952 : 0 : return (Error)err;
1953 : : }
1954 : :
1955 : : iGeom::Error
1956 : 0 : iGeom::addEntArrToSet( const EntityHandle* entity_handles,
1957 : : int entity_handles_size,
1958 : : EntitySetHandle entity_set )
1959 : : {
1960 : : int err;
1961 [ # # ]: 0 : iGeom_addEntArrToSet( mInstance, entity_handles, entity_handles_size, entity_set, &err );
1962 : 0 : return (Error)err;
1963 : : }
1964 : :
1965 : : iGeom::Error
1966 : 0 : iGeom::rmvEntArrFromSet( const EntityHandle* entity_handles,
1967 : : int entity_handles_size,
1968 : : EntitySetHandle entity_set )
1969 : : {
1970 : : int err;
1971 [ # # ]: 0 : iGeom_rmvEntArrFromSet( mInstance, entity_handles, entity_handles_size, entity_set, &err );
1972 : 0 : return (Error)err;
1973 : : }
1974 : :
1975 : : iGeom::Error
1976 : 0 : iGeom::addEntSet( EntitySetHandle to_add, EntitySetHandle add_to )
1977 : : {
1978 : : int err;
1979 [ # # ]: 0 : iGeom_addEntSet( mInstance, to_add, add_to, &err );
1980 : 0 : return (Error)err;
1981 : : }
1982 : :
1983 : : iGeom::Error
1984 : 0 : iGeom::rmvEntSet( EntitySetHandle to_rmv, EntitySetHandle rmv_from )
1985 : : {
1986 : : int err;
1987 [ # # ]: 0 : iGeom_rmvEntSet( mInstance, to_rmv, rmv_from, &err );
1988 : 0 : return (Error)err;
1989 : : }
1990 : :
1991 : : iGeom::Error
1992 : 0 : iGeom::isEntContained( EntitySetHandle set, EntityHandle ent, bool& contained_out ) const
1993 : : {
1994 : : int err, result;
1995 [ # # ]: 0 : iGeom_isEntContained( mInstance, set, ent, &result, &err );
1996 : 0 : contained_out = (result != 0);
1997 : 0 : return (Error)err;
1998 : : }
1999 : :
2000 : : iGeom::Error
2001 : 0 : iGeom::isEntArrContained( EntitySetHandle containing_set,
2002 : : const EntityHandle* entity_handles,
2003 : : int num_entity_handles,
2004 : : bool* is_contained_out ) const
2005 : : {
2006 : 0 : int err, *ptr = 0, alloc = 0, size = 0;
2007 : : iGeom_isEntArrContained( mInstance, containing_set,
2008 : : entity_handles, num_entity_handles,
2009 [ # # ]: 0 : &ptr, &alloc, &size, &err );
2010 [ # # ]: 0 : if (iBase_SUCCESS != err)
2011 : 0 : return (Error)err;
2012 [ # # ]: 0 : for (int i = 0; i < num_entity_handles; ++i)
2013 : 0 : is_contained_out[i] = (ptr[i] != 0);
2014 : 0 : free(ptr);
2015 : 0 : return iBase_SUCCESS;
2016 : : }
2017 : :
2018 : : iGeom::Error
2019 : 0 : iGeom::isEntSetContained( EntitySetHandle containing_set,
2020 : : EntitySetHandle contained_set,
2021 : : bool& contained_out ) const
2022 : : {
2023 : : int err, result;
2024 [ # # ]: 0 : iGeom_isEntSetContained( mInstance, containing_set, contained_set, &result, &err );
2025 : 0 : contained_out = (result != 0);
2026 : 0 : return (Error)err;
2027 : : }
2028 : :
2029 : : iGeom::Error
2030 : 0 : iGeom::addPrntChld( EntitySetHandle parent, EntitySetHandle child )
2031 : : {
2032 : : int err;
2033 [ # # ]: 0 : iGeom_addPrntChld( mInstance, parent, child, &err );
2034 : 0 : return (Error)err;
2035 : : }
2036 : :
2037 : : iGeom::Error
2038 : 0 : iGeom::rmvPrntChld( EntitySetHandle parent, EntitySetHandle child )
2039 : : {
2040 : : int err;
2041 [ # # ]: 0 : iGeom_rmvPrntChld( mInstance, parent, child, &err );
2042 : 0 : return (Error)err;
2043 : : }
2044 : :
2045 : : iGeom::Error
2046 : 0 : iGeom::isChildOf( EntitySetHandle parent, EntitySetHandle child, bool& is_child_out ) const
2047 : : {
2048 : : int err, result;
2049 [ # # ]: 0 : iGeom_isChildOf( mInstance, parent, child, &result, &err );
2050 : 0 : is_child_out = (result != 0);
2051 : 0 : return (Error)err;
2052 : : }
2053 : :
2054 : : iGeom::Error
2055 : 0 : iGeom::getNumChld( EntitySetHandle parent, int num_hops, int& num_child_out ) const
2056 : : {
2057 : : int err;
2058 [ # # ]: 0 : iGeom_getNumChld( mInstance, parent, num_hops, &num_child_out, &err );
2059 : 0 : return (Error)err;
2060 : : }
2061 : :
2062 : : iGeom::Error
2063 : 0 : iGeom::getNumPrnt( EntitySetHandle child, int num_hops, int& num_parent_out ) const
2064 : : {
2065 : : int err;
2066 [ # # ]: 0 : iGeom_getNumPrnt( mInstance, child, num_hops, &num_parent_out, &err );
2067 : 0 : return (Error)err;
2068 : : }
2069 : :
2070 : : iGeom::Error
2071 : 0 : iGeom::getChldn( EntitySetHandle parent, int num_hops,
2072 : : std::vector<EntitySetHandle>& children_out ) const
2073 : : {
2074 : : int err, count;
2075 [ # # ]: 0 : iGeom_getNumChld( mInstance, parent, num_hops, &count, &err );
2076 [ # # ]: 0 : if (iBase_SUCCESS != err)
2077 : 0 : return (Error)err;
2078 [ # # ]: 0 : children_out.resize(count);
2079 : 0 : int alloc = children_out.size(), size;
2080 [ # # ]: 0 : EntitySetHandle* ptr = &children_out[0];
2081 [ # # ]: 0 : iGeom_getEntSets( mInstance, parent, num_hops, &ptr, &alloc, &size, &err );
2082 : 0 : return (Error)err;
2083 : : }
2084 : :
2085 : : iGeom::Error
2086 : 0 : iGeom::getPrnts( EntitySetHandle child, int num_hops,
2087 : : std::vector<EntitySetHandle>& parents_out ) const
2088 : : {
2089 : : int err, count;
2090 [ # # ]: 0 : iGeom_getNumPrnt( mInstance, child, num_hops, &count, &err );
2091 [ # # ]: 0 : if (iBase_SUCCESS != err)
2092 : 0 : return (Error)err;
2093 [ # # ]: 0 : parents_out.resize(count);
2094 : 0 : int alloc = parents_out.size(), size;
2095 [ # # ]: 0 : EntitySetHandle* ptr = &parents_out[0];
2096 [ # # ]: 0 : iGeom_getEntSets( mInstance, child, num_hops, &ptr, &alloc, &size, &err );
2097 : 0 : return (Error)err;
2098 : : }
2099 : :
2100 : :
2101 : : iGeom::Error
2102 : 0 : iGeom::subtract( EntitySetHandle set1, EntitySetHandle set2,
2103 : : EntitySetHandle& result_set_out )
2104 : : {
2105 : : int err;
2106 [ # # ]: 0 : iGeom_subtract( mInstance, set1, set1, &result_set_out, &err );
2107 : 0 : return (Error)err;
2108 : : }
2109 : :
2110 : : iGeom::Error
2111 : 0 : iGeom::intersect( EntitySetHandle set1, EntitySetHandle set2,
2112 : : EntitySetHandle& result_set_out )
2113 : : {
2114 : : int err;
2115 [ # # ]: 0 : iGeom_intersect( mInstance, set1, set1, &result_set_out, &err );
2116 : 0 : return (Error)err;
2117 : : }
2118 : :
2119 : : iGeom::Error
2120 : 0 : iGeom::unite( EntitySetHandle set1, EntitySetHandle set2,
2121 : : EntitySetHandle& result_set_out )
2122 : : {
2123 : : int err;
2124 [ # # ]: 0 : iGeom_unite( mInstance, set1, set1, &result_set_out, &err );
2125 : 0 : return (Error)err;
2126 : : }
2127 : :
2128 : :
2129 : : iGeom::Error
2130 : 39 : iGeom::createTag( const char* tag_name,
2131 : : int tag_num_type_values,
2132 : : TagValueType tag_type,
2133 : : TagHandle& tag_handle_out )
2134 : : {
2135 : : int err;
2136 : : iGeom_createTag( mInstance, tag_name, tag_num_type_values, tag_type,
2137 [ + - ]: 39 : &tag_handle_out, &err, strlen(tag_name) );
2138 : 39 : return (Error)err;
2139 : : }
2140 : :
2141 : :
2142 : : iGeom::Error
2143 : 0 : iGeom::destroyTag( TagHandle tag_handle, bool forced )
2144 : : {
2145 : : int err;
2146 [ # # ]: 0 : iGeom_destroyTag( mInstance, tag_handle, forced, &err );
2147 : 0 : return (Error)err;
2148 : : }
2149 : :
2150 : : iGeom::Error
2151 : 0 : iGeom::getTagName( TagHandle tag_handle, std::string& name_out ) const
2152 : : {
2153 : : int err;
2154 : : char buffer[1024];
2155 : 0 : memset( buffer, 0, sizeof(buffer) );
2156 [ # # ]: 0 : iGeom_getTagName( mInstance, tag_handle, buffer, &err, sizeof(buffer) );
2157 [ # # ]: 0 : name_out = buffer;
2158 : 0 : return (Error)err;
2159 : : }
2160 : :
2161 : : iGeom::Error
2162 : 0 : iGeom::getTagSizeValues( TagHandle tag_handle, int& size_out ) const
2163 : : {
2164 : : int err;
2165 [ # # ]: 0 : iGeom_getTagSizeValues( mInstance, tag_handle, &size_out, &err );
2166 : 0 : return (Error)err;
2167 : : }
2168 : :
2169 : : iGeom::Error
2170 : 1 : iGeom::getTagSizeBytes( TagHandle tag_handle, int& size_out ) const
2171 : : {
2172 : : int err;
2173 [ + - ]: 1 : iGeom_getTagSizeBytes( mInstance, tag_handle, &size_out, &err );
2174 : 1 : return (Error)err;
2175 : : }
2176 : :
2177 : : iGeom::Error
2178 : 4653 : iGeom::getTagHandle( const char* name, TagHandle& handle_out ) const
2179 : : {
2180 : : int err;
2181 [ + - ]: 4653 : iGeom_getTagHandle( mInstance, name, &handle_out, &err, strlen(name) );
2182 : 4653 : return (Error)err;
2183 : : }
2184 : :
2185 : : iGeom::Error
2186 : 0 : iGeom::getTagType( TagHandle tag_handle, TagValueType& type_out ) const
2187 : : {
2188 : : int err, result;
2189 [ # # ]: 0 : iGeom_getTagType( mInstance, tag_handle, &result, &err );
2190 : 0 : type_out = (TagValueType)result;
2191 : 0 : return (Error)err;
2192 : : }
2193 : :
2194 : :
2195 : : iGeom::Error
2196 : 1 : iGeom::setEntSetData( EntitySetHandle set_handle,
2197 : : TagHandle tag_handle,
2198 : : const void* tag_value )
2199 : : {
2200 : 1 : int err, size = 1;
2201 [ + - ]: 1 : iGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
2202 : : iGeom_setEntSetData( mInstance, set_handle, tag_handle,
2203 [ + - ]: 1 : tag_value, size, &err);
2204 : 1 : return (Error)err;
2205 : : }
2206 : :
2207 : : iGeom::Error
2208 : 0 : iGeom::setEntSetIntData( EntitySetHandle set_handle,
2209 : : TagHandle tag_handle,
2210 : : int value )
2211 : : {
2212 : : int err;
2213 [ # # ]: 0 : iGeom_setEntSetIntData( mInstance, set_handle, tag_handle, value, &err );
2214 : 0 : return (Error)err;
2215 : : }
2216 : :
2217 : : iGeom::Error
2218 : 0 : iGeom::setEntSetDblData( EntitySetHandle set_handle,
2219 : : TagHandle tag_handle,
2220 : : double value )
2221 : : {
2222 : : int err;
2223 [ # # ]: 0 : iGeom_setEntSetDblData( mInstance, set_handle, tag_handle, value, &err );
2224 : 0 : return (Error)err;
2225 : : }
2226 : :
2227 : : iGeom::Error
2228 : 0 : iGeom::setEntSetEHData( EntitySetHandle set_handle,
2229 : : TagHandle tag_handle,
2230 : : EntityHandle value )
2231 : :
2232 : : {
2233 : : int err;
2234 [ # # ]: 0 : iGeom_setEntSetEHData( mInstance, set_handle, tag_handle, value, &err );
2235 : 0 : return (Error)err;
2236 : : }
2237 : :
2238 : : iGeom::Error
2239 : 0 : iGeom::setEntSetESHData( EntitySetHandle set_handle,
2240 : : TagHandle tag_handle,
2241 : : EntitySetHandle value )
2242 : :
2243 : : {
2244 : : int err;
2245 [ # # ]: 0 : iGeom_setEntSetESHData( mInstance, set_handle, tag_handle, value, &err );
2246 : 0 : return (Error)err;
2247 : : }
2248 : :
2249 : : iGeom::Error
2250 : 0 : iGeom::getEntSetData( EntitySetHandle set_handle,
2251 : : TagHandle tag_handle,
2252 : : void* tag_value_out ) const
2253 : : {
2254 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
2255 : : iGeom_getEntSetData( mInstance, set_handle, tag_handle,
2256 [ # # ]: 0 : &tag_value_out, &alloc, &size, &err);
2257 : 0 : return (Error)err;
2258 : : }
2259 : :
2260 : : iGeom::Error
2261 : 0 : iGeom::getEntSetIntData( EntitySetHandle set_handle,
2262 : : TagHandle tag_handle,
2263 : : int& value_out ) const
2264 : : {
2265 : : int err;
2266 [ # # ]: 0 : iGeom_getEntSetIntData( mInstance, set_handle, tag_handle, &value_out, &err );
2267 : 0 : return (Error)err;
2268 : : }
2269 : :
2270 : : iGeom::Error
2271 : 0 : iGeom::getEntSetDblData( EntitySetHandle set_handle,
2272 : : TagHandle tag_handle,
2273 : : double& value_out ) const
2274 : : {
2275 : : int err;
2276 [ # # ]: 0 : iGeom_getEntSetDblData( mInstance, set_handle, tag_handle, &value_out, &err );
2277 : 0 : return (Error)err;
2278 : : }
2279 : :
2280 : : iGeom::Error
2281 : 0 : iGeom::getEntSetEHData( EntitySetHandle set_handle,
2282 : : TagHandle tag_handle,
2283 : : EntityHandle& value_out ) const
2284 : :
2285 : : {
2286 : : int err;
2287 [ # # ]: 0 : iGeom_getEntSetEHData( mInstance, set_handle, tag_handle, &value_out, &err );
2288 : 0 : return (Error)err;
2289 : : }
2290 : :
2291 : : iGeom::Error
2292 : 0 : iGeom::getEntSetESHData( EntitySetHandle set_handle,
2293 : : TagHandle tag_handle,
2294 : : EntitySetHandle& value_out ) const
2295 : :
2296 : : {
2297 : : int err;
2298 [ # # ]: 0 : iGeom_getEntSetESHData( mInstance, set_handle, tag_handle, &value_out, &err );
2299 : 0 : return (Error)err;
2300 : : }
2301 : :
2302 : : iGeom::Error
2303 : 0 : iGeom::getAllEntSetTags( EntitySetHandle set,
2304 : : std::vector<TagHandle>& tags_out ) const
2305 : : {
2306 [ # # ]: 0 : if (tags_out.capacity() == 0)
2307 [ # # ]: 0 : tags_out.resize( 32 );
2308 : : else
2309 [ # # ]: 0 : tags_out.resize( tags_out.capacity() );
2310 : :
2311 : 0 : int err, alloc = tags_out.size(), size = 0;
2312 [ # # ]: 0 : TagHandle* ptr = &tags_out[0];
2313 [ # # ]: 0 : iGeom_getAllEntSetTags( mInstance, set, &ptr, &alloc, &size, &err );
2314 [ # # ]: 0 : tags_out.resize(size);
2315 : :
2316 [ # # ][ # # ]: 0 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
2317 : 0 : alloc = tags_out.size();
2318 [ # # ]: 0 : ptr = &tags_out[0];
2319 [ # # ]: 0 : iGeom_getAllEntSetTags( mInstance, set, &ptr, &alloc, &size, &err );
2320 : : }
2321 : :
2322 : 0 : return (Error)err;
2323 : : }
2324 : :
2325 : : iGeom::Error
2326 : 0 : iGeom::getAllTags( EntityHandle entity,
2327 : : std::vector<TagHandle>& tags_out ) const
2328 : :
2329 : : {
2330 [ # # ]: 0 : if (tags_out.capacity() == 0)
2331 [ # # ]: 0 : tags_out.resize( 32 );
2332 : : else
2333 [ # # ]: 0 : tags_out.resize( tags_out.capacity() );
2334 : :
2335 : 0 : int err, alloc = tags_out.size(), size = 0;
2336 [ # # ]: 0 : TagHandle* ptr = &tags_out[0];
2337 [ # # ]: 0 : iGeom_getAllTags( mInstance, entity, &ptr, &alloc, &size, &err );
2338 [ # # ]: 0 : tags_out.resize(size);
2339 : :
2340 [ # # ][ # # ]: 0 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
2341 : 0 : alloc = tags_out.size();
2342 [ # # ]: 0 : ptr = &tags_out[0];
2343 [ # # ]: 0 : iGeom_getAllTags( mInstance, entity, &ptr, &alloc, &size, &err );
2344 : : }
2345 : :
2346 : 0 : return (Error)err;
2347 : : }
2348 : :
2349 : : iGeom::Error
2350 : 0 : iGeom::rmvEntSetTag( EntitySetHandle set, TagHandle tag )
2351 : : {
2352 : : int err;
2353 [ # # ]: 0 : iGeom_rmvEntSetTag( mInstance, set, tag, &err );
2354 : 0 : return (Error)err;
2355 : : }
2356 : :
2357 : : iGeom::Error
2358 : 0 : iGeom::rmvTag( EntityHandle entity, TagHandle tag )
2359 : : {
2360 : : int err;
2361 [ # # ]: 0 : iGeom_rmvTag( mInstance, entity, tag, &err );
2362 : 0 : return (Error)err;
2363 : : }
2364 : :
2365 : : iGeom::Error
2366 : 0 : iGeom::rmvArrTag( const EntityHandle* handles, int size, TagHandle tag )
2367 : : {
2368 : : int err;
2369 [ # # ]: 0 : iGeom_rmvArrTag( mInstance, handles, size, tag, &err );
2370 : 0 : return (Error)err;
2371 : : }
2372 : :
2373 : :
2374 : : iGeom::Error
2375 : 3721 : iGeom::getArrData( const EntityHandle* entity_handles,
2376 : : int entity_handles_size,
2377 : : TagHandle tag_handle,
2378 : : void* tag_values_out ) const
2379 : : {
2380 : 3721 : int err, alloc = std::numeric_limits<int>::max(), size;
2381 : : iGeom_getArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2382 [ + - ]: 3721 : &tag_values_out, &alloc, &size, &err);
2383 : 3721 : return (Error)err;
2384 : : }
2385 : :
2386 : : iGeom::Error
2387 : 0 : iGeom::getIntArrData( const EntityHandle* entity_handles,
2388 : : int entity_handles_size,
2389 : : TagHandle tag_handle,
2390 : : int* tag_values_out ) const
2391 : : {
2392 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
2393 : : iGeom_getIntArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2394 [ # # ]: 0 : &tag_values_out, &alloc, &size, &err);
2395 : 0 : return (Error)err;
2396 : : }
2397 : :
2398 : 46 : iGeom::Error iGeom::getFacets(EntityHandle entity_handle, double dist_tolerance,
2399 : : std::vector<double> &points, std::vector<int> &facets) const
2400 : : {
2401 : : // try getting results using whatever space input vector has allocated
2402 : 46 : bool already_allocd = false;
2403 : 46 : int err, points_size = 0, points_alloc = points.capacity(),
2404 : 46 : facets_size = 0, facets_alloc = facets.capacity();
2405 [ - + ][ # # ]: 46 : if (points_alloc && !facets_alloc) points_alloc = 0;
2406 [ + - ][ - + ]: 46 : else if (!points_alloc && facets_alloc) facets_alloc = 0;
2407 [ - + ][ # # ]: 46 : if (points_alloc && facets_alloc) already_allocd = true;
2408 [ - + ][ # # ]: 46 : double *points_ptr = (points_alloc ? &points[0] : NULL);
2409 [ - + ][ # # ]: 46 : int *facets_ptr = (facets_alloc ? &facets[0] : NULL);
2410 : : iGeom_getFacets(mInstance, entity_handle, dist_tolerance,
2411 : : &points_ptr, &points_alloc, &points_size,
2412 [ + - ]: 46 : &facets_ptr, &facets_alloc, &facets_size, &err);
2413 : :
2414 [ + - ][ - + ]: 46 : if (iBase_SUCCESS == err && already_allocd) {
2415 [ # # ]: 0 : points.resize(points_size);
2416 [ # # ]: 0 : facets.resize(facets_size);
2417 : 0 : return (Error)err;
2418 : : }
2419 [ + - ][ - + ]: 46 : else if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
2420 : : // if input vector was too small, try again requesting allocation
2421 : 0 : points_alloc = 0; points_ptr = NULL;
2422 : 0 : facets_alloc = 0; facets_ptr = NULL;
2423 : : iGeom_getFacets(mInstance, entity_handle, dist_tolerance,
2424 : : &points_ptr, &points_alloc, &points_size,
2425 [ # # ]: 0 : &facets_ptr, &facets_alloc, &facets_size, &err);
2426 : : }
2427 : :
2428 [ + - ]: 46 : if (iBase_SUCCESS == err) {
2429 [ + - ]: 46 : points.resize(points_size);
2430 [ + - ]: 46 : std::copy(points_ptr, points_ptr+points_size, points.begin());
2431 [ + - ]: 46 : facets.resize(facets_size);
2432 [ + - ]: 46 : std::copy(facets_ptr, facets_ptr+facets_size, facets.begin());
2433 : 46 : free(points_ptr); free(facets_ptr);
2434 : : }
2435 : :
2436 : 46 : return (Error)err;
2437 : : }
2438 : :
2439 : : iGeom::Error
2440 : 0 : iGeom::getDblArrData( const EntityHandle* entity_handles,
2441 : : int entity_handles_size,
2442 : : TagHandle tag_handle,
2443 : : double* tag_values_out ) const
2444 : : {
2445 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
2446 : : iGeom_getDblArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2447 [ # # ]: 0 : &tag_values_out, &alloc, &size, &err);
2448 : 0 : return (Error)err;
2449 : : }
2450 : :
2451 : : iGeom::Error
2452 : 0 : iGeom::getEHArrData( const EntityHandle* entity_handles,
2453 : : int entity_handles_size,
2454 : : TagHandle tag_handle,
2455 : : EntityHandle* tag_values_out ) const
2456 : :
2457 : : {
2458 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
2459 : : iGeom_getEHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2460 [ # # ]: 0 : &tag_values_out, &alloc, &size, &err);
2461 : 0 : return (Error)err;
2462 : : }
2463 : :
2464 : : iGeom::Error
2465 : 0 : iGeom::getESHArrData( const EntityHandle* entity_handles,
2466 : : int entity_handles_size,
2467 : : TagHandle tag_handle,
2468 : : EntitySetHandle* tag_values_out ) const
2469 : :
2470 : : {
2471 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
2472 : : iGeom_getESHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2473 [ # # ]: 0 : &tag_values_out, &alloc, &size, &err);
2474 : 0 : return (Error)err;
2475 : : }
2476 : :
2477 : : iGeom::Error
2478 : 0 : iGeom::setArrData( const EntityHandle* entity_handles,
2479 : : int entity_handles_size,
2480 : : TagHandle tag_handle,
2481 : : const void* tag_values )
2482 : : {
2483 : 0 : int err, size = 1;
2484 [ # # ]: 0 : iGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
2485 : : iGeom_setArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2486 : : tag_values, size*entity_handles_size,
2487 [ # # ]: 0 : &err );
2488 : 0 : return (Error)err;
2489 : : }
2490 : :
2491 : : iGeom::Error
2492 : 0 : iGeom::setIntArrData( const EntityHandle* entity_handles,
2493 : : int entity_handles_size,
2494 : : TagHandle tag_handle,
2495 : : const int* tag_values )
2496 : : {
2497 : 0 : int err, size = 1;
2498 [ # # ]: 0 : iGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
2499 : : iGeom_setIntArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2500 [ # # ]: 0 : tag_values, size*entity_handles_size, &err );
2501 : 0 : return (Error)err;
2502 : : }
2503 : :
2504 : : iGeom::Error
2505 : 0 : iGeom::setDblArrData( const EntityHandle* entity_handles,
2506 : : int entity_handles_size,
2507 : : TagHandle tag_handle,
2508 : : const double* tag_values )
2509 : : {
2510 : 0 : int err, size = 1;
2511 [ # # ]: 0 : iGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
2512 : : iGeom_setDblArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2513 [ # # ]: 0 : tag_values, size*entity_handles_size, &err );
2514 : 0 : return (Error)err;
2515 : : }
2516 : :
2517 : : iGeom::Error
2518 : 0 : iGeom::setEHArrData( const EntityHandle* entity_handles,
2519 : : int entity_handles_size,
2520 : : TagHandle tag_handle,
2521 : : const EntityHandle* tag_values )
2522 : : {
2523 : 0 : int err, size = 1;
2524 [ # # ]: 0 : iGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
2525 : : iGeom_setEHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2526 [ # # ]: 0 : tag_values, size*entity_handles_size, &err );
2527 : 0 : return (Error)err;
2528 : : }
2529 : :
2530 : : iGeom::Error
2531 : 0 : iGeom::setESHArrData( const EntityHandle* entity_handles,
2532 : : int entity_handles_size,
2533 : : TagHandle tag_handle,
2534 : : const EntitySetHandle* tag_values )
2535 : : {
2536 : 0 : int err, size = 1;
2537 [ # # ]: 0 : iGeom_getTagSizeValues( mInstance, tag_handle, &size, &err );
2538 : : iGeom_setESHArrData( mInstance, entity_handles, entity_handles_size, tag_handle,
2539 [ # # ]: 0 : tag_values, size*entity_handles_size, &err );
2540 : 0 : return (Error)err;
2541 : : }
2542 : :
2543 : :
2544 : :
2545 : : iGeom::Error
2546 : 1070 : iGeom::setData( EntityHandle entity_handle,
2547 : : TagHandle tag_handle,
2548 : : const void* tag_value )
2549 : : {
2550 : 1070 : int err, size = 1;
2551 [ + - ]: 1070 : iGeom_getTagSizeBytes( mInstance, tag_handle, &size, &err );
2552 : : iGeom_setData( mInstance, entity_handle, tag_handle,
2553 [ + - ]: 1070 : tag_value, size, &err);
2554 : 1070 : return (Error)err;
2555 : : }
2556 : :
2557 : : iGeom::Error
2558 : 0 : iGeom::setIntData( EntityHandle entity_handle,
2559 : : TagHandle tag_handle,
2560 : : int value )
2561 : : {
2562 : : int err;
2563 [ # # ]: 0 : iGeom_setIntData( mInstance, entity_handle, tag_handle, value, &err );
2564 : 0 : return (Error)err;
2565 : : }
2566 : :
2567 : : iGeom::Error
2568 : 0 : iGeom::setDblData( EntityHandle entity_handle,
2569 : : TagHandle tag_handle,
2570 : : double value )
2571 : : {
2572 : : int err;
2573 [ # # ]: 0 : iGeom_setDblData( mInstance, entity_handle, tag_handle, value, &err );
2574 : 0 : return (Error)err;
2575 : : }
2576 : :
2577 : : iGeom::Error
2578 : 0 : iGeom::setEHData( EntityHandle entity_handle,
2579 : : TagHandle tag_handle,
2580 : : EntityHandle value )
2581 : :
2582 : : {
2583 : : int err;
2584 [ # # ]: 0 : iGeom_setEHData( mInstance, entity_handle, tag_handle, value, &err );
2585 : 0 : return (Error)err;
2586 : : }
2587 : :
2588 : : iGeom::Error
2589 : 0 : iGeom::setESHData( EntityHandle entity_handle,
2590 : : TagHandle tag_handle,
2591 : : EntitySetHandle value )
2592 : :
2593 : : {
2594 : : int err;
2595 [ # # ]: 0 : iGeom_setESHData( mInstance, entity_handle, tag_handle, value, &err );
2596 : 0 : return (Error)err;
2597 : : }
2598 : :
2599 : : iGeom::Error
2600 : 1752 : iGeom::getData( EntityHandle entity_handle,
2601 : : TagHandle tag_handle,
2602 : : void* tag_value_out ) const
2603 : : {
2604 : 1752 : int err, alloc = std::numeric_limits<int>::max(), size;
2605 : : iGeom_getData( mInstance, entity_handle, tag_handle,
2606 [ + - ]: 1752 : &tag_value_out, &alloc, &size, &err);
2607 : 1752 : return (Error)err;
2608 : : }
2609 : :
2610 : : iGeom::Error
2611 : 1035 : iGeom::getIntData( EntityHandle entity_handle,
2612 : : TagHandle tag_handle,
2613 : : int& value_out ) const
2614 : : {
2615 : : int err;
2616 [ + - ]: 1035 : iGeom_getIntData( mInstance, entity_handle, tag_handle, &value_out, &err );
2617 : 1035 : return (Error)err;
2618 : : }
2619 : :
2620 : : iGeom::Error
2621 : 0 : iGeom::getDblData( EntityHandle entity_handle,
2622 : : TagHandle tag_handle,
2623 : : double& value_out ) const
2624 : : {
2625 : : int err;
2626 [ # # ]: 0 : iGeom_getDblData( mInstance, entity_handle, tag_handle, &value_out, &err );
2627 : 0 : return (Error)err;
2628 : : }
2629 : :
2630 : : iGeom::Error
2631 : 0 : iGeom::getEHData( EntityHandle entity_handle,
2632 : : TagHandle tag_handle,
2633 : : EntityHandle& value_out ) const
2634 : : {
2635 : : int err;
2636 [ # # ]: 0 : iGeom_getEHData( mInstance, entity_handle, tag_handle, &value_out, &err );
2637 : 0 : return (Error)err;
2638 : : }
2639 : :
2640 : : iGeom::Error
2641 : 0 : iGeom::getESHData( EntityHandle entity_handle,
2642 : : TagHandle tag_handle,
2643 : : EntitySetHandle& value_out ) const
2644 : : {
2645 : : int err;
2646 [ # # ]: 0 : iGeom_getESHData( mInstance, entity_handle, tag_handle, &value_out, &err );
2647 : 0 : return (Error)err;
2648 : : }
2649 : :
2650 : : #endif
|
