1 #include <iostream>
2 #include <map>
3 #include "FBiGeom_MOAB.hpp"
4 #include "moab/GeomTopoTool.hpp"
5 #include "moab/OrientedBoxTreeTool.hpp"
6 #include "moab/CartVect.hpp"
7 #include "moab/FileOptions.hpp"
8 #include "MBTagConventions.hpp"
9 #include <stdlib.h>
10 #include <cstring>
11 #include <map>
12 #include "assert.h"
13
14 using namespace moab;
15
compare_no_case1(const char * str1,const char * str2,size_t n)16 static int compare_no_case1(const char *str1, const char *str2, size_t n) {
17 for (size_t i = 1; i != n && *str1 && toupper(*str1) == toupper(*str2);
18 ++i, ++str1, ++str2);
19 return toupper(*str2) - toupper(*str1);
20 }
21 // Filter out non-MOAB options and remove the "moab:" prefix
filter_options1(const char * begin,const char * end)22 static std::string filter_options1(const char *begin, const char *end)
23 {
24 const char *opt_begin = begin;
25 const char *opt_end = begin;
26
27 std::string filtered;
28 bool first = true;
29
30 while (opt_end != end) {
31 opt_end = std::find(opt_begin, end, ' ');
32
33 if (opt_end-opt_begin >= 5 && compare_no_case1(opt_begin, "moab:", 5) == 0) {
34 if (!first)
35 filtered.push_back(';');
36 first = false;
37 filtered.append(opt_begin+5, opt_end);
38 }
39
40 opt_begin = opt_end+1;
41 }
42 return filtered;
43 }
44
45 bool debug_igeom = false;
46 bool Debug_surf_eval = false;
47
48 #define COPY_RANGE(r, vec) { \
49 EntityHandle *tmp_ptr = reinterpret_cast<EntityHandle*>(vec); \
50 std::copy(r.begin(), r.end(), tmp_ptr);}
51
52 #define TAG_HANDLE(tagh) reinterpret_cast<Tag>(tagh)
53
54 #define COPY_DOUBLEVEC(r, vec) { \
55 double *tmp_ptr = reinterpret_cast<double*>(vec); \
56 std::copy(r.begin(), r.end(), tmp_ptr);}
57
FBiGeom_getDescription(FBiGeom_Instance instance,char * descr,int descr_len)58 void FBiGeom_getDescription(FBiGeom_Instance instance, char* descr, int descr_len) {
59 iMesh_getDescription( IMESH_INSTANCE(instance), descr, descr_len);
60 }
61
FBiGeom_getErrorType(FBiGeom_Instance instance,int * error_type)62 void FBiGeom_getErrorType(FBiGeom_Instance instance, /*out*/int *error_type) {
63 iMesh_getErrorType( IMESH_INSTANCE(instance), /*out*/error_type) ;
64 }
65
FBiGeom_newGeom(char const * options,FBiGeom_Instance * instance_out,int * err,int options_len)66 void FBiGeom_newGeom(char const* options, FBiGeom_Instance* instance_out, int* err,
67 int options_len) {
68
69 std::string tmp_options = filter_options1(options, options+options_len);
70 FileOptions opts(tmp_options.c_str());
71 // process some options?
72
73 MBiGeom **mbigeom = reinterpret_cast<MBiGeom**> (instance_out);
74 *mbigeom = NULL;
75 *mbigeom = new MBiGeom();
76 *err = iBase_SUCCESS;
77 }
78
FBiGeom_dtor(FBiGeom_Instance instance,int * err)79 void FBiGeom_dtor(FBiGeom_Instance instance, int* err) {
80 MBiGeom **mbigeom = reinterpret_cast<MBiGeom**> (&instance);
81 if (*mbigeom)
82 delete *mbigeom;
83 *err = iBase_SUCCESS;
84 }
85
FBiGeom_newGeomFromMesh(iMesh_Instance mesh,iBase_EntitySetHandle set,const char * options,FBiGeom_Instance * geom,int * err,int)86 void FBiGeom_newGeomFromMesh(iMesh_Instance mesh, iBase_EntitySetHandle set,
87 const char *options, FBiGeom_Instance *geom,
88 int *err, int )
89 {
90 MBiMesh * mbimesh = reinterpret_cast<MBiMesh *>(mesh);
91 moab::Interface * mbi = mbimesh->mbImpl;
92 moab::EntityHandle rootSet = reinterpret_cast<moab::EntityHandle> (set);
93 moab::GeomTopoTool * gtt = new moab::GeomTopoTool(mbi, true, rootSet);
94 bool smooth = false; // decide from options
95 char smth[] = "SMOOTH;";
96 const char * res = strstr(options, smth);
97 if (res!=NULL)
98 smooth = true;
99 moab::FBEngine * fbe = new moab::FBEngine(mbi, gtt, smooth);
100 MBiGeom **mbigeom = reinterpret_cast<MBiGeom**> (geom);
101 *mbigeom = NULL;
102 *mbigeom = new MBiGeom(mbimesh, fbe);
103 // will do now the initialization of the engine;
104 // heavy duty computation
105 fbe->Init();
106 *err = iBase_SUCCESS;
107 }
108 // corresponding to constructor 2, from iMesh instance
FBiGeom_dtor2(FBiGeom_Instance instance,int * err)109 void FBiGeom_dtor2(FBiGeom_Instance instance, int* err) {
110 moab::FBEngine * fbe = FBE_cast(instance);
111 if (fbe)
112 {
113 moab::GeomTopoTool * gtt = fbe->get_gtt();
114 if (gtt)
115 delete gtt;
116 delete fbe;
117 }
118 MBiGeom **mbigeom = reinterpret_cast<MBiGeom**> (&instance);
119 if (*mbigeom)
120 delete *mbigeom;
121 *err = iBase_SUCCESS;
122 }
123
FBiGeom_load(FBiGeom_Instance instance,char const * name,char const * options,int * err,int,int options_len)124 void FBiGeom_load(FBiGeom_Instance instance, char const* name, char const* options,
125 int* err, int , int options_len) {
126 // first remove option for smooth facetting
127
128 const char smth[] = "SMOOTH;";
129 bool smooth = false;
130 const char * res = NULL;
131
132 char * reducedOptions = NULL;
133 bool localReduce = false;
134 if (options)
135 res = strstr(options, smth);
136 if (res) {
137 // extract that option, will not be recognized by our moab/imesh
138 reducedOptions = new char[options_len - 6];
139 localReduce = true;
140 int preLen = (int) (res - options);
141 strncpy(reducedOptions, options, preLen);
142 int postLen = options_len - 7 - preLen;
143
144 char * tmp = reducedOptions + preLen;
145
146 strncpy(tmp, res + 7, postLen);
147 reducedOptions[options_len - 7] = 0;
148 std::cout << reducedOptions << std::endl;
149 smooth = true;
150
151 } else {
152 reducedOptions = const_cast<char *> (options);
153 }
154 // load mesh-based geometry
155 const EntityHandle* file_set = 0;
156 ErrorCode rval = MBI->load_file(name, file_set, reducedOptions);
157 if (localReduce)
158 delete [] reducedOptions;
159 CHKERR(rval, "can't load mesh file");
160
161 FBEngine * fbe = FBE_cast(instance);
162 if (fbe == NULL) {
163 *err = iBase_FAILURE;
164 return;
165 }
166 GeomTopoTool * gtt = GETGTT(instance);
167 if (gtt == NULL) {
168 *err = iBase_FAILURE;
169 return;
170 }
171 // keep mesh-based geometries in Range
172 rval = gtt->find_geomsets();
173 CHKERR(rval, "Failure to find geometry lists.");
174
175 if (smooth) fbe->set_smooth();// assumes that initialization did not happen yet
176
177 fbe->Init();// major computation
178
179 RETURN(iBase_SUCCESS);
180 }
181
FBiGeom_save(FBiGeom_Instance instance,char const * name,char const * options,int * err,int name_len,int options_len)182 void FBiGeom_save(FBiGeom_Instance instance, char const* name, char const* options,
183 int* err, int name_len, int options_len) {
184 iMesh_save(IMESH_INSTANCE(instance), NULL, name, options, err, name_len,
185 options_len);
186 }
187
FBiGeom_getRootSet(FBiGeom_Instance instance,iBase_EntitySetHandle * root_set,int * err)188 void FBiGeom_getRootSet(FBiGeom_Instance instance, iBase_EntitySetHandle* root_set,
189 int* err) {
190 EntityHandle modelSet;
191 ErrorCode rval = FBE_cast(instance)->getRootSet(&modelSet);
192 CHKERR(rval,"can't get root set ");
193 *root_set = (iBase_EntitySetHandle)modelSet;
194 RETURN(iBase_SUCCESS);
195 }
196
FBiGeom_getBoundBox(FBiGeom_Instance instance,double *,double *,double *,double *,double *,double *,int * err)197 void FBiGeom_getBoundBox(FBiGeom_Instance instance, double* , double* ,
198 double* , double* , double* , double* , int* err) {
199 RETURN(iBase_NOT_SUPPORTED);
200 }
201
FBiGeom_getEntities(FBiGeom_Instance instance,iBase_EntitySetHandle set_handle,int entity_type,iBase_EntityHandle ** entity_handles,int * entity_handles_allocated,int * entity_handles_size,int * err)202 void FBiGeom_getEntities(FBiGeom_Instance instance,
203 iBase_EntitySetHandle set_handle, int entity_type,
204 iBase_EntityHandle** entity_handles, int* entity_handles_allocated,
205 int* entity_handles_size, int* err) {
206
207 if (0 > entity_type || 4 < entity_type) {
208 ERROR(iBase_INVALID_ENTITY_TYPE, "Bad entity type.");
209 } else/* 0<= entity_type <= 4) */ {
210 Range gentities;
211 ErrorCode rval= FBE_cast(instance)->getEntities((EntityHandle)set_handle, entity_type, gentities);
212 CHKERR(rval,"can't get entities ");
213 *entity_handles_size = gentities.size();
214
215 CHECK_SIZE(*entity_handles, *entity_handles_allocated,
216 *entity_handles_size, iBase_EntityHandle, NULL);
217 COPY_RANGE(gentities, *entity_handles);
218 }
219
220 RETURN(iBase_SUCCESS);
221 }
222
FBiGeom_getNumOfType(FBiGeom_Instance instance,iBase_EntitySetHandle set_handle,int entity_type,int * num_out,int * err)223 void FBiGeom_getNumOfType(FBiGeom_Instance instance,
224 iBase_EntitySetHandle set_handle, int entity_type, int* num_out, int* err) {
225 if (0 > entity_type || 4 < entity_type) {
226 ERROR(iBase_INVALID_ENTITY_TYPE, "Bad entity type.");
227 }
228 ErrorCode rval = FBE_cast(instance)->getNumOfType((EntityHandle)set_handle, entity_type, num_out);
229 CHKERR(rval,"can't get number of type ");
230
231 RETURN(iBase_SUCCESS);
232 }
233
234
FBiGeom_getEntType(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,int * type,int * err)235 void FBiGeom_getEntType(FBiGeom_Instance instance,
236 iBase_EntityHandle entity_handle, int* type, int* err) {
237
238 ErrorCode rval = FBE_cast(instance)->getEntType((EntityHandle)entity_handle, type);
239 CHKERR(rval,"can't get entity type ");
240
241 RETURN(iBase_SUCCESS);
242 }
243
FBiGeom_getArrType(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int ** type,int * type_allocated,int * type_size,int * err)244 void FBiGeom_getArrType(FBiGeom_Instance instance,
245 iBase_EntityHandle const* entity_handles, int entity_handles_size,
246 int** type, int* type_allocated, int* type_size, int* err) {
247 CHECK_SIZE(*type, *type_allocated, entity_handles_size, int, NULL);
248 *type_size=entity_handles_size;
249
250 int tmp_err;
251
252 for (int i = 0; i < entity_handles_size; i++) {
253 FBiGeom_getEntType(instance, entity_handles[i], *type + i, &tmp_err);
254 if (iBase_SUCCESS != tmp_err) {
255 ERROR(tmp_err, "Failed to get entity type in FBiGeom_getArrType.");
256 }
257 }
258
259 RETURN(iBase_SUCCESS);
260 }
261
FBiGeom_getEntAdj(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,int to_dimension,iBase_EntityHandle ** adj_entities,int * adj_entities_allocated,int * adj_entities_size,int * err)262 void FBiGeom_getEntAdj(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
263 int to_dimension, iBase_EntityHandle** adj_entities,
264 int* adj_entities_allocated, int* adj_entities_size, int* err) {
265 Range adjs;
266 EntityHandle this_ent = MBH_cast(entity_handle);
267
268 ErrorCode rval = FBE_cast(instance)->getEntAdj(this_ent, to_dimension,
269 adjs);
270
271 CHKERR(rval, "Failed to get adjacent entities in FBiGeom_getEntAdj.");
272
273 // copy adjacent entities
274 *adj_entities_size = adjs.size();
275 CHECK_SIZE(*adj_entities, *adj_entities_allocated,
276 *adj_entities_size, iBase_EntityHandle, NULL);
277 COPY_RANGE(adjs, *adj_entities);
278
279 RETURN(iBase_SUCCESS);
280 }
281
282 // I suspect this is wrong
FBiGeom_getArrAdj(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int requested_entity_type,iBase_EntityHandle ** adj_entity_handles,int * adj_entity_handles_allocated,int * adj_entity_handles_size,int ** offset,int * offset_allocated,int * offset_size,int * err)283 void FBiGeom_getArrAdj(FBiGeom_Instance instance,
284 iBase_EntityHandle const* entity_handles, int entity_handles_size,
285 int requested_entity_type, iBase_EntityHandle** adj_entity_handles,
286 int* adj_entity_handles_allocated, int* adj_entity_handles_size,
287 int** offset, int* offset_allocated, int* offset_size, int* err) {
288 // check offset array size
289 Range temp_range, total_range;
290 CHECK_SIZE(*offset, *offset_allocated, entity_handles_size + 1, int, NULL);
291 *offset_size = entity_handles_size + 1;
292
293 // get adjacent entities
294 for (int i = 0; i < entity_handles_size; ++i) {
295 (*offset)[i] = total_range.size();
296 temp_range.clear();
297 ErrorCode rval = FBE_cast(instance)->getEntAdj( MBH_cast(entity_handles[i]),
298 requested_entity_type,
299 temp_range);
300 CHKERR(rval, "Failed to get adjacent entities in FBiGeom_getArrAdj.");
301 total_range.merge(temp_range);
302 }
303 int nTot = total_range.size();
304 (*offset)[entity_handles_size] = nTot;
305
306 // copy adjacent entities
307 CHECK_SIZE(*adj_entity_handles, *adj_entity_handles_allocated,
308 nTot, iBase_EntityHandle, NULL);
309 COPY_RANGE(total_range, *adj_entity_handles);
310 *adj_entity_handles_size = nTot;
311
312 RETURN(iBase_SUCCESS);
313 }
314
FBiGeom_getEnt2ndAdj(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,int bridge_dimension,int to_dimension,iBase_EntityHandle ** adjacent_entities,int * adjacent_entities_allocated,int * adjacent_entities_size,int * err)315 void FBiGeom_getEnt2ndAdj(FBiGeom_Instance instance,
316 iBase_EntityHandle entity_handle, int bridge_dimension, int to_dimension,
317 iBase_EntityHandle** adjacent_entities, int* adjacent_entities_allocated,
318 int* adjacent_entities_size, int* err) {
319 Range to_ents, bridge_ents, tmp_ents;
320 ErrorCode rval = FBE_cast(instance)->getEntAdj(MBH_cast(entity_handle), bridge_dimension,
321 bridge_ents);
322
323 CHKERR(rval, "Failed to get adjacent entities in FBiGeom_getEnt2ndAdj.");
324
325 Range::iterator iter, jter, kter, end_jter;
326 Range::iterator end_iter = bridge_ents.end();
327 for (iter = bridge_ents.begin(); iter != end_iter; ++iter) {
328 rval = FBE_cast(instance)->getEntAdj(*iter, to_dimension,
329 tmp_ents);
330
331 CHKERR(rval, "Failed to get adjacent entities in FBiGeom_getEnt2ndAdj.");
332
333 for (jter = tmp_ents.begin(); jter != end_jter; ++jter) {
334 if (to_ents.find(*jter) == to_ents.end()) {
335 to_ents.insert(*jter);
336 }
337 }
338 tmp_ents.clear();
339 }
340
341 *adjacent_entities_size = to_ents.size();
342 CHECK_SIZE(*adjacent_entities, *adjacent_entities_allocated,
343 *adjacent_entities_size, iBase_EntityHandle, NULL);
344 COPY_RANGE(to_ents, *adjacent_entities);
345
346 RETURN(iBase_SUCCESS);
347 }
348
349
FBiGeom_getArr2ndAdj(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,int,iBase_EntityHandle **,int *,int *,int **,int *,int *,int * err)350 void FBiGeom_getArr2ndAdj(FBiGeom_Instance instance,
351 iBase_EntityHandle const* , int ,
352 int , int ,
353 iBase_EntityHandle** ,
354 int* , int* ,
355 int** , int* , int* , int* err) {
356 // not implemented
357 // who would need this monster, anyway?
358 RETURN(iBase_NOT_SUPPORTED);
359 }
360
FBiGeom_isEntAdj(FBiGeom_Instance instance,iBase_EntityHandle entity_handle1,iBase_EntityHandle entity_handle2,int * are_adjacent,int * err)361 void FBiGeom_isEntAdj(FBiGeom_Instance instance, iBase_EntityHandle entity_handle1,
362 iBase_EntityHandle entity_handle2, int* are_adjacent, int* err) {
363
364 bool adjacent_out;
365 ErrorCode rval = FBE_cast(instance)->isEntAdj(MBH_cast(entity_handle1), MBH_cast(entity_handle2),
366 adjacent_out);
367 CHKERR(rval, "Failed to get adjacent info");
368 *are_adjacent = (int)adjacent_out; // 0 or 1, really
369
370 RETURN(iBase_SUCCESS);
371 }
372
FBiGeom_isArrAdj(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles_1,int entity_handles_1_size,iBase_EntityHandle const * entity_handles_2,int entity_handles_2_size,int ** is_adjacent_info,int * is_adjacent_info_allocated,int * is_adjacent_info_size,int * err)373 void FBiGeom_isArrAdj(FBiGeom_Instance instance,
374 iBase_EntityHandle const* entity_handles_1, int entity_handles_1_size,
375 iBase_EntityHandle const* entity_handles_2, int entity_handles_2_size,
376 int** is_adjacent_info, int* is_adjacent_info_allocated,
377 int* is_adjacent_info_size, int* err) {
378 int index1 = 0;
379 int index2 = 0;
380 size_t index1_step, index2_step;
381 int count;
382
383 // If either list contains only 1 entry, compare that entry with
384 // every entry in the other list.
385 if (entity_handles_1_size == entity_handles_2_size) {
386 index1_step = index2_step = 1;
387 count = entity_handles_1_size;
388 } else if (entity_handles_1_size == 1) {
389 index1_step = 0;
390 index2_step = 1;
391 count = entity_handles_2_size;
392 } else if (entity_handles_2_size == 1) {
393 index1_step = 1;
394 index2_step = 0;
395 count = entity_handles_1_size;
396 } else {
397 RETURN(iBase_INVALID_ENTITY_COUNT);
398 }
399
400 CHECK_SIZE(*is_adjacent_info, *is_adjacent_info_allocated,
401 count, int, NULL);
402
403 for (int i = 0; i < count; ++i) {
404 FBiGeom_isEntAdj(instance, entity_handles_1[index1],
405 entity_handles_2[index2], &((*is_adjacent_info)[i]), err);
406 FWDERR();
407
408 index1 += index1_step;
409 index2 += index2_step;
410 }
411 // it is now safe to set the size
412 *is_adjacent_info_size = count;
413
414 RETURN(iBase_SUCCESS);
415 }
416
FBiGeom_getEntClosestPt(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double near_x,double near_y,double near_z,double * on_x,double * on_y,double * on_z,int * err)417 void FBiGeom_getEntClosestPt(FBiGeom_Instance instance,
418 iBase_EntityHandle entity_handle, double near_x, double near_y,
419 double near_z, double* on_x, double* on_y, double* on_z, int* err) {
420
421 ErrorCode rval = FBE_cast(instance)->getEntClosestPt(MBH_cast(entity_handle), near_x,
422 near_y, near_z, on_x, on_y, on_z);
423 CHKERR(rval, "Failed to get closest point");
424
425 RETURN(iBase_SUCCESS);
426 }
427
428
FBiGeom_getArrClosestPt(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int storage_order,double const * near_coordinates,int near_coordinates_size,double ** on_coordinates,int * on_coordinates_allocated,int * on_coordinates_size,int * err)429 void FBiGeom_getArrClosestPt(FBiGeom_Instance instance,
430 iBase_EntityHandle const* entity_handles, int entity_handles_size,
431 int storage_order, double const* near_coordinates,
432 int near_coordinates_size, double** on_coordinates,
433 int* on_coordinates_allocated, int* on_coordinates_size, int* err) {
434 CHECK_SIZE(*on_coordinates, *on_coordinates_allocated,
435 near_coordinates_size, double, NULL);
436
437 for (int i = 0; i < entity_handles_size; i++) {
438 if (storage_order == iBase_INTERLEAVED) {
439 FBiGeom_getEntClosestPt(instance, entity_handles[i],
440 near_coordinates[3*i], near_coordinates[3*i+1], near_coordinates[3*i+2],
441 on_coordinates[3*i], on_coordinates[3*i+1], on_coordinates[3*i+2],
442 err);
443 } else if (storage_order == iBase_BLOCKED) {
444 FBiGeom_getEntClosestPt(instance, entity_handles[i],
445 near_coordinates[i], near_coordinates[i+entity_handles_size], near_coordinates[i+2*entity_handles_size],
446 on_coordinates[i], on_coordinates[i+entity_handles_size], on_coordinates[i+2*entity_handles_size],
447 err);
448 }
449 FWDERR();
450 }
451 *on_coordinates_size = near_coordinates_size;
452
453 RETURN(iBase_SUCCESS);
454 }
455
FBiGeom_getEntNrmlXYZ(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double x,double y,double z,double * nrml_i,double * nrml_j,double * nrml_k,int * err)456 void FBiGeom_getEntNrmlXYZ(FBiGeom_Instance instance,
457 iBase_EntityHandle entity_handle, double x, double y, double z,
458 double* nrml_i, double* nrml_j, double* nrml_k, int* err) {
459
460 ErrorCode rval = FBE_cast(instance)->getEntNrmlXYZ(MBH_cast(entity_handle), x,
461 y, z, nrml_i, nrml_j, nrml_k);
462 CHKERR(rval, "Failed to get normal");
463 RETURN(iBase_SUCCESS);
464 }
465
FBiGeom_getArrNrmlXYZ(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int storage_order,double const * coordinates,int coordinates_size,double ** normals,int * normals_allocated,int * normals_size,int * err)466 void FBiGeom_getArrNrmlXYZ(FBiGeom_Instance instance,
467 iBase_EntityHandle const* entity_handles, int entity_handles_size,
468 int storage_order, double const* coordinates, int coordinates_size,
469 double** normals, int* normals_allocated, int* normals_size, int* err) {
470 // set up iteration according to storage order.
471 // allow either gentity_handles or near_coordinates to contain
472 // only one value, where that single value is applied for every
473 // entry in the other list.
474 size_t index = 0;
475 size_t coord_step, norm_step = 1, ent_step;
476 int count;
477 if (3 * entity_handles_size == coordinates_size) {
478 coord_step = ent_step = 1;
479 count = entity_handles_size;
480 } else if (coordinates_size == 3) {
481 coord_step = 0;
482 ent_step = 1;
483 count = entity_handles_size;
484 } else if (entity_handles_size == 1) {
485 coord_step = 1;
486 ent_step = 0;
487 count = coordinates_size / 3;
488 } else {
489 ERROR(iBase_INVALID_ENTITY_COUNT, "Mismatched array sizes");
490 }
491
492 // check or pre-allocate the coordinate arrays
493 CHECK_SIZE(*normals, *normals_allocated, 3*count, double, NULL);
494
495 const double *coord_x, *coord_y, *coord_z;
496 double *norm_x, *norm_y, *norm_z;
497 if (storage_order == iBase_BLOCKED) {
498 coord_x = coordinates;
499 coord_y = coord_x + coordinates_size / 3;
500 coord_z = coord_y + coordinates_size / 3;
501 norm_x = *normals;
502 norm_y = norm_x + count;
503 norm_z = norm_y + count;
504 norm_step = 1;
505 } else {
506 storage_order = iBase_INTERLEAVED; /* set if unspecified */
507 coord_x = coordinates;
508 coord_y = coord_x + 1;
509 coord_z = coord_x + 2;
510 norm_x = *normals;
511 norm_y = norm_x + 1;
512 norm_z = norm_x + 2;
513 coord_step *= 3;
514 norm_step = 3;
515 }
516
517 for (int i = 0; i < count; ++i) {
518 FBiGeom_getEntNrmlXYZ(instance, entity_handles[index], *coord_x, *coord_y,
519 *coord_z, norm_x, norm_y, norm_z, err);
520 FWDERR();
521
522 index += ent_step;
523 coord_x += coord_step;
524 coord_y += coord_step;
525 coord_z += coord_step;
526 norm_x += norm_step;
527 norm_y += norm_step;
528 norm_z += norm_step;
529 }
530 *normals_size = count;
531 RETURN(iBase_SUCCESS);
532 }
533
FBiGeom_getEntNrmlPlXYZ(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double x,double y,double z,double * pt_x,double * pt_y,double * pt_z,double * nrml_i,double * nrml_j,double * nrml_k,int * err)534 void FBiGeom_getEntNrmlPlXYZ(FBiGeom_Instance instance,
535 iBase_EntityHandle entity_handle, double x, double y, double z,
536 double* pt_x, double* pt_y, double* pt_z, double* nrml_i, double* nrml_j,
537 double* nrml_k, int* err) {
538 // just do for surface and volume
539 int type;
540 FBiGeom_getEntType(instance, entity_handle, &type, err);
541 FWDERR();
542
543 if (type != 2 && type != 3) {
544 ERROR(iBase_INVALID_ENTITY_TYPE,
545 "Entities passed into gentityNormal must be face or volume.");
546 }
547
548 // do 2 searches, so it is not fast enough
549 FBiGeom_getEntClosestPt(instance,
550 entity_handle, x, y, z, pt_x, pt_y, pt_z, err);
551
552 FWDERR();
553 FBiGeom_getEntNrmlXYZ(instance,
554 entity_handle, *pt_x, *pt_y, *pt_z,
555 nrml_i, nrml_j, nrml_k, err);
556 FWDERR();
557
558 RETURN(iBase_SUCCESS);
559 }
560
FBiGeom_getArrNrmlPlXYZ(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int storage_order,double const * near_coordinates,int near_coordinates_size,double ** on_coordinates,int * on_coordinates_allocated,int * on_coordinates_size,double ** normals,int * normals_allocated,int * normals_size,int * err)561 void FBiGeom_getArrNrmlPlXYZ(FBiGeom_Instance instance,
562 iBase_EntityHandle const* entity_handles, int entity_handles_size,
563 int storage_order, double const* near_coordinates,
564 int near_coordinates_size, double** on_coordinates,
565 int* on_coordinates_allocated, int* on_coordinates_size,
566 double** normals, int* normals_allocated, int* normals_size, int* err) {
567 // set up iteration according to storage order.
568 // allow either gentity_handles or near_coordinates to contain
569 // only one value, where that single value is applied for every
570 // entry in the other list.
571 size_t index = 0;
572 size_t near_step, on_step = 1, ent_step;
573 int count;
574 if (3 * entity_handles_size == near_coordinates_size) {
575 near_step = ent_step = 1;
576 count = entity_handles_size;
577 } else if (near_coordinates_size == 3) {
578 near_step = 0;
579 ent_step = 1;
580 count = entity_handles_size;
581 } else if (entity_handles_size == 1) {
582 near_step = 1;
583 ent_step = 0;
584 count = near_coordinates_size / 3;
585 } else {
586 ERROR(iBase_INVALID_ENTITY_COUNT, "Mismatched array sizes");
587 }
588
589 // check or pre-allocate the coordinate arrays
590 CHECK_SIZE(*on_coordinates, *on_coordinates_allocated, 3*count, double, NULL);
591 CHECK_SIZE(*normals, *normals_allocated, 3*count, double, NULL);
592
593 const double *near_x, *near_y, *near_z;
594 double *on_x, *on_y, *on_z;
595 double *norm_x, *norm_y, *norm_z;
596 if (storage_order == iBase_BLOCKED) {
597 near_x = near_coordinates;
598 near_y = near_x + near_coordinates_size / 3;
599 near_z = near_y + near_coordinates_size / 3;
600 on_x = *on_coordinates;
601 on_y = on_x + count;
602 on_z = on_y + count;
603 norm_x = *normals;
604 norm_y = norm_x + count;
605 norm_z = norm_y + count;
606 on_step = 1;
607 } else {
608 storage_order = iBase_INTERLEAVED; /* set if unspecified */
609 near_x = near_coordinates;
610 near_y = near_x + 1;
611 near_z = near_x + 2;
612 on_x = *on_coordinates;
613 on_y = on_x + 1;
614 on_z = on_x + 2;
615 norm_x = *normals;
616 norm_y = norm_x + 1;
617 norm_z = norm_x + 2;
618 near_step *= 3;
619 on_step = 3;
620 }
621
622 for (int i = 0; i < count; ++i) {
623 FBiGeom_getEntNrmlPlXYZ(instance, entity_handles[index], *near_x, *near_y,
624 *near_z, on_x, on_y, on_z, norm_x, norm_y, norm_z, err);
625 FWDERR();
626
627 //entities += ent_step;
628 index += ent_step;
629 near_x += near_step;
630 near_y += near_step;
631 near_z += near_step;
632 on_x += on_step;
633 on_y += on_step;
634 on_z += on_step;
635 norm_x += on_step;
636 norm_y += on_step;
637 norm_z += on_step;
638 }
639 *on_coordinates_size=count*3;
640 *normals_size = count;
641 RETURN(iBase_SUCCESS);
642 }
643
FBiGeom_getEntTgntXYZ(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,double *,int * err)644 void FBiGeom_getEntTgntXYZ(FBiGeom_Instance instance,
645 iBase_EntityHandle ,
646 double , double , double ,
647 double* , double* , double* ,
648 int* err) {
649 RETURN(iBase_NOT_SUPPORTED);
650 }
651
FBiGeom_getArrTgntXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)652 void FBiGeom_getArrTgntXYZ(FBiGeom_Instance instance,
653 iBase_EntityHandle const* ,
654 int ,
655 int , double const* ,
656 int ,
657 double** , int* ,
658 int* , int* err) {
659 RETURN(iBase_NOT_SUPPORTED);
660 }
661
FBiGeom_getEntBoundBox(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double * min_x,double * min_y,double * min_z,double * max_x,double * max_y,double * max_z,int * err)662 void FBiGeom_getEntBoundBox(FBiGeom_Instance instance,
663 iBase_EntityHandle entity_handle, double* min_x, double* min_y,
664 double* min_z, double* max_x, double* max_y, double* max_z, int* err) {
665 ErrorCode rval;
666 int type;
667 FBiGeom_getEntType(instance, entity_handle, &type, err);
668 FWDERR();
669
670 if (type == 0) {
671 FBiGeom_getVtxCoord(instance, entity_handle, min_x, min_y, min_z, err);
672 FWDERR();
673 max_x = min_x;
674 max_y = min_y;
675 max_z = min_z;
676 } else if (type == 1) {
677 // it could be relatively easy to support
678 *err = iBase_NOT_SUPPORTED;
679 FWDERR();
680 } else if (type == 2 || type == 3) {
681
682 EntityHandle root;
683 CartVect center, axis[3];
684 GeomTopoTool * gtt = GETGTT(instance);
685 if (!gtt)
686 ERROR(iBase_FAILURE, "Can't get geom topo tool.");
687 rval = gtt->get_root(MBH_cast(entity_handle), root);
688 CHKERR(rval, "Failed to get tree root in FBiGeom_getEntBoundBox.");
689 rval = gtt->obb_tree()->box(root, center.array(),
690 axis[0].array(), axis[1].array(), axis[2].array());
691 CHKERR(rval, "Failed to get box from obb tree.");
692
693 CartVect absv[3];
694 for (int i=0; i<3; i++)
695 {
696 absv[i]= CartVect( fabs(axis[i][0]), fabs(axis[i][1]), fabs(axis[i][2]) );
697 }
698 CartVect min, max;
699 min = center - absv[0] - absv[1] - absv[2];
700 max = center + absv[0] + absv[1] + absv[2];
701 *min_x = min[0];
702 *min_y = min[1];
703 *min_z = min[2];
704 *max_x = max[0];
705 *max_y = max[1];
706 *max_z = max[2];
707 } else
708 RETURN(iBase_INVALID_ENTITY_TYPE);
709
710 RETURN(iBase_SUCCESS);
711 }
712
FBiGeom_getArrBoundBox(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int storage_order,double ** min_corner,int * min_corner_allocated,int * min_corner_size,double ** max_corner,int * max_corner_allocated,int * max_corner_size,int * err)713 void FBiGeom_getArrBoundBox(FBiGeom_Instance instance,
714 iBase_EntityHandle const* entity_handles, int entity_handles_size,
715 int storage_order, double** min_corner, int* min_corner_allocated,
716 int* min_corner_size, double** max_corner, int* max_corner_allocated,
717 int* max_corner_size, int* err) {
718 // check or pre-allocate the coordinate arrays
719 CHECK_SIZE(*min_corner, *min_corner_allocated, 3*entity_handles_size, double, NULL);
720 CHECK_SIZE(*max_corner, *max_corner_allocated, 3*entity_handles_size, double, NULL);
721
722 size_t step, init;
723 if (storage_order == iBase_BLOCKED) {
724 step = 1;
725 init = entity_handles_size;
726 } else {
727 step = 3;
728 init = 1;
729 }
730 double *min_x, *min_y, *min_z, *max_x, *max_y, *max_z;
731 min_x = *min_corner;
732 max_x = *max_corner;
733 min_y = min_x + init;
734 max_y = max_x + init;
735 min_z = min_y + init;
736 max_z = max_y + init;
737
738 for (int i = 0; i < entity_handles_size; ++i) {
739 FBiGeom_getEntBoundBox(instance, entity_handles[i], min_x, min_y, min_z,
740 max_x, max_y, max_z, err);
741 FWDERR();
742
743 min_x += step;
744 max_x += step;
745 min_y += step;
746 max_y += step;
747 min_z += step;
748 max_z += step;
749 }
750 *min_corner_size = 3*entity_handles_size;
751 *max_corner_size = 3*entity_handles_size;
752 RETURN(iBase_SUCCESS);
753 }
754
FBiGeom_getVtxCoord(FBiGeom_Instance instance,iBase_EntityHandle vertex_handle,double * x,double * y,double * z,int * err)755 void FBiGeom_getVtxCoord(FBiGeom_Instance instance,
756 iBase_EntityHandle vertex_handle, double* x, double* y, double* z,
757 int* err) {
758 ErrorCode rval = FBE_cast(instance)->getVtxCoord(MBH_cast(vertex_handle), x, y, z);
759 CHKERR(rval, "Failed to vertex position");
760 RETURN(iBase_SUCCESS);
761 }
762
FBiGeom_getVtxArrCoords(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,int storage_order,double ** coordinates,int * coordinates_allocated,int * coordinates_size,int * err)763 void FBiGeom_getVtxArrCoords(FBiGeom_Instance instance,
764 iBase_EntityHandle const* entity_handles, int entity_handles_size,
765 int storage_order, double** coordinates, int* coordinates_allocated,
766 int* coordinates_size, int* err) {
767 // check or pre-allocate the coordinate arrays
768 CHECK_SIZE(*coordinates, *coordinates_allocated, 3*entity_handles_size, double, NULL);
769
770 double *x, *y, *z;
771 size_t step;
772 if (storage_order == iBase_BLOCKED) {
773 x = *coordinates;
774 y = x + entity_handles_size;
775 z = y + entity_handles_size;
776 step = 1;
777 } else {
778 x = *coordinates;
779 y = x + 1;
780 z = x + 2;
781 step = 3;
782 }
783
784 for (int i = 0; i < entity_handles_size; i++) {
785 FBiGeom_getVtxCoord(instance, entity_handles[i], x, y, z, err);
786 x += step;
787 y += step;
788 z += step;
789 }
790 *coordinates_size= 3*entity_handles_size;
791 RETURN(iBase_SUCCESS);
792 }
793
FBiGeom_getPntRayIntsct(FBiGeom_Instance instance,double x,double y,double z,double dir_x,double dir_y,double dir_z,iBase_EntityHandle ** intersect_entity_handles,int * intersect_entity_handles_allocated,int * intersect_entity_handles_size,int storage_order,double ** intersect_coords,int * intersect_coords_allocated,int * intersect_coords_size,double ** param_coords,int * param_coords_allocated,int * param_coords_size,int * err)794 void FBiGeom_getPntRayIntsct(FBiGeom_Instance instance, double x, double y, double z,
795 double dir_x, double dir_y, double dir_z,
796 iBase_EntityHandle** intersect_entity_handles,
797 int* intersect_entity_handles_allocated,
798 int* intersect_entity_handles_size, int storage_order,
799 double** intersect_coords, int* intersect_coords_allocated,
800 int* intersect_coords_size, double** param_coords,
801 int* param_coords_allocated, int* param_coords_size, int* err) {
802 // this is pretty cool
803 // we will return only surfaces
804 //
805 // storage order is ignored
806 std::vector<EntityHandle> intersect_handles;
807 std::vector<double> coords;
808 std::vector<double> params;
809 ErrorCode rval = FBE_cast(instance)->getPntRayIntsct(x, y, z, dir_x,
810 dir_y, dir_z,intersect_handles, coords, params);
811 CHKERR(rval,"can't get ray intersections ");
812 *intersect_entity_handles_size = (int)intersect_handles.size();
813
814 CHECK_SIZE(*intersect_entity_handles, *intersect_entity_handles_allocated,
815 *intersect_entity_handles_size, iBase_EntityHandle, NULL);
816 *intersect_coords_size = 3*(int)intersect_handles.size();
817 CHECK_SIZE(*intersect_coords, *intersect_coords_allocated,
818 *intersect_coords_size, double, NULL);
819 *param_coords_size=(int)intersect_handles.size();
820 CHECK_SIZE(*param_coords, *param_coords_allocated,
821 *param_coords_size, double, NULL);
822
823 COPY_RANGE(intersect_handles, *intersect_entity_handles);
824
825 COPY_DOUBLEVEC(params, *param_coords);
826 if (storage_order == iBase_BLOCKED) {
827 int sz=(int)intersect_handles.size();
828 for (int i=0; i<sz; i++)
829 {
830 *intersect_coords[i]=coords[3*i];
831 *intersect_coords[sz+i]=coords[3*i+1];
832 *intersect_coords[2*sz+i]=coords[3*i+2];
833 }
834 } else {
835 COPY_DOUBLEVEC(coords, *intersect_coords);
836 }
837
838 RETURN(iBase_SUCCESS);
839 }
840
FBiGeom_getPntArrRayIntsct(FBiGeom_Instance instance,int,const double *,int,const double *,int,iBase_EntityHandle **,int *,int *,int **,int *,int *,double **,int *,int *,double **,int *,int *,int * err)841 void FBiGeom_getPntArrRayIntsct(FBiGeom_Instance instance, int ,
842 const double* , int , const double* ,
843 int , iBase_EntityHandle** ,
844 int* ,
845 int* , int** , int* ,
846 int* , double** ,
847 int* , int* ,
848 double** , int* ,
849 int* , int* err) {
850 // not implemented
851 RETURN(iBase_NOT_SUPPORTED);
852 }
853
FBiGeom_getEntNrmlSense(FBiGeom_Instance instance,iBase_EntityHandle face,iBase_EntityHandle region,int * sense_out,int * err)854 void FBiGeom_getEntNrmlSense(FBiGeom_Instance instance, iBase_EntityHandle face,
855 iBase_EntityHandle region, int* sense_out, int* err) {
856 moab::EntityHandle mbregion = (moab::EntityHandle) region;
857 moab::EntityHandle mbface = (moab::EntityHandle) face;
858 moab::ErrorCode rval = FBE_cast(instance)->getEgFcSense( mbface, mbregion, *sense_out );
859 CHKERR(rval,"can't get normal sense ");
860 RETURN(iBase_SUCCESS);
861 }
FBiGeom_getArrNrmlSense(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,int **,int *,int *,int * err)862 void FBiGeom_getArrNrmlSense(FBiGeom_Instance instance,
863 iBase_EntityHandle const* , int ,
864 iBase_EntityHandle const* , int ,
865 int** , int* , int* , int* err) {
866 // not implemented
867 RETURN(iBase_NOT_SUPPORTED);
868 }
869
870 /**\brief Get the sense of an edge with respect to a face
871 * Get the sense of an edge with respect to a face. Sense returned is -1, 0, or 1,
872 * representing "reversed", "both", or "forward". "both" sense indicates that edge bounds
873 * the face once with each sense.
874 * \param edge Edge being queried
875 * \param face Face being queried
876 * \param sense_out Sense of edge with respect to face
877 */
878
FBiGeom_getEgFcSense(FBiGeom_Instance instance,iBase_EntityHandle edge,iBase_EntityHandle face,int * sense_out,int * err)879 void FBiGeom_getEgFcSense(FBiGeom_Instance instance, iBase_EntityHandle edge,
880 iBase_EntityHandle face, int* sense_out, int* err) {
881 // this one is important, for establishing the orientation of the edges in faces
882 // bummer, I "thought" it is already implemented
883 // use senses
884 ErrorCode rval = FBE_cast(instance)->getEgFcSense(MBH_cast(edge), MBH_cast (face),
885 *sense_out);
886
887 CHKERR(rval, "Failed to get edge senses in FBiGeom_getEgFcSense.");
888 RETURN(iBase_SUCCESS);
889
890 }
FBiGeom_getEgFcArrSense(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,int **,int *,int *,int * err)891 void FBiGeom_getEgFcArrSense(FBiGeom_Instance instance,
892 iBase_EntityHandle const* , int ,
893 iBase_EntityHandle const* , int ,
894 int** , int* , int* , int* err) {
895 RETURN(iBase_NOT_SUPPORTED);
896 }
897
FBiGeom_getEgVtxSense(FBiGeom_Instance instance,iBase_EntityHandle edge,iBase_EntityHandle vertex1,iBase_EntityHandle vertex2,int * sense_out,int * err)898 void FBiGeom_getEgVtxSense(FBiGeom_Instance instance, iBase_EntityHandle edge,
899 iBase_EntityHandle vertex1, iBase_EntityHandle vertex2, int* sense_out,
900 int* err) {
901
902 ErrorCode rval = FBE_cast(instance)->getEgVtxSense(MBH_cast(edge), MBH_cast(vertex1),
903 MBH_cast(vertex2), *sense_out);
904 CHKERR(rval, "Failed to get vertex sense wrt edge in FBiGeom_getEgVtxSense");
905 RETURN(iBase_SUCCESS);
906 }
FBiGeom_getEgVtxArrSense(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,int **,int *,int *,int * err)907 void FBiGeom_getEgVtxArrSense(FBiGeom_Instance instance,
908 iBase_EntityHandle const* , int ,
909 iBase_EntityHandle const* , int ,
910 iBase_EntityHandle const* , int ,
911 int** , int* , int* , int* err) {
912 RETURN(iBase_NOT_SUPPORTED);
913 }
914
FBiGeom_measure(FBiGeom_Instance instance,iBase_EntityHandle const * entity_handles,int entity_handles_size,double ** measures,int * measures_allocated,int * measures_size,int * err)915 void FBiGeom_measure(FBiGeom_Instance instance,
916 iBase_EntityHandle const* entity_handles, int entity_handles_size,
917 double** measures, int* measures_allocated, int* measures_size, int* err) {
918
919 CHECK_SIZE(*measures, *measures_allocated, entity_handles_size, double, NULL);
920 ErrorCode rval = FBE_cast(instance)->measure((EntityHandle *) (entity_handles) ,
921 entity_handles_size, *measures);
922 CHKERR(rval, "Failed to get measures");
923 *measures_size=entity_handles_size;
924 RETURN(iBase_SUCCESS);
925 }
926
FBiGeom_getFaceType(FBiGeom_Instance instance,iBase_EntityHandle,char * face_type,int * err,int * face_type_length)927 void FBiGeom_getFaceType(FBiGeom_Instance instance, iBase_EntityHandle ,
928 char* face_type, int* err, int* face_type_length) {
929 std::string type = "nonplanar"; // for swept faces created with rays between surfaces,
930 // we could actually create planar surfaces; maybe we should recognize them as such
931 face_type = new char[type.length()+1];
932 strcpy(face_type, type.c_str());
933 *face_type_length = type.length()+1;
934 RETURN(iBase_SUCCESS);
935 }
FBiGeom_getParametric(FBiGeom_Instance instance,int * is_parametric,int * err)936 void FBiGeom_getParametric(FBiGeom_Instance instance, int* is_parametric, int* err) {
937 *is_parametric = 0; //(false)
938 RETURN(iBase_SUCCESS);
939 }
FBiGeom_isEntParametric(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,int * parametric,int * err)940 void FBiGeom_isEntParametric(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
941 int* parametric, int* err) {
942 int type = -1;
943 FBiGeom_getEntType(instance, entity_handle, &type, err);
944 if (type==1)
945 *parametric = 1;// true
946 else
947 *parametric = 0; // false
948 RETURN(iBase_SUCCESS);
949 }
FBiGeom_isArrParametric(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int **,int *,int *,int * err)950 void FBiGeom_isArrParametric(FBiGeom_Instance instance,
951 iBase_EntityHandle const* , int ,
952 int** , int* ,
953 int* , int* err) {
954 // not implemented
955 RETURN(iBase_NOT_SUPPORTED);
956 }
FBiGeom_getEntUVtoXYZ(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double *,double *,double *,int * err)957 void FBiGeom_getEntUVtoXYZ(FBiGeom_Instance instance, iBase_EntityHandle ,
958 double , double , double* , double* , double* , int* err) {
959 RETURN(iBase_NOT_SUPPORTED);
960 }
FBiGeom_getArrUVtoXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)961 void FBiGeom_getArrUVtoXYZ(FBiGeom_Instance instance,
962 iBase_EntityHandle const* , int ,
963 int , double const* , int , double** ,
964 int* , int* , int* err) {
965 RETURN(iBase_NOT_SUPPORTED);
966 }
967
968
FBiGeom_getEntUtoXYZ(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double u,double * x,double * y,double * z,int * err)969 void FBiGeom_getEntUtoXYZ(FBiGeom_Instance instance,
970 iBase_EntityHandle entity_handle, double u, double* x, double* y,
971 double* z, int* err) {
972 int type ;
973 FBiGeom_getEntType(instance, entity_handle, &type, err);
974 FWDERR();
975
976 if (type != 1) // not edge
977 RETURN(iBase_NOT_SUPPORTED);
978
979 ErrorCode rval = FBE_cast(instance)->getEntUtoXYZ(
980 (EntityHandle) entity_handle, u, *x, *y, *z );
981 CHKERR(rval, "Failed to get position from parameter");
982 RETURN(iBase_SUCCESS);
983 }
984
FBiGeom_getArrUtoXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,double const *,int,int,double **,int *,int *,int * err)985 void FBiGeom_getArrUtoXYZ(FBiGeom_Instance instance,
986 iBase_EntityHandle const* , int ,
987 double const* , int , int , double** ,
988 int* , int* , int* err) {
989 // not implemented
990 RETURN(iBase_NOT_SUPPORTED);
991 }
FBiGeom_getEntXYZtoUV(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,int * err)992 void FBiGeom_getEntXYZtoUV(FBiGeom_Instance instance, iBase_EntityHandle ,
993 double , double , double , double* , double* , int* err) {
994 RETURN(iBase_NOT_SUPPORTED);
995 }
FBiGeom_getEntXYZtoU(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,int * err)996 void FBiGeom_getEntXYZtoU(FBiGeom_Instance instance, iBase_EntityHandle ,
997 double , double , double , double* , int* err) {
998 RETURN(iBase_NOT_SUPPORTED);
999 }
FBiGeom_getArrXYZtoUV(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)1000 void FBiGeom_getArrXYZtoUV(FBiGeom_Instance instance,
1001 iBase_EntityHandle const* , int ,
1002 int , double const* , int ,
1003 double** , int* , int* , int* err) {
1004 RETURN(iBase_NOT_SUPPORTED);
1005 }
FBiGeom_getArrXYZtoU(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)1006 void FBiGeom_getArrXYZtoU(FBiGeom_Instance instance,
1007 iBase_EntityHandle const* , int ,
1008 int , double const* , int ,
1009 double** , int* , int* , int* err) {
1010 RETURN(iBase_NOT_SUPPORTED);
1011 }
FBiGeom_getEntXYZtoUVHint(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,int * err)1012 void FBiGeom_getEntXYZtoUVHint(FBiGeom_Instance instance, iBase_EntityHandle ,
1013 double , double , double , double* , double* , int* err) {
1014 RETURN(iBase_NOT_SUPPORTED);
1015 }
FBiGeom_getArrXYZtoUVHint(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)1016 void FBiGeom_getArrXYZtoUVHint(FBiGeom_Instance instance,
1017 iBase_EntityHandle const* , int ,
1018 int , double const* , int , double** ,
1019 int* , int* , int* err) {
1020 RETURN(iBase_NOT_SUPPORTED);
1021 }
FBiGeom_getEntUVRange(FBiGeom_Instance instance,iBase_EntityHandle,double *,double *,double *,double *,int * err)1022 void FBiGeom_getEntUVRange(FBiGeom_Instance instance, iBase_EntityHandle ,
1023 double* , double* , double* , double* , int* err) {
1024 RETURN(iBase_NOT_SUPPORTED);
1025 }
1026
FBiGeom_getEntURange(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double * u_min,double * u_max,int * err)1027 void FBiGeom_getEntURange(FBiGeom_Instance instance,
1028 iBase_EntityHandle entity_handle, double* u_min, double* u_max, int* err) {
1029 ErrorCode rval = FBE_cast(instance)->getEntURange((EntityHandle) entity_handle,
1030 *u_min, *u_max );
1031 CHKERR(rval, "Failed to get range");
1032 RETURN(iBase_SUCCESS);
1033 }
FBiGeom_getArrUVRange(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double **,int *,int *,double **,int *,int *,int * err)1034 void FBiGeom_getArrUVRange(FBiGeom_Instance instance,
1035 iBase_EntityHandle const* , int ,
1036 int , double** , int* ,
1037 int* , double** , int* ,
1038 int* , int* err) {
1039 RETURN(iBase_NOT_SUPPORTED);
1040 }
FBiGeom_getArrURange(FBiGeom_Instance instance,iBase_EntityHandle const *,int,double **,int *,int *,double **,int *,int *,int * err)1041 void FBiGeom_getArrURange(FBiGeom_Instance instance,
1042 iBase_EntityHandle const* , int ,
1043 double** , int* , int* , double** ,
1044 int* , int* , int* err) {
1045 RETURN(iBase_NOT_SUPPORTED);
1046 }
FBiGeom_getEntUtoUV(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle,double,double *,double *,int * err)1047 void FBiGeom_getEntUtoUV(FBiGeom_Instance instance, iBase_EntityHandle ,
1048 iBase_EntityHandle , double , double* , double* ,
1049 int* err) {
1050 RETURN(iBase_NOT_SUPPORTED);
1051 }
FBiGeom_getVtxToUV(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle,double *,double *,int * err)1052 void FBiGeom_getVtxToUV(FBiGeom_Instance instance, iBase_EntityHandle ,
1053 iBase_EntityHandle , double* , double* , int* err) {
1054 RETURN(iBase_NOT_SUPPORTED);
1055 }
FBiGeom_getVtxToU(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle,double *,int * err)1056 void FBiGeom_getVtxToU(FBiGeom_Instance instance, iBase_EntityHandle ,
1057 iBase_EntityHandle , double* , int* err) {
1058 RETURN(iBase_NOT_SUPPORTED);
1059 }
FBiGeom_getArrUtoUV(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,double const *,int,int,double **,int *,int *,int * err)1060 void FBiGeom_getArrUtoUV(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1061 int , iBase_EntityHandle const* ,
1062 int , double const* , int ,
1063 int , double** , int* , int* , int* err) {
1064 RETURN(iBase_NOT_SUPPORTED);
1065 }
FBiGeom_getVtxArrToUV(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,int,double **,int *,int *,int * err)1066 void FBiGeom_getVtxArrToUV(FBiGeom_Instance instance,
1067 iBase_EntityHandle const* , int ,
1068 iBase_EntityHandle const* , int ,
1069 int , double** , int* , int* , int* err) {
1070 RETURN(iBase_NOT_SUPPORTED);
1071 }
FBiGeom_getVtxArrToU(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle const *,int,double **,int *,int *,int * err)1072 void FBiGeom_getVtxArrToU(FBiGeom_Instance instance,
1073 iBase_EntityHandle const* , int ,
1074 iBase_EntityHandle const* , int ,
1075 double** , int* , int* , int* err) {
1076 RETURN(iBase_NOT_SUPPORTED);
1077 }
FBiGeom_getEntNrmlUV(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double *,double *,double *,int * err)1078 void FBiGeom_getEntNrmlUV(FBiGeom_Instance instance, iBase_EntityHandle ,
1079 double , double , double* , double* , double* ,
1080 int* err) {
1081 RETURN(iBase_NOT_SUPPORTED);
1082 }
FBiGeom_getArrNrmlUV(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)1083 void FBiGeom_getArrNrmlUV(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1084 int , int , double const* ,
1085 int , double** , int* ,
1086 int* , int* err) {
1087 RETURN(iBase_NOT_SUPPORTED);
1088 }
FBiGeom_getEntTgntU(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,double u,double * tgnt_i,double * tgnt_j,double * tgnt_k,int * err)1089 void FBiGeom_getEntTgntU(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1090 double u, double* tgnt_i, double* tgnt_j, double* tgnt_k, int* err) {
1091 ErrorCode rval = FBE_cast(instance)->getEntTgntU( (moab::EntityHandle)entity_handle , u,
1092 *tgnt_i, *tgnt_j, *tgnt_k);
1093 CHKERR(rval, "Failed to get tangent from u");
1094 RETURN(iBase_SUCCESS);
1095 }
FBiGeom_getArrTgntU(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int * err)1096 void FBiGeom_getArrTgntU(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1097 int , int , double const* ,
1098 int , double** , int* ,
1099 int* , int* err) {
1100 RETURN(iBase_NOT_SUPPORTED);
1101 }
FBiGeom_getEnt1stDrvt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double **,int *,int *,double **,int *,int *,int * err)1102 void FBiGeom_getEnt1stDrvt(FBiGeom_Instance instance, iBase_EntityHandle ,
1103 double , double , double** , int* ,
1104 int* , double** , int* ,
1105 int* , int* err) {
1106 RETURN(iBase_NOT_SUPPORTED);
1107 }
FBiGeom_getArr1stDrvt(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int **,int *,int *,double **,int *,int *,int **,int *,int *,int * err)1108 void FBiGeom_getArr1stDrvt(FBiGeom_Instance instance,
1109 iBase_EntityHandle const* , int ,
1110 int , double const* , int , double** ,
1111 int* , int* , int** ,
1112 int* , int* , double** ,
1113 int* , int* , int** ,
1114 int* , int* , int* err) {
1115 RETURN(iBase_NOT_SUPPORTED);
1116 }
FBiGeom_getEnt2ndDrvt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double **,int *,int *,double **,int *,int *,double **,int *,int *,int * err)1117 void FBiGeom_getEnt2ndDrvt(FBiGeom_Instance instance, iBase_EntityHandle ,
1118 double , double , double** , int* ,
1119 int* , double** , int* ,
1120 int* , double** , int* ,
1121 int* , int* err) {
1122 RETURN(iBase_NOT_SUPPORTED);
1123 }
FBiGeom_getArr2ndDrvt(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,int **,int *,int *,double **,int *,int *,int **,int *,int *,double **,int *,int *,int **,int *,int *,int * err)1124 void FBiGeom_getArr2ndDrvt(FBiGeom_Instance instance,
1125 iBase_EntityHandle const* , int ,
1126 int , double const* , int , double** ,
1127 int* , int* , int** ,
1128 int* , int* , double** ,
1129 int* , int* , int** ,
1130 int* , int* , double** ,
1131 int* , int* , int** ,
1132 int* , int* , int* err) {
1133 RETURN(iBase_NOT_SUPPORTED);
1134 }
FBiGeom_getFcCvtrUV(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double *,double *,double *,double *,double *,double *,int * err)1135 void FBiGeom_getFcCvtrUV(FBiGeom_Instance instance, iBase_EntityHandle ,
1136 double , double , double* , double* , double* ,
1137 double* , double* , double* , int* err) {
1138 RETURN(iBase_NOT_SUPPORTED);
1139 }
FBiGeom_getFcArrCvtrUV(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,double **,int *,int *,int * err)1140 void FBiGeom_getFcArrCvtrUV(FBiGeom_Instance instance,
1141 iBase_EntityHandle const* , int ,
1142 int , double const* , int , double** ,
1143 int* , int* , double** ,
1144 int* , int* , int* err) {
1145 RETURN(iBase_NOT_SUPPORTED);
1146 }
FBiGeom_isEntPeriodic(FBiGeom_Instance,iBase_EntityHandle,int * in_u,int * in_v,int * err)1147 void FBiGeom_isEntPeriodic(FBiGeom_Instance /*instance*/, iBase_EntityHandle /*entity_handle*/,
1148 int* in_u, int* in_v , int* err) {
1149 *in_u = 0;
1150 *in_v = 0;
1151 *err = 0;
1152 return;
1153 }
FBiGeom_isArrPeriodic(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int **,int *,int *,int * err)1154 void FBiGeom_isArrPeriodic(FBiGeom_Instance instance,
1155 iBase_EntityHandle const* , int ,
1156 int** , int* , int* , int* err) {
1157 RETURN(iBase_NOT_SUPPORTED);
1158 }
FBiGeom_isFcDegenerate(FBiGeom_Instance instance,iBase_EntityHandle,int *,int * err)1159 void FBiGeom_isFcDegenerate(FBiGeom_Instance instance, iBase_EntityHandle ,
1160 int* , int* err) {
1161 RETURN(iBase_NOT_SUPPORTED);
1162 }
FBiGeom_isFcArrDegenerate(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int **,int *,int *,int * err)1163 void FBiGeom_isFcArrDegenerate(FBiGeom_Instance instance,
1164 iBase_EntityHandle const* , int ,
1165 int** , int* , int* ,
1166 int* err) {
1167 RETURN(iBase_NOT_SUPPORTED);
1168 }
1169
FBiGeom_initEntIter(FBiGeom_Instance instance,iBase_EntitySetHandle,int,iBase_EntityIterator *,int * err)1170 void FBiGeom_initEntIter(FBiGeom_Instance instance, iBase_EntitySetHandle ,
1171 int , iBase_EntityIterator* , int* err) {
1172 RETURN(iBase_NOT_SUPPORTED);
1173 }
1174
FBiGeom_initEntArrIter(FBiGeom_Instance instance,iBase_EntitySetHandle,int,int,iBase_EntityArrIterator *,int * err)1175 void FBiGeom_initEntArrIter(FBiGeom_Instance instance,
1176 iBase_EntitySetHandle , int ,
1177 int , iBase_EntityArrIterator* ,
1178 int* err) {
1179 RETURN(iBase_NOT_SUPPORTED);
1180 }
1181
FBiGeom_getNextEntIter(FBiGeom_Instance instance,iBase_EntityIterator,iBase_EntityHandle *,int *,int * err)1182 void FBiGeom_getNextEntIter(FBiGeom_Instance instance, iBase_EntityIterator,
1183 iBase_EntityHandle* , int* , int* err) {
1184 RETURN(iBase_NOT_SUPPORTED);
1185 }
1186
FBiGeom_getNextEntArrIter(FBiGeom_Instance instance,iBase_EntityArrIterator,iBase_EntityHandle **,int *,int *,int *,int * err)1187 void FBiGeom_getNextEntArrIter(FBiGeom_Instance instance, iBase_EntityArrIterator,
1188 iBase_EntityHandle** , int* ,
1189 int* , int* , int* err) {
1190 RETURN(iBase_NOT_SUPPORTED);
1191 }
1192
FBiGeom_resetEntIter(FBiGeom_Instance instance,iBase_EntityIterator,int * err)1193 void FBiGeom_resetEntIter(FBiGeom_Instance instance, iBase_EntityIterator, int* err) {
1194 RETURN(iBase_NOT_SUPPORTED);
1195 }
1196
FBiGeom_resetEntArrIter(FBiGeom_Instance instance,iBase_EntityArrIterator,int * err)1197 void FBiGeom_resetEntArrIter(FBiGeom_Instance instance, iBase_EntityArrIterator, int* err) {
1198 RETURN(iBase_NOT_SUPPORTED);
1199 }
1200
FBiGeom_endEntIter(FBiGeom_Instance instance,iBase_EntityIterator,int * err)1201 void FBiGeom_endEntIter(FBiGeom_Instance instance, iBase_EntityIterator, int* err) {
1202 RETURN(iBase_NOT_SUPPORTED);
1203 }
1204
FBiGeom_endEntArrIter(FBiGeom_Instance instance,iBase_EntityArrIterator,int * err)1205 void FBiGeom_endEntArrIter(FBiGeom_Instance instance, iBase_EntityArrIterator, int* err) {
1206 RETURN(iBase_NOT_SUPPORTED);
1207 }
1208
FBiGeom_copyEnt(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle *,int * err)1209 void FBiGeom_copyEnt(FBiGeom_Instance instance, iBase_EntityHandle ,
1210 iBase_EntityHandle* , int* err) {
1211 RETURN(iBase_NOT_SUPPORTED);
1212 }
1213
FBiGeom_sweepEntAboutAxis(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double,iBase_EntityHandle *,int * err)1214 void FBiGeom_sweepEntAboutAxis(FBiGeom_Instance instance, iBase_EntityHandle ,
1215 double , double , double ,
1216 double , iBase_EntityHandle* , int* err) {
1217 RETURN(iBase_NOT_SUPPORTED);
1218 }
1219
FBiGeom_deleteAll(FBiGeom_Instance instance,int * err)1220 void FBiGeom_deleteAll(FBiGeom_Instance instance, int* err) {
1221 // it means deleting some sets from moab db ; is this what we want?
1222 RETURN(iBase_NOT_SUPPORTED);
1223 }
1224
FBiGeom_deleteEnt(FBiGeom_Instance instance,iBase_EntityHandle,int * err)1225 void FBiGeom_deleteEnt(FBiGeom_Instance instance, iBase_EntityHandle /*entity_handle*/,
1226 int* err) {
1227 RETURN(iBase_NOT_SUPPORTED);
1228 }
1229
FBiGeom_createSphere(FBiGeom_Instance instance,double,iBase_EntityHandle *,int * err)1230 void FBiGeom_createSphere(FBiGeom_Instance instance, double ,
1231 iBase_EntityHandle* , int* err) {
1232 RETURN(iBase_NOT_SUPPORTED);
1233 }
1234
FBiGeom_createPrism(FBiGeom_Instance instance,double,int,double,double,iBase_EntityHandle *,int * err)1235 void FBiGeom_createPrism(FBiGeom_Instance instance, double , int ,
1236 double , double , iBase_EntityHandle* ,
1237 int* err) {
1238 RETURN(iBase_NOT_SUPPORTED);
1239 }
1240
FBiGeom_createBrick(FBiGeom_Instance instance,double,double,double,iBase_EntityHandle *,int * err)1241 void FBiGeom_createBrick(FBiGeom_Instance instance, double , double , double ,
1242 iBase_EntityHandle* , int* err) {
1243 RETURN(iBase_NOT_SUPPORTED);
1244 }
1245
FBiGeom_createCylinder(FBiGeom_Instance instance,double,double,double,iBase_EntityHandle *,int * err)1246 void FBiGeom_createCylinder(FBiGeom_Instance instance, double , double ,
1247 double , iBase_EntityHandle* , int* err) {
1248 RETURN(iBase_NOT_SUPPORTED);
1249 }
1250
FBiGeom_createCone(FBiGeom_Instance instance,double,double,double,double,iBase_EntityHandle *,int * err)1251 void FBiGeom_createCone(FBiGeom_Instance instance, double , double ,
1252 double , double , iBase_EntityHandle* ,
1253 int* err) {
1254 RETURN(iBase_NOT_SUPPORTED);
1255 }
1256
FBiGeom_createTorus(FBiGeom_Instance instance,double,double,iBase_EntityHandle *,int * err)1257 void FBiGeom_createTorus(FBiGeom_Instance instance, double , double ,
1258 iBase_EntityHandle* , int* err) {
1259 RETURN(iBase_NOT_SUPPORTED);
1260 }
1261
FBiGeom_moveEnt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,int * err)1262 void FBiGeom_moveEnt(FBiGeom_Instance instance, iBase_EntityHandle , double ,
1263 double , double , int* err) {
1264 RETURN(iBase_NOT_SUPPORTED);
1265 }
1266
FBiGeom_rotateEnt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double,int * err)1267 void FBiGeom_rotateEnt(FBiGeom_Instance instance, iBase_EntityHandle ,
1268 double , double , double ,
1269 double , int* err) {
1270 RETURN(iBase_NOT_SUPPORTED);
1271 }
1272
FBiGeom_reflectEnt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double,double,double,int * err)1273 void FBiGeom_reflectEnt(FBiGeom_Instance instance, iBase_EntityHandle ,
1274 double, double, double, double,
1275 double, double, int* err) {
1276 RETURN(iBase_NOT_SUPPORTED);
1277 }
1278
FBiGeom_scaleEnt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double,double,double,int * err)1279 void FBiGeom_scaleEnt(FBiGeom_Instance instance, iBase_EntityHandle ,
1280 double, double, double, double,
1281 double, double, int* err) {
1282 RETURN(iBase_NOT_SUPPORTED);
1283 }
1284
FBiGeom_uniteEnts(FBiGeom_Instance instance,iBase_EntityHandle const *,int,iBase_EntityHandle *,int * err)1285 void FBiGeom_uniteEnts(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1286 int , iBase_EntityHandle* , int* err) {
1287 RETURN(iBase_NOT_SUPPORTED);
1288 }
1289
FBiGeom_subtractEnts(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle,iBase_EntityHandle *,int * err)1290 void FBiGeom_subtractEnts(FBiGeom_Instance instance, iBase_EntityHandle ,
1291 iBase_EntityHandle , iBase_EntityHandle* , int* err) {
1292 RETURN(iBase_NOT_SUPPORTED);
1293 }
1294
FBiGeom_intersectEnts(FBiGeom_Instance instance,iBase_EntityHandle,iBase_EntityHandle,iBase_EntityHandle *,int * err)1295 void FBiGeom_intersectEnts(FBiGeom_Instance instance, iBase_EntityHandle ,
1296 iBase_EntityHandle , iBase_EntityHandle* , int* err) {
1297 RETURN(iBase_NOT_SUPPORTED);
1298 }
1299
FBiGeom_sectionEnt(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double,int,iBase_EntityHandle *,int * err)1300 void FBiGeom_sectionEnt(FBiGeom_Instance instance, iBase_EntityHandle ,
1301 double , double , double ,
1302 double , int , iBase_EntityHandle* , int* err) {
1303 RETURN(iBase_NOT_SUPPORTED);
1304 }
1305
FBiGeom_imprintEnts(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int * err)1306 void FBiGeom_imprintEnts(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1307 int , int* err) {
1308 RETURN(iBase_NOT_SUPPORTED);
1309 }
1310
FBiGeom_mergeEnts(FBiGeom_Instance instance,iBase_EntityHandle const *,int,double,int * err)1311 void FBiGeom_mergeEnts(FBiGeom_Instance instance, iBase_EntityHandle const* ,
1312 int , double , int* err) {
1313 RETURN(iBase_NOT_SUPPORTED);
1314 }
1315 // start copy old
1316
FBiGeom_createEntSet(FBiGeom_Instance instance,int isList,iBase_EntitySetHandle * entity_set_created,int * err)1317 void FBiGeom_createEntSet(FBiGeom_Instance instance, int isList,
1318 iBase_EntitySetHandle* entity_set_created, int *err) {
1319 iMesh_createEntSet(IMESH_INSTANCE(instance), isList, entity_set_created, err);
1320 FWDERR();
1321 }
1322
FBiGeom_destroyEntSet(FBiGeom_Instance instance,iBase_EntitySetHandle,int * err)1323 void FBiGeom_destroyEntSet(FBiGeom_Instance instance,
1324 iBase_EntitySetHandle , int *err) {
1325 RETURN(iBase_NOT_SUPPORTED);
1326 }
1327
FBiGeom_isList(FBiGeom_Instance instance,iBase_EntitySetHandle,int *,int * err)1328 void FBiGeom_isList(FBiGeom_Instance instance, iBase_EntitySetHandle ,
1329 int* , int *err) {
1330 RETURN(iBase_NOT_SUPPORTED);
1331 }
1332
FBiGeom_getNumEntSets(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,int,int * num_sets,int * err)1333 void FBiGeom_getNumEntSets(FBiGeom_Instance instance,
1334 iBase_EntitySetHandle entity_set_handle, int /*num_hops*/, int *num_sets,
1335 int *err) {
1336 // here, we get only the entity sets that have gents as members
1337 // we have the convention that entity sets of geom dimension 4 are
1338 // sets of geo entities; they should contain only gentities as elements (or other sets of gents)
1339 // we should also consider the number of hops
1340 // first, get all sets of geo dim 4 from the entity_set_handle; then intersect with
1341 // the range from geom topo tool
1342 Tag geomTag;
1343 ErrorCode rval = MBI->tag_get_handle(GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geomTag);
1344 if (MB_SUCCESS != rval)
1345 RETURN(iBase_FAILURE);
1346 GeomTopoTool * gtt = GETGTT(instance);
1347 const Range * gRange =gtt-> geoRanges();
1348 // get all sets of geom dimension 4 from the entity set
1349 EntityHandle moabSet = (EntityHandle)entity_set_handle;
1350 const int four = 4;
1351 const void* const four_val[] = { &four };
1352 Range tmp;
1353 rval = MBI->get_entities_by_type_and_tag(moabSet, MBENTITYSET, &geomTag,
1354 four_val, 1, tmp);
1355 CHKERR(rval,"can't get sets of geo dim 4 ");
1356 tmp=intersect(tmp, gRange[4]);
1357 *num_sets = tmp.size();// ignore, for the time being, number of hops
1358
1359 RETURN(iBase_SUCCESS);
1360 }
1361
FBiGeom_getEntSets(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,int,iBase_EntitySetHandle ** contained_set_handles,int * contained_set_handles_allocated,int * contained_set_handles_size,int * err)1362 void FBiGeom_getEntSets(FBiGeom_Instance instance,
1363 iBase_EntitySetHandle entity_set_handle, int ,
1364 iBase_EntitySetHandle** contained_set_handles,
1365 int* contained_set_handles_allocated, int* contained_set_handles_size,
1366 int *err) {
1367 // we get only the entity sets that have gents as members
1368 // we keep the convention that entity sets of geom dimension 4 are
1369 // sets of geo entities; they should contain only gentities as elements (or other sets of gents)
1370 Tag geomTag;
1371 ErrorCode rval = MBI->tag_get_handle(GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geomTag);
1372 if (MB_SUCCESS != rval)
1373 RETURN(iBase_FAILURE);
1374 GeomTopoTool * gtt = GETGTT(instance);
1375 const Range * gRange =gtt-> geoRanges();
1376 // get all sets of geom dimension 4 from the entity set
1377 EntityHandle moabSet = (EntityHandle)entity_set_handle;
1378 const int four = 4;
1379 const void* const four_val[] = { &four };
1380 Range tmp;
1381 rval = MBI->get_entities_by_type_and_tag(moabSet, MBENTITYSET, &geomTag,
1382 four_val, 1, tmp);
1383 CHKERR(rval,"can't get sets of geo dim 4 ");
1384 tmp=intersect(tmp, gRange[4]);
1385 *contained_set_handles_size = tmp.size();
1386 CHECK_SIZE(*contained_set_handles, *contained_set_handles_allocated,
1387 *contained_set_handles_size, iBase_EntitySetHandle, NULL);
1388 COPY_RANGE(tmp, *contained_set_handles);
1389
1390 RETURN(iBase_SUCCESS);
1391 }
1392
FBiGeom_addEntToSet(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_EntitySetHandle entity_set,int * err)1393 void FBiGeom_addEntToSet(FBiGeom_Instance instance,
1394 iBase_EntityHandle entity_handle, iBase_EntitySetHandle entity_set,
1395 int *err) {
1396 iMesh_addEntToSet(IMESH_INSTANCE(instance), entity_handle, entity_set, err);
1397 }
1398
FBiGeom_rmvEntFromSet(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_EntitySetHandle entity_set,int * err)1399 void FBiGeom_rmvEntFromSet(FBiGeom_Instance instance,
1400 iBase_EntityHandle entity_handle, iBase_EntitySetHandle entity_set,
1401 int *err) {
1402 iMesh_rmvEntFromSet(IMESH_INSTANCE(instance), entity_handle, entity_set, err);
1403 }
1404
FBiGeom_addEntArrToSet(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_EntitySetHandle entity_set,int * err)1405 void FBiGeom_addEntArrToSet(FBiGeom_Instance instance,
1406 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1407 iBase_EntitySetHandle entity_set, int *err) {
1408 iMesh_addEntArrToSet(IMESH_INSTANCE(instance), entity_handles,
1409 entity_handles_size, entity_set, err);
1410 }
1411
FBiGeom_rmvEntArrFromSet(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_EntitySetHandle entity_set,int * err)1412 void FBiGeom_rmvEntArrFromSet(FBiGeom_Instance instance,
1413 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1414 iBase_EntitySetHandle entity_set, int *err) {
1415 iMesh_rmvEntArrFromSet(IMESH_INSTANCE(instance), entity_handles,
1416 entity_handles_size, entity_set, err);
1417 }
1418
FBiGeom_addEntSet(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_to_add,iBase_EntitySetHandle entity_set_handle,int * err)1419 void FBiGeom_addEntSet(FBiGeom_Instance instance,
1420 iBase_EntitySetHandle entity_set_to_add,
1421 iBase_EntitySetHandle entity_set_handle, int *err) {
1422 iMesh_addEntSet(IMESH_INSTANCE(instance), entity_set_to_add,
1423 entity_set_handle, err);
1424 }
1425
FBiGeom_rmvEntSet(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_to_remove,iBase_EntitySetHandle entity_set_handle,int * err)1426 void FBiGeom_rmvEntSet(FBiGeom_Instance instance,
1427 iBase_EntitySetHandle entity_set_to_remove,
1428 iBase_EntitySetHandle entity_set_handle, int *err) {
1429 iMesh_rmvEntSet(IMESH_INSTANCE(instance), entity_set_to_remove,
1430 entity_set_handle, err);
1431 }
1432
FBiGeom_isEntContained(FBiGeom_Instance instance,iBase_EntitySetHandle containing_entity_set,iBase_EntityHandle contained_entity,int * is_contained,int * err)1433 void FBiGeom_isEntContained(FBiGeom_Instance instance,
1434 iBase_EntitySetHandle containing_entity_set,
1435 iBase_EntityHandle contained_entity, int *is_contained, int *err) {
1436 iMesh_isEntContained(IMESH_INSTANCE(instance), containing_entity_set,
1437 contained_entity, is_contained, err);
1438 }
1439
FBiGeom_isEntArrContained(FBiGeom_Instance instance,iBase_EntitySetHandle containing_set,const iBase_EntityHandle * entity_handles,int num_entity_handles,int ** is_contained,int * is_contained_allocated,int * is_contained_size,int * err)1440 void FBiGeom_isEntArrContained(FBiGeom_Instance instance,
1441 iBase_EntitySetHandle containing_set,
1442 const iBase_EntityHandle* entity_handles, int num_entity_handles,
1443 int** is_contained, int* is_contained_allocated, int* is_contained_size,
1444 int* err) {
1445 iMesh_isEntArrContained(IMESH_INSTANCE(instance), containing_set,
1446 entity_handles, num_entity_handles, is_contained,
1447 is_contained_allocated, is_contained_size, err);
1448 }
1449
FBiGeom_isEntSetContained(FBiGeom_Instance instance,iBase_EntitySetHandle containing_entity_set,iBase_EntitySetHandle contained_entity_set,int * is_contained,int * err)1450 void FBiGeom_isEntSetContained(FBiGeom_Instance instance,
1451 iBase_EntitySetHandle containing_entity_set,
1452 iBase_EntitySetHandle contained_entity_set, int *is_contained, int *err) {
1453 iMesh_isEntSetContained(IMESH_INSTANCE(instance), containing_entity_set,
1454 contained_entity_set, is_contained, err);
1455 }
1456
FBiGeom_addPrntChld(FBiGeom_Instance instance,iBase_EntitySetHandle parent_entity_set,iBase_EntitySetHandle child_entity_set,int * err)1457 void FBiGeom_addPrntChld(FBiGeom_Instance instance,
1458 iBase_EntitySetHandle parent_entity_set,
1459 iBase_EntitySetHandle child_entity_set, int *err) {
1460 iMesh_addPrntChld(IMESH_INSTANCE(instance), parent_entity_set,
1461 child_entity_set, err);
1462 }
1463
FBiGeom_rmvPrntChld(FBiGeom_Instance instance,iBase_EntitySetHandle parent_entity_set,iBase_EntitySetHandle child_entity_set,int * err)1464 void FBiGeom_rmvPrntChld(FBiGeom_Instance instance,
1465 iBase_EntitySetHandle parent_entity_set,
1466 iBase_EntitySetHandle child_entity_set, int *err) {
1467 iMesh_rmvPrntChld(IMESH_INSTANCE(instance), parent_entity_set,
1468 child_entity_set, err);
1469 }
1470
FBiGeom_isChildOf(FBiGeom_Instance instance,iBase_EntitySetHandle parent_entity_set,iBase_EntitySetHandle child_entity_set,int * is_child,int * err)1471 void FBiGeom_isChildOf(FBiGeom_Instance instance,
1472 iBase_EntitySetHandle parent_entity_set,
1473 iBase_EntitySetHandle child_entity_set, int *is_child, int *err) {
1474 iMesh_isChildOf(IMESH_INSTANCE(instance), parent_entity_set,
1475 child_entity_set, is_child, err);
1476 }
1477
FBiGeom_getNumChld(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,int num_hops,int * num_child,int * err)1478 void FBiGeom_getNumChld(FBiGeom_Instance instance,
1479 iBase_EntitySetHandle entity_set, int num_hops, int *num_child, int *err) {
1480 iMesh_getNumChld(IMESH_INSTANCE(instance), entity_set, num_hops, num_child,
1481 err);
1482 }
1483
FBiGeom_getNumPrnt(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,int num_hops,int * num_parent,int * err)1484 void FBiGeom_getNumPrnt(FBiGeom_Instance instance,
1485 iBase_EntitySetHandle entity_set, int num_hops, int *num_parent, int *err) {
1486 iMesh_getNumPrnt(IMESH_INSTANCE(instance), entity_set, num_hops, num_parent,
1487 err);
1488 }
1489
FBiGeom_getChldn(FBiGeom_Instance instance,iBase_EntitySetHandle from_entity_set,int num_hops,iBase_EntitySetHandle ** entity_set_handles,int * entity_set_handles_allocated,int * entity_set_handles_size,int * err)1490 void FBiGeom_getChldn(FBiGeom_Instance instance,
1491 iBase_EntitySetHandle from_entity_set, int num_hops,
1492 iBase_EntitySetHandle** entity_set_handles,
1493 int* entity_set_handles_allocated, int* entity_set_handles_size, int *err) {
1494 iMesh_getChldn(IMESH_INSTANCE(instance), from_entity_set, num_hops,
1495 entity_set_handles, entity_set_handles_allocated,
1496 entity_set_handles_size, err);
1497 }
1498
FBiGeom_getPrnts(FBiGeom_Instance instance,iBase_EntitySetHandle from_entity_set,int num_hops,iBase_EntitySetHandle ** entity_set_handles,int * entity_set_handles_allocated,int * entity_set_handles_size,int * err)1499 void FBiGeom_getPrnts(FBiGeom_Instance instance,
1500 iBase_EntitySetHandle from_entity_set, int num_hops,
1501 iBase_EntitySetHandle** entity_set_handles,
1502 int* entity_set_handles_allocated, int* entity_set_handles_size, int *err) {
1503 iMesh_getPrnts(IMESH_INSTANCE(instance), from_entity_set, num_hops,
1504 entity_set_handles, entity_set_handles_allocated,
1505 entity_set_handles_size, err);
1506 }
1507
FBiGeom_createTag(FBiGeom_Instance instance,const char * tag_name,int tag_size,int tag_type,iBase_TagHandle * tag_handle,int * err,int tag_name_len)1508 void FBiGeom_createTag(FBiGeom_Instance instance, const char* tag_name,
1509 int tag_size, int tag_type, iBase_TagHandle* tag_handle, int *err,
1510 int tag_name_len) {
1511
1512 iMesh_createTag(IMESH_INSTANCE(instance), tag_name, tag_size, tag_type,
1513 tag_handle, err, tag_name_len);
1514 }
1515
1516
FBiGeom_destroyTag(FBiGeom_Instance instance,iBase_TagHandle tag_handle,int,int * err)1517 void FBiGeom_destroyTag(FBiGeom_Instance instance, iBase_TagHandle tag_handle,
1518 int , int *err) {
1519 ErrorCode rval = MBI->tag_delete(TAG_HANDLE(tag_handle));
1520 CHKERR(rval, "Failed to delete tag");
1521 RETURN(iBase_SUCCESS);
1522 }
1523
FBiGeom_getTagName(FBiGeom_Instance instance,iBase_TagHandle tag_handle,char * name,int * err,int name_len)1524 void FBiGeom_getTagName(FBiGeom_Instance instance, iBase_TagHandle tag_handle,
1525 char *name, int* err, int name_len) {
1526 iMesh_getTagName(IMESH_INSTANCE(instance), tag_handle, name, err, name_len);
1527 }
1528
FBiGeom_getTagSizeValues(FBiGeom_Instance instance,iBase_TagHandle tag_handle,int * tag_size,int * err)1529 void FBiGeom_getTagSizeValues(FBiGeom_Instance instance,
1530 iBase_TagHandle tag_handle, int *tag_size, int *err) {
1531 iMesh_getTagSizeValues(IMESH_INSTANCE(instance), tag_handle, tag_size, err);
1532 }
1533
FBiGeom_getTagSizeBytes(FBiGeom_Instance instance,iBase_TagHandle tag_handle,int * tag_size,int * err)1534 void FBiGeom_getTagSizeBytes(FBiGeom_Instance instance, iBase_TagHandle tag_handle,
1535 int *tag_size, int *err) {
1536 iMesh_getTagSizeBytes(IMESH_INSTANCE(instance), tag_handle, tag_size, err);
1537 }
1538
FBiGeom_getTagHandle(FBiGeom_Instance instance,const char * tag_name,iBase_TagHandle * tag_handle,int * err,int tag_name_len)1539 void FBiGeom_getTagHandle(FBiGeom_Instance instance, const char* tag_name,
1540 iBase_TagHandle *tag_handle, int *err, int tag_name_len) {
1541 iMesh_getTagHandle(IMESH_INSTANCE(instance), tag_name, tag_handle, err,
1542 tag_name_len);
1543 }
1544
FBiGeom_getTagType(FBiGeom_Instance instance,iBase_TagHandle tag_handle,int * tag_type,int * err)1545 void FBiGeom_getTagType(FBiGeom_Instance instance, iBase_TagHandle tag_handle,
1546 int *tag_type, int *err) {
1547 iMesh_getTagType(IMESH_INSTANCE(instance), tag_handle, tag_type, err);
1548 }
1549
FBiGeom_setEntSetData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,iBase_TagHandle tag_handle,const void * tag_value,int tag_value_size,int * err)1550 void FBiGeom_setEntSetData(FBiGeom_Instance instance,
1551 iBase_EntitySetHandle entity_set_handle, iBase_TagHandle tag_handle,
1552 const void* tag_value, int tag_value_size, int *err) {
1553 iMesh_setEntSetData(IMESH_INSTANCE(instance), entity_set_handle, tag_handle,
1554 tag_value, tag_value_size, err);
1555 }
1556
FBiGeom_setEntSetIntData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,int tag_value,int * err)1557 void FBiGeom_setEntSetIntData(FBiGeom_Instance instance,
1558 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1559 int tag_value, int *err) {
1560 iMesh_setEntSetIntData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1561 tag_value, err);
1562 }
1563
FBiGeom_setEntSetDblData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,double tag_value,int * err)1564 void FBiGeom_setEntSetDblData(FBiGeom_Instance instance,
1565 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1566 double tag_value, int *err) {
1567 iMesh_setEntSetDblData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1568 tag_value, err);
1569 }
1570
FBiGeom_setEntSetEHData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,iBase_EntityHandle tag_value,int * err)1571 void FBiGeom_setEntSetEHData(FBiGeom_Instance instance,
1572 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1573 iBase_EntityHandle tag_value, int *err) {
1574 iMesh_setEntSetEHData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1575 tag_value, err);
1576 }
1577
FBiGeom_setEntSetESHData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,iBase_EntitySetHandle tag_value,int * err)1578 void FBiGeom_setEntSetESHData(FBiGeom_Instance instance,
1579 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1580 iBase_EntitySetHandle tag_value, int *err) {
1581 iMesh_setEntSetESHData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1582 tag_value, err);
1583 }
1584
FBiGeom_getEntSetData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,iBase_TagHandle tag_handle,void ** tag_value,int * tag_value_allocated,int * tag_value_size,int * err)1585 void FBiGeom_getEntSetData(FBiGeom_Instance instance,
1586 iBase_EntitySetHandle entity_set_handle, iBase_TagHandle tag_handle,
1587 void** tag_value, int* tag_value_allocated, int* tag_value_size, int *err) {
1588 iMesh_getEntSetData(IMESH_INSTANCE(instance), entity_set_handle, tag_handle,
1589 tag_value, tag_value_allocated, tag_value_size, err);
1590 }
1591
FBiGeom_getEntSetIntData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,int * out_data,int * err)1592 void FBiGeom_getEntSetIntData(FBiGeom_Instance instance,
1593 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1594 int *out_data, int *err) {
1595 iMesh_getEntSetIntData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1596 out_data, err);
1597 }
1598
FBiGeom_getEntSetDblData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,double * out_data,int * err)1599 void FBiGeom_getEntSetDblData(FBiGeom_Instance instance,
1600 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1601 double *out_data, int *err) {
1602 iMesh_getEntSetDblData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1603 out_data, err);
1604 }
1605
FBiGeom_getEntSetEHData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,iBase_EntityHandle * out_data,int * err)1606 void FBiGeom_getEntSetEHData(FBiGeom_Instance instance,
1607 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1608 iBase_EntityHandle *out_data, int *err) {
1609 iMesh_getEntSetEHData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1610 out_data, err);
1611 }
1612
FBiGeom_getEntSetESHData(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set,iBase_TagHandle tag_handle,iBase_EntitySetHandle * out_data,int * err)1613 void FBiGeom_getEntSetESHData(FBiGeom_Instance instance,
1614 iBase_EntitySetHandle entity_set, iBase_TagHandle tag_handle,
1615 iBase_EntitySetHandle *out_data, int *err) {
1616 iMesh_getEntSetESHData(IMESH_INSTANCE(instance), entity_set, tag_handle,
1617 out_data, err);
1618 }
1619
FBiGeom_getAllEntSetTags(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,iBase_TagHandle ** tag_handles,int * tag_handles_allocated,int * tag_handles_size,int * err)1620 void FBiGeom_getAllEntSetTags(FBiGeom_Instance instance,
1621 iBase_EntitySetHandle entity_set_handle, iBase_TagHandle** tag_handles,
1622 int* tag_handles_allocated, int* tag_handles_size, int *err) {
1623 iMesh_getAllEntSetTags(IMESH_INSTANCE(instance), entity_set_handle,
1624 tag_handles, tag_handles_allocated, tag_handles_size, err);
1625 }
1626
FBiGeom_rmvEntSetTag(FBiGeom_Instance instance,iBase_EntitySetHandle entity_set_handle,iBase_TagHandle tag_handle,int * err)1627 void FBiGeom_rmvEntSetTag(FBiGeom_Instance instance,
1628 iBase_EntitySetHandle entity_set_handle, iBase_TagHandle tag_handle,
1629 int *err) {
1630 iMesh_rmvEntSetTag(IMESH_INSTANCE(instance), entity_set_handle, tag_handle,
1631 err);
1632 }
1633
FBiGeom_getArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,void ** tag_values,int * tag_values_allocated,int * tag_values_size,int * err)1634 void FBiGeom_getArrData(FBiGeom_Instance instance,
1635 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1636 iBase_TagHandle tag_handle, void** tag_values, int* tag_values_allocated,
1637 int* tag_values_size, int *err) {
1638 iMesh_getArrData(IMESH_INSTANCE(instance), entity_handles,
1639 entity_handles_size, tag_handle, tag_values, tag_values_allocated,
1640 tag_values_size, err);
1641 }
1642
FBiGeom_getIntArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,int ** tag_values,int * tag_values_allocated,int * tag_values_size,int * err)1643 void FBiGeom_getIntArrData(FBiGeom_Instance instance,
1644 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1645 iBase_TagHandle tag_handle, int** tag_values, int* tag_values_allocated,
1646 int* tag_values_size, int *err) {
1647 iMesh_getIntArrData(IMESH_INSTANCE(instance), entity_handles,
1648 entity_handles_size, tag_handle, tag_values, tag_values_allocated,
1649 tag_values_size, err);
1650 }
1651
FBiGeom_getDblArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,double ** tag_values,int * tag_values_allocated,int * tag_values_size,int * err)1652 void FBiGeom_getDblArrData(FBiGeom_Instance instance,
1653 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1654 iBase_TagHandle tag_handle, double** tag_values,
1655 int* tag_values_allocated, int* tag_values_size, int *err) {
1656 iMesh_getDblArrData(IMESH_INSTANCE(instance), entity_handles,
1657 entity_handles_size, tag_handle, tag_values, tag_values_allocated,
1658 tag_values_size, err);
1659 }
1660
FBiGeom_getEHArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,iBase_EntityHandle ** tag_value,int * tag_value_allocated,int * tag_value_size,int * err)1661 void FBiGeom_getEHArrData(FBiGeom_Instance instance,
1662 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1663 iBase_TagHandle tag_handle, iBase_EntityHandle** tag_value,
1664 int* tag_value_allocated, int* tag_value_size, int *err) {
1665 iMesh_getEHArrData(IMESH_INSTANCE(instance), entity_handles,
1666 entity_handles_size, tag_handle, tag_value, tag_value_allocated,
1667 tag_value_size, err);
1668 }
1669
FBiGeom_getESHArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,iBase_EntitySetHandle ** tag_value,int * tag_value_allocated,int * tag_value_size,int * err)1670 void FBiGeom_getESHArrData(FBiGeom_Instance instance,
1671 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1672 iBase_TagHandle tag_handle, iBase_EntitySetHandle** tag_value,
1673 int* tag_value_allocated, int* tag_value_size, int *err) {
1674 iMesh_getESHArrData(IMESH_INSTANCE(instance), entity_handles,
1675 entity_handles_size, tag_handle, tag_value, tag_value_allocated,
1676 tag_value_size, err);
1677 }
1678
FBiGeom_setArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,const void * tag_values,int tag_values_size,int * err)1679 void FBiGeom_setArrData(FBiGeom_Instance instance,
1680 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1681 iBase_TagHandle tag_handle, const void* tag_values, int tag_values_size,
1682 int *err) {
1683 iMesh_setArrData(IMESH_INSTANCE(instance), entity_handles,
1684 entity_handles_size, tag_handle, tag_values, tag_values_size, err);
1685 }
1686
FBiGeom_setIntArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,const int * tag_values,int tag_values_size,int * err)1687 void FBiGeom_setIntArrData(FBiGeom_Instance instance,
1688 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1689 iBase_TagHandle tag_handle, const int* tag_values, int tag_values_size,
1690 int *err) {
1691 iMesh_setIntArrData(IMESH_INSTANCE(instance), entity_handles,
1692 entity_handles_size, tag_handle, tag_values, tag_values_size, err);
1693 }
1694
FBiGeom_setDblArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,const double * tag_values,const int tag_values_size,int * err)1695 void FBiGeom_setDblArrData(FBiGeom_Instance instance,
1696 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1697 iBase_TagHandle tag_handle, const double* tag_values,
1698 const int tag_values_size, int *err) {
1699 iMesh_setDblArrData(IMESH_INSTANCE(instance), entity_handles,
1700 entity_handles_size, tag_handle, tag_values, tag_values_size, err);
1701 }
1702
FBiGeom_setEHArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,const iBase_EntityHandle * tag_values,int tag_values_size,int * err)1703 void FBiGeom_setEHArrData(FBiGeom_Instance instance,
1704 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1705 iBase_TagHandle tag_handle, const iBase_EntityHandle* tag_values,
1706 int tag_values_size, int *err) {
1707 iMesh_setEHArrData(IMESH_INSTANCE(instance), entity_handles,
1708 entity_handles_size, tag_handle, tag_values, tag_values_size, err);
1709 }
1710
FBiGeom_setESHArrData(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,const iBase_EntitySetHandle * tag_values,int tag_values_size,int * err)1711 void FBiGeom_setESHArrData(FBiGeom_Instance instance,
1712 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1713 iBase_TagHandle tag_handle, const iBase_EntitySetHandle* tag_values,
1714 int tag_values_size, int *err) {
1715 iMesh_setESHArrData(IMESH_INSTANCE(instance), entity_handles,
1716 entity_handles_size, tag_handle, tag_values, tag_values_size, err);
1717 }
1718
FBiGeom_rmvArrTag(FBiGeom_Instance instance,const iBase_EntityHandle * entity_handles,int entity_handles_size,iBase_TagHandle tag_handle,int * err)1719 void FBiGeom_rmvArrTag(FBiGeom_Instance instance,
1720 const iBase_EntityHandle* entity_handles, int entity_handles_size,
1721 iBase_TagHandle tag_handle, int *err) {
1722 iMesh_rmvArrTag(IMESH_INSTANCE(instance), entity_handles,
1723 entity_handles_size, tag_handle, err);
1724 }
1725
FBiGeom_getData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,void ** tag_value,int * tag_value_allocated,int * tag_value_size,int * err)1726 void FBiGeom_getData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1727 iBase_TagHandle tag_handle, void** tag_value, int *tag_value_allocated,
1728 int *tag_value_size, int *err) {
1729 iMesh_getData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1730 tag_value, tag_value_allocated, tag_value_size, err);
1731 }
1732
FBiGeom_getIntData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,int * out_data,int * err)1733 void FBiGeom_getIntData(FBiGeom_Instance instance,
1734 iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
1735 int *out_data, int *err) {
1736 iMesh_getIntData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1737 out_data, err);
1738 }
1739
FBiGeom_getDblData(FBiGeom_Instance instance,const iBase_EntityHandle entity_handle,const iBase_TagHandle tag_handle,double * out_data,int * err)1740 void FBiGeom_getDblData(FBiGeom_Instance instance,
1741 const iBase_EntityHandle entity_handle, const iBase_TagHandle tag_handle,
1742 double *out_data, int *err) {
1743 iMesh_getDblData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1744 out_data, err);
1745 }
1746
FBiGeom_getEHData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,iBase_EntityHandle * out_data,int * err)1747 void FBiGeom_getEHData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1748 iBase_TagHandle tag_handle, iBase_EntityHandle *out_data, int *err) {
1749 iMesh_getEHData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1750 out_data, err);
1751 }
1752
FBiGeom_getESHData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,iBase_EntitySetHandle * out_data,int * err)1753 void FBiGeom_getESHData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1754 iBase_TagHandle tag_handle, iBase_EntitySetHandle *out_data, int *err) {
1755 iMesh_getESHData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1756 out_data, err);
1757 }
1758
FBiGeom_setData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,const void * tag_value,int tag_value_size,int * err)1759 void FBiGeom_setData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1760 iBase_TagHandle tag_handle, const void* tag_value, int tag_value_size,
1761 int *err) {
1762 iMesh_setData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1763 tag_value, tag_value_size, err);
1764 }
1765
FBiGeom_setIntData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,int tag_value,int * err)1766 void FBiGeom_setIntData(FBiGeom_Instance instance,
1767 iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
1768 int tag_value, int *err) {
1769 iMesh_setIntData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1770 tag_value, err);
1771 }
1772
FBiGeom_setDblData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,double tag_value,int * err)1773 void FBiGeom_setDblData(FBiGeom_Instance instance,
1774 iBase_EntityHandle entity_handle, iBase_TagHandle tag_handle,
1775 double tag_value, int *err) {
1776 iMesh_setDblData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1777 tag_value, err);
1778 }
1779
FBiGeom_setEHData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,iBase_EntityHandle tag_value,int * err)1780 void FBiGeom_setEHData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1781 iBase_TagHandle tag_handle, iBase_EntityHandle tag_value, int *err) {
1782 iMesh_setEHData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1783 tag_value, err);
1784 }
1785
FBiGeom_setESHData(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,iBase_EntitySetHandle tag_value,int * err)1786 void FBiGeom_setESHData(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1787 iBase_TagHandle tag_handle, iBase_EntitySetHandle tag_value, int *err) {
1788 iMesh_setESHData(IMESH_INSTANCE(instance), entity_handle, tag_handle,
1789 tag_value, err);
1790 }
1791
FBiGeom_getAllTags(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle ** tag_handles,int * tag_handles_allocated,int * tag_handles_size,int * err)1792 void FBiGeom_getAllTags(FBiGeom_Instance instance,
1793 iBase_EntityHandle entity_handle, iBase_TagHandle** tag_handles,
1794 int* tag_handles_allocated, int* tag_handles_size, int *err) {
1795 iMesh_getAllTags(IMESH_INSTANCE(instance), entity_handle, tag_handles,
1796 tag_handles_allocated, tag_handles_size, err);
1797 }
1798
FBiGeom_rmvTag(FBiGeom_Instance instance,iBase_EntityHandle entity_handle,iBase_TagHandle tag_handle,int * err)1799 void FBiGeom_rmvTag(FBiGeom_Instance instance, iBase_EntityHandle entity_handle,
1800 iBase_TagHandle tag_handle, int *err) {
1801 iMesh_rmvTag(IMESH_INSTANCE(instance), entity_handle, tag_handle, err);
1802 }
1803
FBiGeom_subtract(FBiGeom_Instance instance,iBase_EntitySetHandle,iBase_EntitySetHandle,iBase_EntitySetHandle *,int * err)1804 void FBiGeom_subtract(FBiGeom_Instance instance,
1805 iBase_EntitySetHandle , iBase_EntitySetHandle ,
1806 iBase_EntitySetHandle* , int *err) {
1807 RETURN(iBase_NOT_SUPPORTED);
1808 }
1809
FBiGeom_intersect(FBiGeom_Instance instance,iBase_EntitySetHandle,iBase_EntitySetHandle,iBase_EntitySetHandle *,int * err)1810 void FBiGeom_intersect(FBiGeom_Instance instance,
1811 iBase_EntitySetHandle , iBase_EntitySetHandle ,
1812 iBase_EntitySetHandle* , int *err) {
1813 RETURN(iBase_NOT_SUPPORTED);
1814 }
1815
FBiGeom_unite(FBiGeom_Instance instance,iBase_EntitySetHandle,iBase_EntitySetHandle,iBase_EntitySetHandle *,int * err)1816 void FBiGeom_unite(FBiGeom_Instance instance, iBase_EntitySetHandle ,
1817 iBase_EntitySetHandle ,
1818 iBase_EntitySetHandle* , int *err) {
1819 RETURN(iBase_NOT_SUPPORTED);
1820 }
1821
1822 // TODO methods not yet implemented
FBiGeom_getEntClosestPtTrimmed(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,double *,int * err)1823 void FBiGeom_getEntClosestPtTrimmed( FBiGeom_Instance instance,
1824 iBase_EntityHandle ,
1825 double ,
1826 double ,
1827 double ,
1828 double* ,
1829 double* ,
1830 double* ,
1831 int* err )
1832 {
1833 RETURN(iBase_NOT_SUPPORTED);
1834 }
1835
FBiGeom_getFcCvtrXYZ(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,double *,double *,double *,double *,int * err)1836 void FBiGeom_getFcCvtrXYZ( FBiGeom_Instance instance,
1837 iBase_EntityHandle ,
1838 double ,
1839 double ,
1840 double ,
1841 double* ,
1842 double* ,
1843 double* ,
1844 double* ,
1845 double* ,
1846 double* ,
1847 int* err )
1848 {
1849 RETURN(iBase_NOT_SUPPORTED);
1850 }
1851
FBiGeom_getEgCvtrXYZ(FBiGeom_Instance instance,iBase_EntityHandle,double,double,double,double *,double *,double *,int * err)1852 void FBiGeom_getEgCvtrXYZ( FBiGeom_Instance instance,
1853 iBase_EntityHandle ,
1854 double ,
1855 double ,
1856 double ,
1857 double* ,
1858 double* ,
1859 double* ,
1860 int* err )
1861 {
1862 RETURN(iBase_NOT_SUPPORTED);
1863 }
1864
FBiGeom_getEntArrCvtrXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,double **,int *,int *,int * err)1865 void FBiGeom_getEntArrCvtrXYZ( FBiGeom_Instance instance,
1866 iBase_EntityHandle const* ,
1867 int ,
1868 int ,
1869 double const* ,
1870 int ,
1871 double** ,
1872 int* ,
1873 int* ,
1874 double** ,
1875 int* ,
1876 int* ,
1877 int* err )
1878 {
1879 RETURN(iBase_NOT_SUPPORTED);
1880 }
1881
FBiGeom_getEgEvalXYZ(FBiGeom_Instance instance,iBase_EntityHandle edge,double x,double y,double z,double * on_x,double * on_y,double * on_z,double * tngt_i,double * tngt_j,double * tngt_k,double * cvtr_i,double * cvtr_j,double * cvtr_k,int * err)1882 void FBiGeom_getEgEvalXYZ( FBiGeom_Instance instance,
1883 iBase_EntityHandle edge,
1884 double x,
1885 double y,
1886 double z,
1887 double* on_x,
1888 double* on_y,
1889 double* on_z,
1890 double* tngt_i,
1891 double* tngt_j,
1892 double* tngt_k,
1893 double* cvtr_i,
1894 double* cvtr_j,
1895 double* cvtr_k,
1896 int* err )
1897 {
1898 ErrorCode rval = FBE_cast(instance)->getEgEvalXYZ( (moab::EntityHandle) edge,
1899 x, y, z,
1900 *on_x, *on_y, *on_z,
1901 *tngt_i, *tngt_j, *tngt_k,
1902 *cvtr_i, *cvtr_j, *cvtr_k );
1903 CHKERR(rval,"can't get point on edge ");
1904 RETURN(iBase_SUCCESS);
1905 }
1906
FBiGeom_getFcEvalXYZ(FBiGeom_Instance instance,iBase_EntityHandle face_handle,double x,double y,double z,double * on_x,double * on_y,double * on_z,double * nrml_i,double * nrml_j,double * nrml_k,double * cvtr1_i,double * cvtr1_j,double * cvtr1_k,double * cvtr2_i,double * cvtr2_j,double * cvtr2_k,int * err)1907 void FBiGeom_getFcEvalXYZ( FBiGeom_Instance instance,
1908 iBase_EntityHandle face_handle,
1909 double x,
1910 double y,
1911 double z,
1912 double* on_x,
1913 double* on_y,
1914 double* on_z,
1915 double* nrml_i,
1916 double* nrml_j,
1917 double* nrml_k,
1918 double* cvtr1_i,
1919 double* cvtr1_j,
1920 double* cvtr1_k,
1921 double* cvtr2_i,
1922 double* cvtr2_j,
1923 double* cvtr2_k,
1924 int* err )
1925 {
1926 /*
1927 moab::ErrorCode rval = _fbEngine->getFcEvalXYZ( (moab::EntityHandle) face,
1928 x, y, z,
1929 on_x, on_y, on_z,
1930 nrml_i, nrml_j, nrml_k,
1931 cvtr1_i, cvtr1_j, cvtr1_k,
1932 cvtr2_i, cvtr2_j, cvtr2_k );*/
1933 // camal really does not use curvatures
1934 // the most it is calling for normals and for closest point
1935 // return all curvatures = 0 for the time being, because we
1936 // know camal is not requesting them
1937
1938 *cvtr1_i=*cvtr1_j=*cvtr1_k= *cvtr2_i= *cvtr2_j= *cvtr2_k=0.;
1939 // first get closest point, then normal, separately
1940 ErrorCode rval = FBE_cast(instance)->getEntClosestPt((moab::EntityHandle) face_handle,
1941 x, y, z,
1942 on_x, on_y, on_z );
1943 CHKERR(rval,"can't get closest point on surface ");
1944 rval = FBE_cast(instance)->getEntNrmlXYZ( (moab::EntityHandle) face_handle,
1945 x, y, z,
1946 nrml_i, nrml_j, nrml_k ); // some inconsistency here, we use pointers, not refs
1947 CHKERR(rval,"can't get normal on closest point on surface ");
1948 RETURN(iBase_SUCCESS);
1949 }
1950
FBiGeom_getArrEgEvalXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,double **,int *,int *,double **,int *,int *,int * err)1951 void FBiGeom_getArrEgEvalXYZ( FBiGeom_Instance instance,
1952 iBase_EntityHandle const* ,
1953 int ,
1954 int ,
1955 double const* ,
1956 int ,
1957 double** ,
1958 int* ,
1959 int* ,
1960 double** ,
1961 int* ,
1962 int* ,
1963 double** ,
1964 int* ,
1965 int* ,
1966 int* err )
1967 {
1968 RETURN(iBase_NOT_SUPPORTED);
1969 }
1970
FBiGeom_getArrFcEvalXYZ(FBiGeom_Instance instance,iBase_EntityHandle const *,int,int,double const *,int,double **,int *,int *,double **,int *,int *,double **,int *,int *,double **,int *,int *,int * err)1971 void FBiGeom_getArrFcEvalXYZ( FBiGeom_Instance instance,
1972 iBase_EntityHandle const* ,
1973 int ,
1974 int ,
1975 double const* ,
1976 int ,
1977 double** ,
1978 int* ,
1979 int* ,
1980 double** ,
1981 int* ,
1982 int* ,
1983 double** ,
1984 int* ,
1985 int* ,
1986 double** ,
1987 int* ,
1988 int* ,
1989 int* err )
1990 {
1991 RETURN(iBase_NOT_SUPPORTED);
1992 }
1993
FBiGeom_getPntClsf(FBiGeom_Instance instance,double,double,double,iBase_EntityHandle *,int * err)1994 void FBiGeom_getPntClsf( FBiGeom_Instance instance,
1995 double ,
1996 double ,
1997 double ,
1998 iBase_EntityHandle* ,
1999 int* err )
2000 {
2001 RETURN(iBase_NOT_SUPPORTED);
2002 }
2003
FBiGeom_getPntArrClsf(FBiGeom_Instance instance,int,double const *,int,iBase_EntityHandle **,int *,int *,int * err)2004 void FBiGeom_getPntArrClsf( FBiGeom_Instance instance,
2005 int ,
2006 double const* ,
2007 int ,
2008 iBase_EntityHandle** ,
2009 int* ,
2010 int* ,
2011 int* err )
2012 {
2013 RETURN(iBase_NOT_SUPPORTED);
2014 }
2015
FBiGeom_getFacets(FBiGeom_Instance instance,iBase_EntityHandle,double,double,int,int,int,int,int,int * err)2016 void FBiGeom_getFacets(FBiGeom_Instance instance,
2017 iBase_EntityHandle ,
2018 double ,
2019 double , int , int ,
2020 int , int , int ,
2021 int *err)
2022 {
2023 RETURN(iBase_NOT_SUPPORTED);
2024 }
2025
FBiGeom_getEntTolerance(FBiGeom_Instance instance,iBase_EntityHandle,double *,int * err)2026 void FBiGeom_getEntTolerance( FBiGeom_Instance instance,
2027 iBase_EntityHandle ,
2028 double* ,
2029 int* err )
2030 {
2031 RETURN(iBase_NOT_SUPPORTED);
2032 }
FBiGeom_getArrTolerance(FBiGeom_Instance instance,iBase_EntityHandle const *,int,double **,int *,int *,int * err)2033 void FBiGeom_getArrTolerance( FBiGeom_Instance instance,
2034 iBase_EntityHandle const* ,
2035 int ,
2036 double** ,
2037 int* ,
2038 int* ,
2039 int* err )
2040 {
2041 RETURN(iBase_NOT_SUPPORTED);
2042 }
FBiGeom_getTolerance(FBiGeom_Instance instance,int *,double *,int * err)2043 void FBiGeom_getTolerance( FBiGeom_Instance instance,
2044 int* ,
2045 double* ,
2046 int* err )
2047 {
2048 RETURN(iBase_NOT_SUPPORTED);
2049 }
2050
2051