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