Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : FacetQueryEngine.cpp
3 : : //
4 : : // Purpose : Implementation of the FacetQueryEngine class.
5 : : // This class provides facet-based implementations
6 : : // of various virtual functions in the GeometryQueryEngine
7 : : // hierarchy.
8 : : //
9 : : // Special Notes :
10 : : //
11 : : // Creator : David R. White
12 : : //
13 : : // Creation Date : 7/17/00
14 : : //
15 : : //-------------------------------------------------------------------------
16 : : #include "FacetQueryEngine.hpp"
17 : : #include "FacetModifyEngine.hpp"
18 : : #include "FacetboolInterface.hpp"
19 : : #include "TopologyEntity.hpp"
20 : : #include "TopologyBridge.hpp"
21 : : #include "RefEntity.hpp"
22 : : #include "Body.hpp"
23 : : #include "Shell.hpp"
24 : : #include "Loop.hpp"
25 : : #include "Chain.hpp"
26 : : #include "CoEdge.hpp"
27 : : #include "CoFace.hpp"
28 : : #include "RefVolume.hpp"
29 : : #include "RefFace.hpp"
30 : : #include "RefEdge.hpp"
31 : : #include "RefVertex.hpp"
32 : : #include "GeometryEntity.hpp"
33 : : #include "DLIList.hpp"
34 : : #include "CubitBox.hpp"
35 : : #include "CubitString.hpp"
36 : : #include "FacetPoint.hpp"
37 : : #include "FacetCurve.hpp"
38 : : #include "FacetCoEdge.hpp"
39 : : #include "FacetLoop.hpp"
40 : : #include "FacetSurface.hpp"
41 : : #include "FacetShell.hpp"
42 : : #include "FacetLump.hpp"
43 : : #include "FacetBody.hpp"
44 : : #include "CubitFacetEdge.hpp"
45 : : #include "CubitFacetEdgeData.hpp"
46 : : #include "CubitFacet.hpp"
47 : : #include "CubitFacetData.hpp"
48 : : #include "CubitQuadFacet.hpp"
49 : : #include "CubitQuadFacetData.hpp"
50 : : #include "CubitPoint.hpp"
51 : : #include "GMem.hpp"
52 : : #include "FacetEvalTool.hpp"
53 : : #include "CurveFacetEvalTool.hpp"
54 : : #include "CubitPointData.hpp"
55 : : #include "GeometryQueryTool.hpp"
56 : : #include "ChollaDebug.hpp"
57 : : #include "CubitObserver.hpp"
58 : : #include "ChollaEngine.hpp"
59 : : #include "ChollaSurface.hpp"
60 : : #include "ChollaCurve.hpp"
61 : : #include "ChollaPoint.hpp"
62 : : #include "Cholla.h"
63 : : #include "CubitFileIOWrapper.hpp"
64 : : #include "CCubitFile.hpp"
65 : : #include "TDFacetBoundaryPoint.hpp"
66 : : #include "GfxDebug.hpp"
67 : : #include "KDDTree.hpp"
68 : : #include "RTree.hpp"
69 : : #include "FacetDataUtil.hpp"
70 : : #include "GridSearchTree.hpp"
71 : : #include <stdio.h>
72 : : #include <errno.h>
73 : : #include "GeometryModifyTool.hpp"
74 : : #include "BodySM.hpp"
75 : : #include "AppUtil.hpp"
76 : : #include "ProgressTool.hpp"
77 : : #include "CubitOctreeGeneratorVolumes.hpp"
78 : : #include "GfxDebug.hpp"
79 : :
80 : : using namespace NCubitFile;
81 : :
82 : : FacetQueryEngine* FacetQueryEngine::instance_ = NULL;
83 : : int FacetQueryEngine::hashPointSize = 0;
84 : : DLIList<CubitPoint*> *FacetQueryEngine::hashPointArray = NULL;
85 : :
86 : : const int FacetQueryEngine::FQE_MAJOR_VERSION = 10;
87 : : const int FacetQueryEngine::FQE_MINOR_VERSION = 0;
88 : : const int FacetQueryEngine::FQE_SUBMINOR_VERSION = 0;
89 : :
90 : : struct ContainmentPoint
91 : : {
92 : : CubitVector *pt_coordinates;
93 : : int index;
94 : 0 : CubitBox bounding_box() { return CubitBox( *pt_coordinates); }
95 : : };
96 : :
97 : : //================================================================================
98 : : // Description:
99 : : // Author :
100 : : // Date :
101 : : //================================================================================
102 : 918 : FacetQueryEngine* FacetQueryEngine::instance()
103 : : {
104 [ + + ]: 918 : if (instance_ == NULL ) {
105 [ + - ]: 874 : instance_ = new FacetQueryEngine;
106 : : }
107 : 918 : return instance_;
108 : : }
109 : :
110 : : //================================================================================
111 : : // Description: default constructor
112 : : // Author :
113 : : // Date :
114 : : //================================================================================
115 : 1748 : FacetQueryEngine::FacetQueryEngine()
116 : : {
117 [ + - ][ + - ]: 874 : GeometryQueryTool::instance()->add_gqe( this );
118 : 874 : }
119 : :
120 : : //================================================================================
121 : : // Description: destructor
122 : : // Author :
123 : : // Date :
124 : : //================================================================================
125 : 813 : FacetQueryEngine::~FacetQueryEngine()
126 : : {
127 : 271 : instance_ = NULL;
128 [ - + ]: 542 : }
129 : :
130 : 0 : void FacetQueryEngine::delete_instance()
131 : : {
132 [ # # ]: 0 : if( NULL != instance_ )
133 : : {
134 [ # # ]: 0 : delete instance_;
135 : 0 : instance_ = NULL;
136 : : }
137 : 0 : }
138 : :
139 : :
140 : :
141 : : //================================================================================
142 : : // Description: can_delete_bodies
143 : : // Author : sjowen
144 : : // Date : 4/25/02
145 : : //================================================================================
146 : 0 : CubitBoolean FacetQueryEngine::can_delete_bodies(DLIList<Body*>body_list)
147 : : {
148 : 0 : CubitBoolean delete_ok = CUBIT_TRUE;
149 : : int ii;
150 [ # # ][ # # ]: 0 : for (ii=0; ii<body_list.size() && delete_ok; ii++)
[ # # ]
151 : : {
152 : 0 : Body *body_ptr = body_list.get_and_step();
153 : : // Extract the BODY from Body
154 [ # # ]: 0 : FacetBody* fbody_ptr = CAST_TO(body_ptr->get_body_sm_ptr(), FacetBody);
155 [ # # ]: 0 : if (fbody_ptr)
156 : : {
157 : 0 : delete_ok = fbody_ptr->can_be_deleted(body_list);
158 : : }
159 : : }
160 : 0 : return delete_ok;
161 : : }
162 : :
163 : 22 : int FacetQueryEngine::get_major_version()
164 : : {
165 : 22 : return FQE_MAJOR_VERSION;
166 : : }
167 : :
168 : 22 : int FacetQueryEngine::get_minor_version()
169 : : {
170 : 22 : return FQE_MINOR_VERSION;
171 : : }
172 : :
173 : 22 : int FacetQueryEngine::get_subminor_version()
174 : : {
175 : 22 : return FQE_SUBMINOR_VERSION;
176 : : }
177 : :
178 : 22 : CubitString FacetQueryEngine::get_engine_version_string()
179 : : {
180 : 22 : CubitString version_string = "Facet Geometry Engine version ";
181 [ + - ][ + - ]: 22 : version_string += CubitString::number(get_major_version());
[ + - ][ + - ]
182 [ + - ][ + - ]: 22 : version_string += CubitString(".");
[ + - ]
183 [ + - ][ + - ]: 22 : version_string += CubitString::number(get_minor_version());
[ + - ][ + - ]
184 [ + - ][ + - ]: 22 : version_string += CubitString(".");
[ + - ]
185 [ + - ][ + - ]: 22 : version_string += CubitString::number(get_subminor_version());
[ + - ][ + - ]
186 : :
187 : 22 : return version_string;
188 : : }
189 : :
190 : : //================================================================================
191 : : // Description:
192 : : // Author :
193 : : // Date :
194 : : //================================================================================
195 : 0 : const std::type_info& FacetQueryEngine::entity_type_info() const
196 : : {
197 : 0 : return typeid(*this);
198 : : }
199 : :
200 : : //================================================================================
201 : : // Description:
202 : : // Author :
203 : : // Date :
204 : : //================================================================================
205 : 0 : TBPoint* FacetQueryEngine::make_Point( GeometryType ,
206 : : CubitVector const& ) const
207 : : {
208 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
209 : 0 : return (TBPoint*) NULL;
210 : : }
211 : :
212 : : //================================================================================
213 : : // Description:
214 : : // Author :
215 : : // Date :
216 : : //================================================================================
217 : 0 : Curve* FacetQueryEngine::make_Curve(Curve *) const
218 : : {
219 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
220 : 0 : return (Curve*) NULL;
221 : : }
222 : :
223 : : //================================================================================
224 : : // Description:
225 : : // Author :
226 : : // Date :
227 : : //================================================================================
228 : 0 : Curve* FacetQueryEngine::make_Curve( TBPoint const* ,
229 : : TBPoint const* ,
230 : : RefFace* ,
231 : : CubitVector * ) const
232 : : {
233 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
234 : 0 : return (Curve*) NULL;
235 : : }
236 : :
237 : : //================================================================================
238 : : // Description:
239 : : // Author :
240 : : // Date :
241 : : //================================================================================
242 : 0 : Curve* FacetQueryEngine::make_Curve( GeometryType ,
243 : : TBPoint const* ,
244 : : TBPoint const* ,
245 : : DLIList<CubitVector*>& ,
246 : : RefFace* ) const
247 : : {
248 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
249 : 0 : return (Curve*) NULL;
250 : : }
251 : :
252 : : //================================================================================
253 : : // Description:
254 : : // Author :
255 : : // Date :
256 : : //================================================================================
257 : 0 : Curve* FacetQueryEngine::make_Curve( GeometryType ,
258 : : TBPoint const* ,
259 : : TBPoint const* ,
260 : : CubitVector const* ,
261 : : CubitSense ) const
262 : : {
263 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
264 : 0 : return (Curve*) NULL;
265 : : }
266 : :
267 : : //================================================================================
268 : : // Description:
269 : : // Author :
270 : : // Date :
271 : : //================================================================================
272 : 0 : Surface* FacetQueryEngine::make_Surface( Surface *,
273 : : DLIList<Loop*> &,
274 : : CubitBoolean ) const
275 : : {
276 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
277 : 0 : return (Surface*) NULL;
278 : : }
279 : :
280 : : //================================================================================
281 : : // Description:
282 : : // Author :
283 : : // Date :
284 : : //================================================================================
285 : 0 : Surface* FacetQueryEngine::make_Surface( GeometryType ,
286 : : DLIList<Curve*>& ,
287 : : DLIList<Loop*> &,
288 : : Surface *) const
289 : : {
290 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
291 : 0 : return (Surface*) NULL;
292 : : }
293 : :
294 : : //================================================================================
295 : : // Description:
296 : : // Author :
297 : : // Date :
298 : : //================================================================================
299 : 0 : Lump* FacetQueryEngine::make_Lump( GeometryType ,
300 : : DLIList<Surface*>& ) const
301 : : {
302 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
303 : 0 : return (Lump*) NULL;
304 : : }
305 : :
306 : : //================================================================================
307 : : // Description:
308 : : // Author :
309 : : // Date :
310 : : //================================================================================
311 : 0 : BodySM* FacetQueryEngine::make_BodySM( Surface * ) const
312 : : {
313 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
314 : 0 : return (BodySM*) NULL;
315 : : }
316 : :
317 : : //================================================================================
318 : : // Description:
319 : : // Author :
320 : : // Date :
321 : : //================================================================================
322 : 0 : BodySM* FacetQueryEngine::make_BodySM( DLIList<Lump*>& ) const
323 : : {
324 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
325 : 0 : return (BodySM*) NULL;
326 : : }
327 : :
328 : : //================================================================================
329 : : // Description: create a new body by copying
330 : : // Author : sjowen
331 : : // Date : 9/7/01
332 : : //================================================================================
333 : 0 : Body* FacetQueryEngine::copy_body( Body *body_ptr )
334 : : {
335 [ # # ]: 0 : BodySM* bodysm_ptr = body_ptr->get_body_sm_ptr();
336 [ # # ]: 0 : FacetBody *facet_body_ptr = CAST_TO(bodysm_ptr, FacetBody);
337 [ # # ]: 0 : if (!facet_body_ptr)
338 : : {
339 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempt to copy mesh-based geometry Body. This body is not MBG.");
[ # # ][ # # ]
340 : 0 : return (Body*)NULL;
341 : : }
342 : :
343 : : TopologyBridge *top_bridge;
344 [ # # ][ # # ]: 0 : GeometryModifyTool::instance()->prepare_for_copy( body_ptr, top_bridge );
[ # # ]
345 : :
346 [ # # ]: 0 : BodySM* osme_body_ptr = (BodySM*)facet_body_ptr->copy();
347 [ # # ]: 0 : if (!osme_body_ptr)
348 : : {
349 [ # # ][ # # ]: 0 : GeometryModifyTool::instance()->clean_up_from_copy_failure( top_bridge );
350 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to copy mesh-based geometry Body");
[ # # ][ # # ]
351 : 0 : return (Body*)NULL;
352 : : }
353 : :
354 : 0 : TopologyBridge *tb = (TopologyBridge*)osme_body_ptr;
355 [ # # ][ # # ]: 0 : GeometryModifyTool::instance()->finish_copy( tb, bodysm_ptr );
356 : :
357 [ # # ][ # # ]: 0 : Body *new_body_ptr = GeometryQueryTool::instance()->make_Body( osme_body_ptr );
358 : 0 : return new_body_ptr;
359 : : }
360 : :
361 : : //================================================================================
362 : : // Description: reflect body about an axis
363 : : // Author : sjowen
364 : : // Date : 9/7/01
365 : : //================================================================================
366 : 0 : CubitStatus FacetQueryEngine::reflect( BodySM *bodysm,
367 : : const CubitVector& axis)
368 : : {
369 [ # # ]: 0 : FacetBody *fbody = CAST_TO(bodysm, FacetBody);
370 [ # # ]: 0 : if (!fbody)
371 : : {
372 [ # # ][ # # ]: 0 : PRINT_ERROR("Attempt to reflect mesh-based geometry Body. This body is not MBG.");
373 : 0 : return CUBIT_FAILURE;
374 : : }
375 : :
376 : 0 : fbody->reflect( axis.x(), axis.y(), axis.z() );
377 : :
378 : 0 : return CUBIT_SUCCESS;
379 : : }
380 : :
381 : 0 : CubitStatus FacetQueryEngine::get_connected_patch(
382 : : DLIList<FacetSurface*>& remaining_surfs,
383 : : DLIList<FacetSurface*>& output_patch )
384 : : {
385 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> stack, curve_surfs;
[ # # ]
386 [ # # ][ # # ]: 0 : std::set<FacetSurface*> marked;
387 [ # # ][ # # ]: 0 : DLIList<FacetCurve*> curves;
388 : 0 : int debug_this = 0;
389 [ # # ]: 0 : if(debug_this){
390 [ # # ]: 0 : GfxDebug::clear();
391 : : }
392 : : int i;
393 [ # # ][ # # ]: 0 : for (i = remaining_surfs.size(); i--; )
394 [ # # ][ # # ]: 0 : marked.insert( remaining_surfs.get_and_step() );
395 : :
396 : : // Choose one surface to start with
397 [ # # ]: 0 : FacetSurface* surf = remaining_surfs.pop();
398 [ # # ]: 0 : marked.erase( surf );
399 [ # # ]: 0 : stack.append( surf );
400 : :
401 : : // Get all connected surfaces
402 [ # # ][ # # ]: 0 : while( stack.size() )
403 : : {
404 [ # # ]: 0 : surf = stack.pop();
405 [ # # ]: 0 : if(debug_this){
406 [ # # ][ # # ]: 0 : surf->get_eval_tool()->debug_draw_facets(CUBIT_BLUE_INDEX);
407 [ # # ]: 0 : GfxDebug::mouse_xforms();
408 : : }
409 [ # # ]: 0 : output_patch.append( surf );
410 : :
411 [ # # ]: 0 : surf->get_curves( curves );
412 [ # # ][ # # ]: 0 : while (curves.size())
413 : : {
414 [ # # ]: 0 : FacetCurve* curve = curves.pop();
415 [ # # ]: 0 : curve->get_surfaces( curve_surfs );
416 [ # # ][ # # ]: 0 : if(debug_this && curve_surfs.size() < 2){
[ # # ][ # # ]
417 [ # # ][ # # ]: 0 : PRINT_INFO("Curve is not connected to 2 surfaces.\n");
[ # # ][ # # ]
418 [ # # ][ # # ]: 0 : curve->get_eval_tool()->debug_draw_facet_edges(CUBIT_MAGENTA_INDEX);
419 : : }
420 : :
421 : :
422 [ # # ][ # # ]: 0 : while (curve_surfs.size())
423 : : {
424 [ # # ]: 0 : FacetSurface* curve_surf = curve_surfs.pop();
425 [ # # ][ # # ]: 0 : if (marked.erase(curve_surf))
426 [ # # ]: 0 : stack.append( curve_surf );
427 : : }
428 : : }
429 : : }
430 : :
431 : : // Remove output surfaces from input list
432 : : // At this point, "marked" contains all the surfaces not in "ouput_patch"
433 [ # # ]: 0 : remaining_surfs.last();
434 [ # # ][ # # ]: 0 : for (i = remaining_surfs.size(); i--; )
435 [ # # ][ # # ]: 0 : if (marked.find(remaining_surfs.step_and_get()) == marked.end())
[ # # ][ # # ]
[ # # ]
436 [ # # ]: 0 : remaining_surfs.change_to( 0 );
437 [ # # ]: 0 : remaining_surfs.remove_all_with_value( 0 );
438 : :
439 [ # # ]: 0 : return CUBIT_SUCCESS;
440 : :
441 : : }
442 : :
443 : 0 : CubitStatus FacetQueryEngine::get_graphics( BodySM *bodysm, GMem* g_mem,
444 : : std::vector<Surface*> &surface_to_facets_vector,
445 : : std::vector<TopologyBridge*> &vertex_edge_to_point_vector,
446 : : std::vector<std::pair<TopologyBridge*, std::pair<int,int> > > &facet_edges_on_curves,
447 : : unsigned short normal_tolerance,
448 : : double distance_tolerance, double max_edge_length ) const
449 : : {
450 [ # # ]: 0 : FacetBody *facet_body = CAST_TO(bodysm, FacetBody );
451 [ # # ]: 0 : if( NULL == facet_body )
452 : 0 : return CUBIT_FAILURE;
453 : :
454 [ # # ]: 0 : DLIList<Surface*> surfaces;
455 [ # # ]: 0 : bodysm->surfaces( surfaces );
456 : :
457 : : //unmark all the points
458 [ # # ][ # # ]: 0 : for( int i=surfaces.size(); i--; )
459 : : {
460 [ # # ]: 0 : Surface *tmp_surf = surfaces.get_and_step();
461 [ # # ]: 0 : FacetSurface *facet_surface = CAST_TO( tmp_surf, FacetSurface );
462 : :
463 [ # # ]: 0 : DLIList<CubitPoint*> surface_points;
464 [ # # ]: 0 : facet_surface->get_my_points( surface_points );
465 : :
466 [ # # ][ # # ]: 0 : for( int k=surface_points.size(); k--; )
467 [ # # ][ # # ]: 0 : surface_points.get_and_step()->marked(0);
468 [ # # ]: 0 : }
469 : :
470 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> all_facets;
471 : 0 : int point_index = 0;
472 [ # # ][ # # ]: 0 : std::vector<CubitPoint*> all_points;
473 [ # # ][ # # ]: 0 : for( int i=surfaces.size(); i--; )
474 : : {
475 [ # # ]: 0 : Surface *tmp_surf = surfaces.get_and_step();
476 [ # # ]: 0 : FacetSurface *facet_surface = CAST_TO( tmp_surf, FacetSurface );
477 : :
478 [ # # ]: 0 : DLIList<CubitFacet*> surface_facets;
479 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> surface_points;
480 [ # # ]: 0 : facet_surface->get_my_facets(surface_facets, surface_points);
481 : :
482 [ # # ]: 0 : surface_facets.reset();
483 [ # # ]: 0 : all_facets += surface_facets;
484 : :
485 [ # # ][ # # ]: 0 : for( int k=surface_points.size(); k--; )
486 : : {
487 [ # # ]: 0 : CubitPoint *tmp_pt = surface_points.get_and_step();
488 [ # # ][ # # ]: 0 : if( tmp_pt->marked() == 0 )
489 : : {
490 [ # # ]: 0 : all_points.push_back( tmp_pt );
491 : 0 : point_index++;
492 [ # # ]: 0 : tmp_pt->marked( point_index );
493 [ # # ]: 0 : vertex_edge_to_point_vector.push_back( tmp_surf );
494 : : }
495 : : }
496 : :
497 [ # # ]: 0 : surface_facets.reset();
498 [ # # ][ # # ]: 0 : for( int k=surface_facets.size(); k--; )
499 [ # # ]: 0 : surface_to_facets_vector.push_back( tmp_surf );
500 [ # # ]: 0 : }
501 : :
502 : : //now stuff them into the g_mem
503 [ # # ][ # # ]: 0 : g_mem->allocate_tri( all_facets.size() );
504 [ # # ]: 0 : g_mem->fListCount = all_facets.size() * 4;
505 [ # # ]: 0 : g_mem->pointListCount = all_points.size();
506 : :
507 [ # # ]: 0 : GPoint* pt_itor = g_mem->point_list();
508 [ # # ][ # # ]: 0 : for ( size_t i = 0; i < all_points.size(); i++ )
509 : : {
510 [ # # ]: 0 : CubitPoint* point = all_points[i];
511 [ # # ]: 0 : pt_itor->x = (float)point->x();
512 [ # # ]: 0 : pt_itor->y = (float)point->y();
513 [ # # ]: 0 : pt_itor->z = (float)point->z();
514 : 0 : pt_itor++;
515 : : }
516 : :
517 : : // Copy facets to Gmem
518 [ # # ]: 0 : all_facets.reset();
519 [ # # ]: 0 : int* f_itor = g_mem->facet_list();
520 [ # # ][ # # ]: 0 : for ( int i = 0; i < all_facets.size(); i++ )
521 : : {
522 : 0 : *(f_itor++) = 3;
523 [ # # ]: 0 : CubitFacet* facet = all_facets.get_and_step();
524 [ # # ]: 0 : for ( int j = 0; j < 3; j++ )
525 : : {
526 [ # # ][ # # ]: 0 : *(f_itor++) = facet->point(j)->marked() - 1; //go back to zero-based
527 : : }
528 : : }
529 : :
530 : : //get all the curves
531 [ # # ][ # # ]: 0 : DLIList<Curve*> curves;
532 [ # # ]: 0 : bodysm->curves( curves );
533 [ # # ][ # # ]: 0 : for( int i=curves.size(); i--; )
534 : : {
535 [ # # ]: 0 : Curve *tmp_curve = curves.get_and_step();
536 [ # # ]: 0 : FacetCurve *facet_curve = CAST_TO( tmp_curve, FacetCurve );
537 : :
538 : : //get all the curves
539 [ # # ]: 0 : DLIList<CubitFacetEdge*> curve_facets;
540 [ # # ]: 0 : facet_curve->get_facets(curve_facets);
541 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> curve_points;
542 [ # # ]: 0 : facet_curve->get_points(curve_points);
543 [ # # ]: 0 : curve_points.reset();
544 [ # # ]: 0 : curve_facets.reset();
545 : :
546 [ # # ][ # # ]: 0 : for( int k=0; k<curve_points.size(); k++ )
547 : : {
548 [ # # ]: 0 : CubitPoint *tmp_pt = curve_points.get_and_step();
549 [ # # ][ # # ]: 0 : assert( tmp_pt->marked() );
550 : :
551 [ # # ][ # # ]: 0 : if( k == curve_points.size() - 1 )
552 : 0 : break;
553 : :
554 [ # # ]: 0 : int index1 = tmp_pt->marked();
555 [ # # ][ # # ]: 0 : int index2 = curve_points.get()->marked();
556 : :
557 [ # # ]: 0 : vertex_edge_to_point_vector[index1-1] = tmp_curve;
558 [ # # ][ # # ]: 0 : facet_edges_on_curves.push_back( std::make_pair( tmp_curve, std::make_pair( index1-1, index2-1) ) );
[ # # ][ # # ]
559 : : }
560 [ # # ]: 0 : }
561 : :
562 : : //get all the vertices
563 [ # # ][ # # ]: 0 : DLIList<TBPoint*> points;
564 [ # # ]: 0 : bodysm->points( points );
565 : :
566 [ # # ][ # # ]: 0 : for( int i=points.size(); i--; )
567 : : {
568 [ # # ]: 0 : TBPoint *tmp_pt = points.get_and_step();
569 [ # # ]: 0 : FacetPoint *facet_point = CAST_TO( tmp_pt, FacetPoint );
570 [ # # ]: 0 : CubitPoint *cubit_pt = facet_point->get_cubit_point();
571 [ # # ][ # # ]: 0 : assert( cubit_pt->marked() );
572 [ # # ][ # # ]: 0 : vertex_edge_to_point_vector[cubit_pt->marked()-1] = tmp_pt;
573 : : }
574 : :
575 : :
576 : : //reset the marks back to zero
577 [ # # ][ # # ]: 0 : for ( unsigned int i = 0; i < all_points.size(); i++ )
578 [ # # ][ # # ]: 0 : all_points[i]->marked(0);
579 : :
580 : :
581 [ # # ]: 0 : return CUBIT_SUCCESS;
582 : : }
583 : :
584 : : //================================================================================
585 : : // Description:
586 : : // Author :
587 : : // Date :
588 : : //================================================================================
589 : 0 : CubitStatus FacetQueryEngine::get_graphics( Surface* surface_ptr,
590 : : GMem* gMem,
591 : : unsigned short ,
592 : : double, double ) const
593 : : {
594 [ # # ]: 0 : if( !gMem )
595 : 0 : return CUBIT_FAILURE;
596 : :
597 : : // get the FacetSurface.
598 : : int i;
599 [ # # ]: 0 : FacetSurface *facet_surf_ptr = CAST_TO(surface_ptr,FacetSurface);
600 [ # # ]: 0 : if( ! facet_surf_ptr )
601 : 0 : return CUBIT_FAILURE;
602 : :
603 : : // get the facets for the surface
604 [ # # ]: 0 : DLIList<CubitFacet*> surface_facets;
605 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> surface_points;
606 [ # # ]: 0 : facet_surf_ptr->get_my_facets(surface_facets, surface_points);
607 : :
608 : : // set return values, and if GMem is NULL return
609 : : // (caller just wanted to know the counts.)
610 [ # # ]: 0 : int number_points = surface_points.size();
611 [ # # ]: 0 : int number_triangles = surface_facets.size();
612 : :
613 : :
614 : : // Allocate space in GMem
615 [ # # ]: 0 : gMem->allocate_tri(number_triangles);
616 [ # # ]: 0 : gMem->fListCount = surface_facets.size() * 4;
617 : 0 : gMem->pointListCount = number_points;
618 : :
619 : : // Copy points to GMem
620 [ # # ]: 0 : surface_points.reset();
621 [ # # ]: 0 : GPoint* pt_itor = gMem->point_list();
622 [ # # ]: 0 : for ( i = 0; i < number_points; i++ )
623 : : {
624 [ # # ]: 0 : CubitPoint* point = surface_points.get_and_step();
625 [ # # ]: 0 : pt_itor->x = (float)point->x();
626 [ # # ]: 0 : pt_itor->y = (float)point->y();
627 [ # # ]: 0 : pt_itor->z = (float)point->z();
628 [ # # ]: 0 : point->marked(i);
629 : 0 : pt_itor++;
630 : : }
631 : :
632 : : // Copy facets to Gmem
633 [ # # ]: 0 : surface_facets.reset();
634 [ # # ]: 0 : int* f_itor = gMem->facet_list();
635 [ # # ]: 0 : for ( i = 0; i < number_triangles; i++ )
636 : : {
637 : 0 : *(f_itor++) = 3;
638 [ # # ]: 0 : CubitFacet* facet = surface_facets.get_and_step();
639 [ # # ]: 0 : for ( int j = 0; j < 3; j++ )
640 [ # # ][ # # ]: 0 : *(f_itor++) = facet->point(j)->marked();
641 : : }
642 : :
643 : : // cleanup
644 [ # # ][ # # ]: 0 : while( surface_points.size() )
645 [ # # ][ # # ]: 0 : surface_points.pop()->marked(0);
646 : :
647 [ # # ]: 0 : return CUBIT_SUCCESS;
648 : : }
649 : :
650 : : //================================================================================
651 : : // Description:
652 : : // Author :
653 : : // Date :
654 : : //================================================================================
655 : 0 : CubitStatus FacetQueryEngine::get_graphics( Curve* curve_ptr,
656 : : GMem* gMem,
657 : : double /*angle_tolerance*/,
658 : : double /*distance_tolerance*/,
659 : : double /*max_edge_length*/ ) const
660 : : {
661 : : // get the FacetCurve.
662 [ # # ]: 0 : FacetCurve *facet_curv_ptr = CAST_TO(curve_ptr,FacetCurve);
663 : :
664 [ # # ]: 0 : DLIList<CubitFacetEdge*> curve_facets;
665 [ # # ]: 0 : facet_curv_ptr->get_facets(curve_facets);
666 [ # # ]: 0 : int number_facets = curve_facets.size();
667 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> curve_points;
668 [ # # ]: 0 : facet_curv_ptr->get_points(curve_points);
669 [ # # ]: 0 : curve_points.reset();
670 [ # # ]: 0 : curve_facets.reset();
671 [ # # ]: 0 : int num_points = curve_points.size();
672 [ # # ][ # # ]: 0 : GPoint *new_point_list = new GPoint[num_points];
673 [ # # ][ # # ]: 0 : int *new_facet_list = new int [number_facets*3];
674 : : int ii;
675 : : CubitPoint *cur_pnt;
676 [ # # ]: 0 : for ( ii = 0; ii < num_points; ii++ )
677 : : {
678 [ # # ]: 0 : cur_pnt = curve_points.get();
679 [ # # ]: 0 : new_point_list[ii].x = cur_pnt->x();
680 [ # # ]: 0 : new_point_list[ii].y = cur_pnt->y();
681 [ # # ]: 0 : new_point_list[ii].z = cur_pnt->z();
682 : : //mark the point with the index into the point list.
683 : : //This is very important to make sure we can index these
684 : : //points when we do the facet array.
685 [ # # ][ # # ]: 0 : curve_points.get_and_step()->marked(ii);
686 : : }
687 [ # # ]: 0 : for ( ii = 0; ii < number_facets; ii++ )
688 : : {
689 : : //All our facets are segments. So the first value is 2.
690 : 0 : int index_count = 3*ii;
691 : 0 : new_facet_list[index_count] = 2;
692 : 0 : int jj = index_count + 1;
693 : : int ll, kk;
694 [ # # ]: 0 : CubitFacetEdge *facet_ptr = curve_facets.get_and_step();
695 : : CubitPoint *temp_point;
696 [ # # ]: 0 : for ( kk = jj, ll = 0; kk < jj+2; kk++, ll++)
697 : : {
698 [ # # ]: 0 : temp_point = facet_ptr->point(ll);
699 [ # # ]: 0 : int index_to_point = temp_point->marked();
700 [ # # ][ # # ]: 0 : if ( index_to_point < 0 || index_to_point > num_points )
701 : : {
702 [ # # ][ # # ]: 0 : PRINT_ERROR("Bad logic in converting edge facets to drawing facets.\n");
[ # # ][ # # ]
703 [ # # ]: 0 : delete[] new_point_list;
704 [ # # ]: 0 : delete[] new_facet_list;
705 : 0 : return CUBIT_FAILURE;
706 : : }
707 : 0 : new_facet_list[kk] = index_to_point;
708 : : }
709 : : }
710 [ # # ]: 0 : gMem->replace_point_list(new_point_list, num_points, num_points);
711 [ # # ]: 0 : gMem->replace_facet_list(new_facet_list, number_facets*3, number_facets*3);
712 [ # # ]: 0 : gMem->points_consolidated(CUBIT_TRUE);
713 : :
714 [ # # ]: 0 : return CUBIT_SUCCESS;
715 : : }
716 : :
717 : : //================================================================================
718 : : // Description:
719 : : // Author :
720 : : // Date :
721 : : //================================================================================
722 : 0 : CubitStatus FacetQueryEngine::get_isoparametric_points(Surface* ,
723 : : int &nu, int &nv,
724 : : GMem*&) const
725 : : {
726 : 0 : nu = nv = 0;
727 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
728 : 0 : return CUBIT_FAILURE;
729 : : }
730 : :
731 : 0 : CubitStatus FacetQueryEngine::get_u_isoparametric_points(Surface* ,
732 : : double, int&,
733 : : GMem*&) const
734 : : {
735 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
736 : 0 : return CUBIT_FAILURE;
737 : : }
738 : :
739 : 0 : CubitStatus FacetQueryEngine::get_v_isoparametric_points(Surface* ,
740 : : double, int&,
741 : : GMem*&) const
742 : : {
743 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
744 : 0 : return CUBIT_FAILURE;
745 : : }
746 : :
747 : : //================================================================================
748 : : // Description:
749 : : // Author :
750 : : // Date :
751 : : //================================================================================
752 : 0 : CubitStatus FacetQueryEngine::transform_vec_position( CubitVector const& ,
753 : : BodySM *,
754 : : CubitVector & ) const
755 : : {
756 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
757 : 0 : return CUBIT_FAILURE;
758 : : }
759 : :
760 : : //================================================================================
761 : : // Description:
762 : : // Author :
763 : : // Date :
764 : : //================================================================================
765 : 0 : CubitStatus FacetQueryEngine::get_intersections( Curve* , CubitVector& ,
766 : : CubitVector&,
767 : : DLIList<CubitVector>& ,
768 : : CubitBoolean,
769 : : CubitBoolean )
770 : : {
771 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
772 : 0 : return CUBIT_FAILURE;
773 : : }
774 : :
775 : 0 : CubitStatus FacetQueryEngine::get_intersections( Curve* , Curve* ,
776 : : DLIList<CubitVector>& ,
777 : : CubitBoolean,
778 : : CubitBoolean )
779 : : {
780 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
781 : 0 : return CUBIT_FAILURE;
782 : : }
783 : 0 : CubitStatus FacetQueryEngine::get_intersections( Curve*,
784 : : Curve*,
785 : : DLIList<CubitVector>&,
786 : : double, CubitBoolean )
787 : : {
788 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
789 : 0 : return CUBIT_FAILURE;
790 : : }
791 : :
792 : : CubitStatus
793 : 0 : FacetQueryEngine::get_intersections( Curve* /*ref_edge*/, Surface* /*ref_face*/,
794 : : DLIList<CubitVector>& ,
795 : : CubitBoolean )
796 : : {
797 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
798 : 0 : return CUBIT_FAILURE;
799 : : }
800 : :
801 : : //================================================================================
802 : : // Description: Find extrema position on an entity list
803 : : // Author :
804 : : // Date :
805 : : //================================================================================
806 : : CubitStatus
807 : 0 : FacetQueryEngine::entity_extrema( DLIList<GeometryEntity*> &,
808 : : const CubitVector *,
809 : : const CubitVector *,
810 : : const CubitVector *,
811 : : CubitVector &,
812 : : GeometryEntity *& )
813 : : {
814 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
815 : 0 : return CUBIT_FAILURE;
816 : : }
817 : :
818 : : //================================================================================
819 : : // Description: Find distance between two entities and closest positions.
820 : : // Author :
821 : : // Date :
822 : : //================================================================================
823 : : CubitStatus
824 : 0 : FacetQueryEngine::entity_entity_distance( GeometryEntity *,
825 : : GeometryEntity *,
826 : : CubitVector &, CubitVector &,
827 : : double & )
828 : : {
829 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
830 : 0 : return CUBIT_FAILURE;
831 : : }
832 : :
833 : : //===========================================================================
834 : : //Function Name: save_temp_geom_file
835 : : //Member Type: PUBLIC
836 : : //Description: function called for save/restore to save temporary FACET file
837 : : // If file is created, CubitString 'created_file' and
838 : : // 'create_file_type' are set
839 : : //Author: Corey Ernst
840 : : //Date: 1/18/2003
841 : : //===========================================================================
842 : :
843 : 0 : CubitStatus FacetQueryEngine::save_temp_geom_file( DLIList<TopologyBridge*>& ref_entity_list,
844 : : const char *file_name,
845 : : const CubitString &cubit_version,
846 : : CubitString &created_file,
847 : : CubitString &created_file_type)
848 : : {
849 [ # # ]: 0 : int size_before = ref_entity_list.size();
850 [ # # ]: 0 : CubitString temp_filename(file_name);
851 [ # # ][ # # ]: 0 : temp_filename += ".mbg";
[ # # ]
852 : :
853 [ # # ][ # # ]: 0 : ModelExportOptions export_options;
854 : :
855 [ # # ]: 0 : if( export_solid_model( ref_entity_list, temp_filename.c_str(), FACET_TYPE,
856 [ # # ][ # # ]: 0 : cubit_version, export_options ) == CUBIT_FAILURE )
857 : : {
858 [ # # ][ # # ]: 0 : PRINT_ERROR( "Error occured while trying to save temporary MESH_BASED_GEOMETRY file\n");
[ # # ][ # # ]
859 : 0 : return CUBIT_FAILURE;
860 : : }
861 : :
862 [ # # ]: 0 : int size_after = ref_entity_list.size();
863 : :
864 [ # # ]: 0 : if( size_before > size_after )
865 : : {
866 [ # # ]: 0 : created_file += temp_filename;
867 [ # # ][ # # ]: 0 : created_file_type += "FACET";
[ # # ]
868 : : }
869 [ # # ]: 0 : return CUBIT_SUCCESS;
870 : : }
871 : :
872 : : //===========================================================================
873 : : //Function Name:export_solid_model
874 : : //Member Type: PUBLIC
875 : : //Description: function called for save/restore to save temporary FACET file
876 : : //Author: Corey Ernst
877 : : //Date: 1/18/2003
878 : : //===========================================================================
879 : :
880 : 55 : CubitStatus FacetQueryEngine::export_solid_model( DLIList<TopologyBridge*>& ref_entity_list,
881 : : const char* file_name,
882 : : Model_File_Type file_type,
883 : : const CubitString &,
884 : : ModelExportOptions & )
885 : : {
886 [ - + ]: 55 : if( file_type != FACET_TYPE )
887 : 0 : return CUBIT_SUCCESS;
888 : :
889 [ + - ]: 55 : DLIList<FacetBody*> facet_bodies;
890 [ + - ][ + - ]: 110 : DLIList<FacetLump*> facet_lumps;
891 [ + - ][ + - ]: 110 : DLIList<FacetShell*> facet_shells;
892 [ + - ][ + - ]: 110 : DLIList<FacetSurface*> facet_surfaces;
893 [ + - ][ + - ]: 110 : DLIList<FacetLoop*> facet_loops;
894 [ + - ][ + - ]: 110 : DLIList<FacetCoEdge*> facet_coedges;
895 [ + - ][ + - ]: 110 : DLIList<FacetCurve*> facet_curves;
896 [ + - ][ + - ]: 110 : DLIList<FacetPoint*> facet_points;
897 : :
898 [ + - ][ + - ]: 110 : DLIList<TopologyBridge*> ref_entities_handled;
899 : :
900 : : int i;
901 : : //Collect all free entities (bodies, curves, vertices )
902 [ + - ]: 55 : ref_entity_list.reset();
903 [ + - ][ + + ]: 121 : for(i=ref_entity_list.size(); i>0; i--)
904 : : {
905 [ + - ]: 66 : TopologyBridge* ref_entity_ptr = ref_entity_list.get();
906 : 66 : CubitBoolean handled = CUBIT_TRUE;
907 : :
908 : : //if it is a Vertex
909 [ - + ][ - + ]: 66 : if( FacetPoint* pt = CAST_TO( ref_entity_ptr, FacetPoint) )
910 [ # # ]: 0 : facet_points.append( pt );
911 : : //if it is a Curve
912 [ - + ][ - + ]: 66 : else if( FacetCurve* curve = CAST_TO( ref_entity_ptr, FacetCurve) )
913 [ # # ]: 0 : facet_curves.append( curve );
914 : : /*
915 : : //if it is a Surface -- I don't think you can ever have a free surface
916 : : //without it being a Body
917 : : else if( FacetSurface* surf = CAST_TO( ref_entity_ptr, FacetSurface) )
918 : : facet_surfaces.append( surf );
919 : : */
920 : : //if it is a Body
921 [ - + ][ + - ]: 66 : else if( FacetBody* body = CAST_TO( ref_entity_ptr, FacetBody ) )
922 [ + - ]: 66 : facet_bodies.append( body );
923 : : else
924 : 66 : handled = CUBIT_FALSE;
925 : :
926 [ + - ]: 66 : if( handled == CUBIT_TRUE )
927 : : {
928 [ + - ]: 66 : ref_entities_handled.append( ref_entity_ptr );
929 [ + - ]: 66 : ref_entity_list.change_to(NULL);
930 : : }
931 : :
932 [ + - ]: 66 : ref_entity_list.step();
933 : : }
934 : :
935 [ + - ]: 55 : ref_entity_list.remove_all_with_value(NULL);
936 : :
937 [ + - ]: 55 : int free_body_count = facet_bodies.size();
938 [ + - ]: 55 : int free_curve_count = facet_curves.size();
939 [ + - ]: 55 : int free_point_count = facet_points.size();
940 : :
941 : : //if nothing to write out...return
942 [ - + ][ # # ]: 55 : if( free_body_count == 0 && free_curve_count == 0 && free_point_count == 0)
[ # # ]
943 : 0 : return CUBIT_SUCCESS;
944 : :
945 : : //get file pointer
946 [ + - ]: 55 : FILE *file_ptr = fopen( file_name, "wb" );
947 : :
948 : : //get all child entities from the bodies, curves, & vertices
949 : : gather_all_facet_entities( facet_bodies, facet_lumps,
950 : : facet_shells, facet_surfaces,
951 : : facet_loops, facet_coedges,
952 [ + - ]: 55 : facet_curves, facet_points );
953 : :
954 : : //create a wrapper object for writing
955 [ + - ][ + - ]: 110 : CIOWrapper file_writer( file_ptr );
956 : :
957 : : // write out file type "MESHED_BASED_GEOMETRY"
958 [ + - ]: 55 : file_writer.BeginWriteBlock(0);
959 [ + - ]: 55 : file_writer.Write( "MESH_BASED_GEOMETRY", 19 );
960 : :
961 : : // write out Endian value
962 : 55 : UnsignedInt32 endian_value = CCubitFile::mintNativeEndian;
963 [ + - ]: 55 : file_writer.Write( &endian_value, 1 );
964 : :
965 : : // write out version #
966 : 55 : UnsignedInt32 version = 1;
967 [ + - ]: 55 : file_writer.Write( &version, 1 );
968 : :
969 : :
970 : : //save the facets (geometry info )
971 : : CubitStatus status;
972 [ + - ][ + - ]: 55 : status = save_facets( file_ptr, facet_surfaces, facet_curves, facet_points );
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
973 [ - + ]: 55 : if( status == CUBIT_FAILURE ) return CUBIT_FAILURE;
974 : :
975 : : //write out topology and attributes
976 : : status = write_topology( file_ptr,
977 : : facet_bodies, facet_lumps,
978 : : facet_shells, facet_surfaces,
979 : : facet_loops, facet_coedges,
980 [ + - ]: 55 : facet_curves, facet_points );
981 [ - + ]: 55 : if( status == CUBIT_FAILURE ) return CUBIT_FAILURE;
982 : :
983 [ - + ][ # # ]: 55 : if( free_body_count || free_curve_count || free_point_count )
[ # # ]
984 [ + - ][ + - ]: 55 : PRINT_INFO( "\nExported:" );
[ + - ][ + - ]
985 : :
986 : 55 : int flg = 0;
987 : :
988 [ + - ]: 55 : if( free_body_count )
989 : : {
990 [ - + ][ # # ]: 55 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
991 [ + - ][ + - ]: 55 : if( DEBUG_FLAG( 153 ) )
[ - + ]
992 : : {
993 [ # # ]: 0 : if( free_body_count == 1 )
994 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Body\n", free_body_count );
[ # # ][ # # ]
995 : : else
996 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Bodies\n", free_body_count );
[ # # ][ # # ]
997 : : }
998 : :
999 [ + - ][ + + ]: 55 : if( facet_lumps.size() == 1 )
1000 [ + - ][ + - ]: 44 : PRINT_INFO( "%4d Facet Volume\n", facet_lumps.size() );
[ + - ][ + - ]
[ + - ]
1001 : : else
1002 [ + - ][ + - ]: 55 : PRINT_INFO( "%4d Facet Volumes\n", facet_lumps.size() );
[ + - ][ + - ]
[ + - ]
1003 : : }
1004 [ - + ]: 55 : if( free_curve_count )
1005 : : {
1006 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1007 [ # # ]: 0 : if( free_curve_count == 1 )
1008 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Curve\n", free_curve_count );
[ # # ][ # # ]
1009 : : else
1010 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Curves\n", free_curve_count );
[ # # ][ # # ]
1011 : : }
1012 [ - + ]: 55 : if( free_point_count )
1013 : : {
1014 [ # # ][ # # ]: 0 : if( flg )PRINT_INFO( " " );else flg=1;
[ # # ][ # # ]
[ # # ]
1015 [ # # ]: 0 : if( free_point_count == 1 )
1016 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Point\n", free_point_count );
[ # # ][ # # ]
1017 : : else
1018 [ # # ][ # # ]: 0 : PRINT_INFO( "%4d Facet Points\n", free_point_count );
[ # # ][ # # ]
1019 : : }
1020 [ + - ][ + - ]: 55 : PRINT_INFO( "\n" );
[ + - ][ + - ]
1021 : :
1022 : :
1023 : :
1024 [ + - ]: 55 : fclose( file_ptr );
1025 : :
1026 [ + - ]: 110 : return CUBIT_SUCCESS;
1027 : : }
1028 : :
1029 : : CubitStatus
1030 : 55 : FacetQueryEngine::gather_all_facet_entities( DLIList<FacetBody*> &facet_bodies,
1031 : : DLIList<FacetLump*> &facet_lumps,
1032 : : DLIList<FacetShell*> &facet_shells,
1033 : : DLIList<FacetSurface*> &facet_surfaces,
1034 : : DLIList<FacetLoop*> &facet_loops,
1035 : : DLIList<FacetCoEdge*> &facet_coedges,
1036 : : DLIList<FacetCurve*> &facet_curves,
1037 : : DLIList<FacetPoint*> &facet_points )
1038 : : {
1039 : : int i;
1040 : :
1041 : :
1042 : : //Collect FacetLumps from FacetBody
1043 [ + + ]: 121 : for(i=0; i<facet_bodies.size(); i++)
1044 : : {
1045 : 66 : FacetBody *facet_body = facet_bodies.get_and_step();
1046 : 66 : facet_body->get_lumps( facet_lumps );
1047 : : }
1048 : :
1049 : :
1050 : : //Collect FacetShells from FacetLumps
1051 [ + + ]: 121 : for(i=0; i<facet_lumps.size(); i++)
1052 : : {
1053 : 66 : FacetLump *facet_lump = facet_lumps.get_and_step();
1054 : 66 : facet_lump->get_shells( facet_shells );
1055 : : }
1056 : :
1057 : :
1058 : : //Collect FacetSurfaces from FacetShells
1059 [ + + ]: 121 : for(i=0; i<facet_shells.size(); i++)
1060 : : {
1061 : 66 : FacetShell *facet_shell = facet_shells.get_and_step();
1062 : 66 : facet_shell->get_surfaces( facet_surfaces );
1063 : : }
1064 : 55 : facet_surfaces.uniquify_ordered();
1065 : :
1066 : :
1067 : : //Collect FacetLoops from FacetSurfaces
1068 [ + + ]: 330 : for(i=0; i<facet_surfaces.size(); i++)
1069 : : {
1070 : 275 : FacetSurface *facet_surface = facet_surfaces.get_and_step();
1071 : 275 : facet_surface->get_loops( facet_loops );
1072 : : }
1073 : :
1074 : : //Collect FacetCoEdges from FacetLoops
1075 [ + + ]: 319 : for(i=0; i<facet_loops.size(); i++)
1076 : : {
1077 : 264 : FacetLoop *facet_loop = facet_loops.get_and_step();
1078 : 264 : facet_loop->get_coedges( facet_coedges );
1079 : : }
1080 : :
1081 : :
1082 : : //Collect FacetCurves from FacetCoEdges
1083 [ + + ]: 913 : for( i=0; i<facet_coedges.size(); i++)
1084 : : {
1085 : 858 : FacetCoEdge *facet_coedge = facet_coedges.get_and_step();
1086 : 858 : facet_coedge->get_curves( facet_curves );
1087 : : }
1088 : 55 : facet_curves.uniquify_ordered();
1089 : :
1090 : :
1091 : : //Collect FacetPoints from FacetCurves
1092 [ + + ]: 517 : for( i=0; i<facet_curves.size(); i++)
1093 : : {
1094 : 462 : FacetCurve *facet_curve = facet_curves.get_and_step();
1095 : 462 : facet_curve->get_points( facet_points );
1096 : : }
1097 : :
1098 : : //uniquify lists
1099 : 55 : facet_points.uniquify_ordered();
1100 : :
1101 : :
1102 : 55 : return CUBIT_SUCCESS;
1103 : :
1104 : : }
1105 : :
1106 : :
1107 : : CubitStatus
1108 : 55 : FacetQueryEngine::write_topology( FILE *file_ptr,
1109 : : DLIList<FacetBody*> &facet_bodies,
1110 : : DLIList<FacetLump*> &facet_lumps,
1111 : : DLIList<FacetShell*> &facet_shells,
1112 : : DLIList<FacetSurface*> &facet_surfaces,
1113 : : DLIList<FacetLoop*> &facet_loops,
1114 : : DLIList<FacetCoEdge*> &facet_coedges,
1115 : : DLIList<FacetCurve*> &facet_curves,
1116 : : DLIList<FacetPoint*> &facet_points )
1117 : : {
1118 : :
1119 : : int i;
1120 : :
1121 : : //create a wrapper object for writing
1122 [ + - ]: 55 : CIOWrapper file_writer( file_ptr );
1123 : :
1124 : : //-----------------write FacetPoints--------------
1125 [ + - ]: 55 : UnsignedInt32 size = facet_points.size();
1126 : : //write out number of FacetPoints
1127 [ + - ]: 55 : file_writer.Write( &size, 1 );
1128 [ + - ]: 55 : facet_points.reset();
1129 [ + - ][ + + ]: 385 : for( i=0; i<facet_points.size(); i++)
1130 : : {
1131 [ + - ]: 330 : FacetPoint *curr_point = facet_points.get_and_step();
1132 [ + - ][ + - ]: 330 : int id = curr_point->get_cubit_point()->id();
1133 : :
1134 [ + - ]: 330 : file_writer.Write( reinterpret_cast<UnsignedInt32*>(&id), 1 );
1135 [ + - ][ - + ]: 330 : if( curr_point->save_attribs(file_ptr) == CUBIT_FAILURE )
1136 : 0 : return CUBIT_FAILURE;
1137 : : }
1138 : :
1139 : : //-----------------write FacetCurves--------------
1140 [ + - ]: 55 : size = facet_curves.size();
1141 : : //write out number of FacetCurves
1142 [ + - ]: 55 : file_writer.Write( &size, 1 );
1143 [ + - ]: 55 : facet_curves.reset();
1144 [ + - ][ + + ]: 517 : for( i=0; i<facet_curves.size(); i++)
1145 : : {
1146 [ + - ]: 462 : FacetCurve *curr_curve = facet_curves.get_and_step();
1147 : : TBPoint *s_point, *e_point;
1148 [ + - ]: 462 : s_point = curr_curve->start_point();
1149 [ + - ]: 462 : e_point = curr_curve->end_point();
1150 : :
1151 : : int data_to_write[4];
1152 : :
1153 : : // get start&end points implicit ids
1154 : 462 : FacetPoint *temp_point = NULL;
1155 [ - + ]: 462 : temp_point = CAST_TO( s_point, FacetPoint );
1156 [ - + ]: 462 : if( !temp_point ) assert(0);
1157 : : int found;
1158 [ + - ]: 462 : found = facet_points.where_is_item( temp_point );
1159 [ - + ]: 462 : if( found == -1)
1160 : 0 : assert(0);
1161 : 462 : data_to_write[0] = found;
1162 : :
1163 [ - + ]: 462 : temp_point = CAST_TO( e_point, FacetPoint );
1164 [ - + ]: 462 : if( !temp_point ) assert(0);
1165 [ + - ]: 462 : found = facet_points.where_is_item( temp_point );
1166 [ - + ]: 462 : if( found == -1)
1167 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Curves\n");
[ # # ][ # # ]
1168 : 462 : data_to_write[1] = found;
1169 : :
1170 : : //convert Sense info to integer
1171 [ + - ][ - + ]: 462 : if( curr_curve->get_sense() == CUBIT_UNKNOWN )
1172 : 0 : data_to_write[2] = -1;
1173 : : else
1174 [ + - ][ - + ]: 462 : data_to_write[2] = (curr_curve->get_sense() == CUBIT_REVERSED) ? 1 : 0;
1175 : :
1176 [ + - ][ + - ]: 462 : data_to_write[3] = curr_curve->get_eval_tool()->get_output_id();
1177 : :
1178 : : //write the data
1179 [ + - ]: 462 : file_writer.Write( reinterpret_cast<UnsignedInt32*>(data_to_write), 4 );
1180 : :
1181 [ + - ][ - + ]: 462 : if( curr_curve->save_attribs(file_ptr) == CUBIT_FAILURE )
1182 : 0 : return CUBIT_FAILURE;
1183 : : }
1184 : :
1185 : : //-----------------write FacetCoedges--------------
1186 [ + - ]: 55 : size = facet_coedges.size();
1187 : : // write out number of FacetCurves
1188 [ + - ]: 55 : file_writer.Write( &size, 1 );
1189 [ + - ]: 55 : facet_coedges.reset();
1190 [ + - ][ + + ]: 913 : for( i=0; i<facet_coedges.size(); i++)
1191 : : {
1192 [ + - ]: 858 : FacetCoEdge *curr_coedge = facet_coedges.get_and_step();
1193 : : Curve *curve_sm;
1194 [ + - ]: 858 : curve_sm = curr_coedge->curve();
1195 : :
1196 : 858 : FacetCurve *temp_curve = NULL;
1197 [ - + ]: 858 : temp_curve = CAST_TO( curve_sm, FacetCurve );
1198 : :
1199 : : int data_to_write[2];
1200 : :
1201 : : // get implicit id of this curve
1202 : : int found;
1203 [ + - ]: 858 : found = facet_curves.where_is_item( temp_curve );
1204 [ - + ]: 858 : if( found == -1)
1205 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet CoEdges\n");
[ # # ][ # # ]
1206 : 858 : data_to_write[0] = found;
1207 : :
1208 : : // convert sense info to integer
1209 [ + - ][ - + ]: 858 : if( curr_coedge->get_sense() == CUBIT_UNKNOWN )
1210 : 0 : data_to_write[1] = -1;
1211 : : else
1212 [ + - ][ + + ]: 858 : data_to_write[1] = (curr_coedge->get_sense() == CUBIT_REVERSED) ? 1 : 0;
1213 : :
1214 : : // write out the data
1215 [ + - ]: 858 : file_writer.Write( reinterpret_cast<UnsignedInt32*>(data_to_write), 2 );
1216 : :
1217 : : }
1218 : :
1219 : : //-----------------write FacetLoops--------------
1220 [ + - ]: 55 : size = facet_loops.size();
1221 : : // write out number of FacetLoops
1222 [ + - ]: 55 : file_writer.Write( &size, 1 );
1223 [ + - ]: 55 : facet_loops.reset();
1224 [ + - ][ + + ]: 319 : for( i=0; i<facet_loops.size(); i++)
1225 : : {
1226 [ + - ]: 264 : FacetLoop *curr_loop = facet_loops.get_and_step();
1227 [ + - ]: 264 : DLIList<FacetCoEdge*> coedge_list;
1228 [ + - ]: 264 : curr_loop->get_coedges( coedge_list );
1229 : :
1230 : : // get number of coedges in this loop
1231 : : UnsignedInt32 *data_to_write;
1232 [ + - ]: 264 : size = coedge_list.size();
1233 [ + - ][ + - ]: 264 : data_to_write = new UnsignedInt32[ size + 1 ];
1234 : 264 : data_to_write[0] = size;
1235 : :
1236 : : UnsignedInt32 j;
1237 : : // get implicit ids of coedges
1238 [ + - ]: 264 : coedge_list.reset();
1239 [ + + ]: 1122 : for( j=1; j<size+1; j++)
1240 : : {
1241 [ + - ]: 858 : FacetCoEdge *temp_coedge = coedge_list.get_and_step();
1242 : : int found;
1243 [ + - ]: 858 : found = facet_coedges.where_is_item( temp_coedge );
1244 [ - + ]: 858 : if( found == -1)
1245 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Loops\n");
[ # # ][ # # ]
1246 : 858 : data_to_write[j] = found;
1247 : : }
1248 : :
1249 : : // write out the data
1250 [ + - ]: 264 : file_writer.Write( data_to_write, size + 1);
1251 [ + - ]: 264 : delete [] data_to_write;
1252 [ + - ]: 264 : }
1253 : :
1254 : : //-----------------write FacetSurfaces--------------
1255 [ + - ]: 55 : size = facet_surfaces.size();
1256 : : // write out number of FacetSurfaces
1257 [ + - ]: 55 : file_writer.Write( &size, 1 );
1258 [ + - ]: 55 : facet_surfaces.reset();
1259 [ + - ][ + + ]: 330 : for( i=0; i<facet_surfaces.size(); i++)
1260 : : {
1261 [ + - ]: 275 : FacetSurface *curr_surface = facet_surfaces.get_and_step();
1262 : :
1263 [ + - ]: 275 : DLIList<FacetLoop*> loop_list;
1264 [ + - ]: 275 : curr_surface->get_loops( loop_list );
1265 : :
1266 [ + - ]: 275 : int num_loops = loop_list.size();
1267 : : int data_to_write[6];
1268 : :
1269 : : // convert sense info to integer
1270 : : // if( curr_surface->get_relative_surface_sense() == CUBIT_UNKNOWN )
1271 : : // data_to_write[0] = -1;
1272 : : // else
1273 : : // data_to_write[0] = (curr_surface->get_relative_surface_sense() == CUBIT_REVERSED) ? 1 : 0;
1274 : 275 : data_to_write[0]=0;
1275 : : // get "useFacets"
1276 : 275 : data_to_write[1] = 1;
1277 : :
1278 : : // get output id of FacetEvalTool
1279 [ + - ][ + - ]: 275 : data_to_write[2] = curr_surface->get_eval_tool()->get_output_id();
1280 : :
1281 : : // get Shell Sense stuff
1282 : : CubitSense sense0;
1283 : :
1284 [ + - ]: 275 : curr_surface->get_shell_sense( sense0 );
1285 [ + + ]: 275 : if( sense0 == CUBIT_UNKNOWN )
1286 : 77 : data_to_write[3] = -1;
1287 : : else
1288 [ - + ]: 198 : data_to_write[3] = (sense0 == CUBIT_REVERSED) ? 1 : 0;
1289 : :
1290 : : // if( sense1 == CUBIT_UNKNOWN )
1291 : 275 : data_to_write[4] = -1;
1292 : : // else
1293 : : // data_to_write[4] = (sense1 == CUBIT_REVERSED) ? 1 : 0;
1294 : :
1295 : : // get number of loops
1296 : 275 : data_to_write[5] = num_loops;
1297 : :
1298 [ + - ]: 275 : file_writer.Write( reinterpret_cast<UnsignedInt32*>(data_to_write), 6 );
1299 : :
1300 : : // get implicit ids of loops
1301 [ + + ]: 275 : if( num_loops > 0 )
1302 : : {
1303 [ + - ][ + - ]: 264 : int *loop_ids = new int[num_loops];
1304 : : int j;
1305 [ + - ]: 264 : loop_list.reset();
1306 [ + + ]: 528 : for( j=0; j<num_loops; j++)
1307 : : {
1308 [ + - ]: 264 : FacetLoop *temp_loop = loop_list.get_and_step();
1309 : : int found;
1310 [ + - ]: 264 : found = facet_loops.where_is_item( temp_loop );
1311 [ - + ]: 264 : if( found == -1 )
1312 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Surfaces\n");
[ # # ][ # # ]
1313 : 264 : loop_ids[j] = found;
1314 : : }
1315 : :
1316 : : // write out data
1317 [ + - ]: 264 : file_writer.Write( reinterpret_cast<UnsignedInt32*>(loop_ids), num_loops );
1318 [ + - ]: 264 : delete [] loop_ids;
1319 : : }
1320 : :
1321 [ + - ][ - + ]: 275 : if( curr_surface->save_attribs(file_ptr) == CUBIT_FAILURE )
1322 [ + - ][ + - ]: 275 : return CUBIT_FAILURE;
1323 : 275 : }
1324 : :
1325 : : //-----------------write FacetShells--------------
1326 [ + - ]: 55 : size = facet_shells.size();
1327 : : // write out number of FacetShells
1328 [ + - ]: 55 : file_writer.Write( &size, 1 );
1329 [ + - ]: 55 : facet_shells.reset();
1330 [ + - ][ + + ]: 121 : for( i=0; i<facet_shells.size(); i++)
1331 : : {
1332 [ + - ]: 66 : FacetShell *curr_shell= facet_shells.get_and_step(); //number of surfaces
1333 [ + - ]: 66 : DLIList<FacetSurface*> temp_facet_surf_list;
1334 [ + - ]: 66 : curr_shell->get_surfaces( temp_facet_surf_list );
1335 : :
1336 : : // get number of surfaces in this shell
1337 : : UnsignedInt32 *data_to_write;
1338 [ + - ]: 66 : int num_surfs = temp_facet_surf_list.size();
1339 [ + - ][ + - ]: 66 : data_to_write = new UnsignedInt32[ num_surfs + 1];
1340 : 66 : data_to_write[0] = num_surfs;
1341 : :
1342 : : // get implicit ids of surfaces
1343 : : int j;
1344 [ + - ]: 66 : temp_facet_surf_list.reset();
1345 [ + + ]: 341 : for( j=1; j<num_surfs+1; j++)
1346 : : {
1347 [ + - ]: 275 : FacetSurface *temp_facet_surface = temp_facet_surf_list.get_and_step();
1348 : : int found;
1349 [ + - ]: 275 : found = facet_surfaces.where_is_item( temp_facet_surface );
1350 [ - + ]: 275 : if( found == -1 )
1351 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Shells\n");
[ # # ][ # # ]
1352 : 275 : data_to_write[j] = found;
1353 : : }
1354 : :
1355 : : // write the data
1356 [ + - ]: 66 : file_writer.Write( data_to_write, num_surfs + 1 );
1357 [ + - ]: 66 : delete [] data_to_write;
1358 [ + - ]: 66 : }
1359 : :
1360 : : //-----------------write FacetLumps--------------
1361 [ + - ]: 55 : size = facet_lumps.size();
1362 : : // write out number of FacetLumps
1363 [ + - ]: 55 : file_writer.Write( &size, 1 );
1364 [ + - ]: 55 : facet_lumps.reset();
1365 [ + - ][ + + ]: 121 : for( i=0; i<facet_lumps.size(); i++)
1366 : : {
1367 [ + - ]: 66 : FacetLump *curr_lump = facet_lumps.get_and_step();
1368 : :
1369 [ + - ]: 66 : DLIList<FacetShell*> temp_facet_shell_list;
1370 [ + - ]: 66 : curr_lump->get_shells( temp_facet_shell_list );
1371 : :
1372 : : // get number of shells in this lump
1373 : : UnsignedInt32 *data_to_write;
1374 [ + - ]: 66 : int num_shells= temp_facet_shell_list.size();
1375 [ + - ][ + - ]: 66 : data_to_write = new UnsignedInt32[ num_shells+ 1];
1376 : 66 : data_to_write[0] = num_shells;
1377 : :
1378 : : //get implicit ides of the lumps in this shell
1379 : : int j;
1380 [ + - ]: 66 : temp_facet_shell_list.reset();
1381 [ + + ]: 132 : for( j=1; j<num_shells+1; j++)
1382 : : {
1383 [ + - ]: 66 : FacetShell *temp_facet_shell = temp_facet_shell_list.get_and_step();
1384 : : int found;
1385 [ + - ]: 66 : found = facet_shells.where_is_item( temp_facet_shell );
1386 [ - + ]: 66 : if( found == -1 )
1387 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Lumps\n");
[ # # ][ # # ]
1388 : 66 : data_to_write[j] = found;
1389 : : }
1390 : :
1391 : : //write the data
1392 [ + - ]: 66 : file_writer.Write( data_to_write, num_shells + 1 );
1393 [ + - ]: 66 : delete [] data_to_write;
1394 [ + - ][ - + ]: 66 : if( curr_lump->save_attribs(file_ptr) == CUBIT_FAILURE )
1395 [ + - ][ + - ]: 66 : return CUBIT_FAILURE;
1396 : 66 : }
1397 : :
1398 : : //-----------------write FacetBodies--------------
1399 [ + - ]: 55 : size = facet_bodies.size();
1400 : : // write out number of FacetBodies
1401 [ + - ]: 55 : file_writer.Write( &size, 1 );
1402 [ + - ]: 55 : facet_bodies.reset();
1403 [ + - ][ + + ]: 121 : for( i=0; i<facet_bodies.size(); i++)
1404 : : {
1405 [ + - ]: 66 : FacetBody *curr_body = facet_bodies.get_and_step();
1406 : :
1407 [ + - ]: 66 : DLIList<FacetLump*> temp_facet_lump_list;
1408 [ + - ]: 66 : curr_body->get_lumps( temp_facet_lump_list );
1409 : :
1410 : : // get the number of lumps in this body
1411 : : UnsignedInt32 *data_to_write;
1412 [ + - ]: 66 : int num_lumps = temp_facet_lump_list.size();
1413 [ + - ][ + - ]: 66 : data_to_write = new UnsignedInt32[ num_lumps + 1];
1414 : 66 : data_to_write[0] = num_lumps;
1415 : :
1416 : : // get the implicit ids of the lumps in this body
1417 : : int j;
1418 [ + - ]: 66 : temp_facet_lump_list.reset();
1419 [ + + ]: 132 : for( j=1; j<num_lumps+1; j++)
1420 : : {
1421 [ + - ]: 66 : FacetLump *temp_facet_lump = temp_facet_lump_list.get_and_step();
1422 : : int found;
1423 [ + - ]: 66 : found = facet_lumps.where_is_item( temp_facet_lump );
1424 [ - + ]: 66 : if( found == -1 )
1425 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem saving Facet Bodies\n");
[ # # ][ # # ]
1426 : 66 : data_to_write[j] = found;
1427 : : }
1428 : :
1429 : : // write the data
1430 [ + - ]: 66 : file_writer.Write( data_to_write, num_lumps + 1 );
1431 [ + - ]: 66 : delete [] data_to_write;
1432 : :
1433 : : // write the transformation matrix of this body
1434 [ + - ][ + - ]: 132 : CubitTransformMatrix trans_matrix;
[ + - ]
1435 [ + - ]: 66 : curr_body->get_transforms( trans_matrix );
1436 : :
1437 [ + - ]: 66 : UnsignedInt32 num_rows = trans_matrix.num_rows();
1438 [ + - ]: 66 : UnsignedInt32 num_cols = trans_matrix.num_cols();
1439 : : UnsignedInt32 rows_and_cols[2];
1440 : 66 : rows_and_cols[0] = num_rows;
1441 : 66 : rows_and_cols[1] = num_cols;
1442 : :
1443 [ + - ]: 66 : file_writer.Write( rows_and_cols, 2 );
1444 : :
1445 : : double *trans_matrix_array;
1446 [ + - ][ + - ]: 66 : trans_matrix_array = new double[ num_rows*num_cols ];
1447 : :
1448 : : //fill up the array row-by-row
1449 : 66 : unsigned u, k = 0;
1450 [ + + ]: 330 : for(u=0; u<num_rows; u++)
1451 : : {
1452 [ + + ]: 1320 : for(k=0; k<num_cols; k++)
1453 [ + - ]: 1056 : trans_matrix_array[(u*num_cols)+k] = trans_matrix.get(u,k);
1454 : : }
1455 : :
1456 [ + - ]: 66 : file_writer.Write( trans_matrix_array, u*k );
1457 [ + - ]: 66 : delete [] trans_matrix_array;
1458 [ + - ][ - + ]: 66 : if( curr_body->save_attribs(file_ptr) == CUBIT_FAILURE )
1459 [ + - ][ + - ]: 66 : return CUBIT_FAILURE;
1460 : 66 : }
1461 : :
1462 [ + - ]: 55 : return CUBIT_SUCCESS;
1463 : : }
1464 : :
1465 : :
1466 : : CubitStatus
1467 : 11 : FacetQueryEngine::restore_topology( FILE *file_ptr,
1468 : : unsigned int endian,
1469 : : int num_points,
1470 : : CubitPoint **points_array,
1471 : : int num_cfet,
1472 : : CurveFacetEvalTool** cfev_array,
1473 : : int num_fet,
1474 : : FacetEvalTool** fev_array,
1475 : : DLIList<TopologyBridge*> &imported_entities )
1476 : : {
1477 : :
1478 : : //get file pointer
1479 : : unsigned int size;
1480 : : unsigned int i, j;
1481 : : int id, k;
1482 : :
1483 : : FacetPoint **facet_points;
1484 : : FacetCurve **facet_curves;
1485 : : FacetCoEdge **facet_coedges;
1486 : : FacetLoop **facet_loops;
1487 : : FacetSurface **facet_surfaces;
1488 : : FacetShell **facet_shells;
1489 : : FacetLump **facet_lumps;
1490 : : FacetBody **facet_bodies;
1491 : :
1492 : : FacetPoint *tmp_point;
1493 : : FacetCurve *tmp_curve;
1494 : : FacetCoEdge *tmp_coedge;
1495 : : FacetLoop *tmp_loop;
1496 : : FacetSurface *tmp_surf;
1497 : : FacetShell *tmp_shell;
1498 : : FacetLump *tmp_lump;
1499 : : FacetBody*tmp_body;
1500 : :
1501 : 11 : int num_facet_points = 0;
1502 : 11 : int num_facet_curves = 0;
1503 : 11 : int num_facet_coedges = 0;
1504 : 11 : int num_facet_loops = 0;
1505 : 11 : int num_facet_surfaces = 0;
1506 : 11 : int num_facet_shells = 0;
1507 : 11 : int num_facet_lumps = 0;
1508 : 11 : int num_facet_bodies = 0;
1509 : :
1510 : : //create a wrapper object for writing
1511 [ + - ]: 11 : CIOWrapper file_reader( endian, file_ptr );
1512 : :
1513 : : //-----------------Read FacetPoints------------------
1514 : : // Read number of FacetPoints
1515 [ + - ]: 11 : file_reader.Read( &size, 1 );
1516 : : // Allocate memory for FacetPoints
1517 [ + - ][ + - ]: 11 : facet_points = new FacetPoint*[size];
1518 [ + + ]: 187 : for(i=0; i<size; i++)
1519 : : {
1520 [ + - ]: 176 : file_reader.Read( reinterpret_cast<UnsignedInt32*>(&id), 1 );
1521 [ + - ][ - + ]: 176 : if( id >= num_points || id < 0 )
1522 : : {
1523 [ # # ]: 0 : delete [] facet_points;
1524 : 0 : return CUBIT_FAILURE;
1525 : : }
1526 : :
1527 [ + - ][ + - ]: 176 : tmp_point = new FacetPoint( points_array[ id ] );
1528 [ - + ]: 176 : if( tmp_point == NULL )
1529 : 0 : return CUBIT_FAILURE;
1530 : :
1531 : 176 : num_facet_points++;
1532 : 176 : facet_points[i] = tmp_point;
1533 [ + - ]: 176 : tmp_point->restore_attribs( file_ptr, endian );
1534 : : }
1535 : :
1536 : : //-----------------Read FacetCurves------------------
1537 : : //Read number of FacetCurves
1538 [ + - ]: 11 : file_reader.Read( &size, 1 );
1539 : : // Allocate memory for FacetCurves
1540 [ + - ][ + - ]: 11 : facet_curves = new FacetCurve*[size];
1541 [ + + ]: 275 : for(i=0; i<size; i++)
1542 : : {
1543 : : int data[4];
1544 [ + - ]: 264 : file_reader.Read( reinterpret_cast<UnsignedInt32*>(data), 4 );
1545 [ + - ][ + - ]: 264 : if( data[0] >= num_facet_points || data[0] < 0 ||
[ + - ]
1546 [ + - ][ + - ]: 264 : data[1] >= num_facet_points || data[1] < 0 ||
1547 [ - + ]: 264 : data[3] >= num_cfet || data[3] < 0 )
1548 : : {
1549 [ # # ]: 0 : delete [] facet_curves;
1550 : 0 : return CUBIT_FAILURE;
1551 : : }
1552 : :
1553 : : CubitSense sense;
1554 [ - + ]: 264 : if (data[2] == -1 )
1555 : 0 : sense = CUBIT_UNKNOWN;
1556 : : else
1557 [ - + ]: 264 : sense = data[2] ? CUBIT_REVERSED : CUBIT_FORWARD;
1558 : :
1559 : 528 : tmp_curve = new FacetCurve( cfev_array[ data[3] ], facet_points[ data[0] ],
1560 [ + - ][ + - ]: 264 : facet_points[ data[1] ], sense );
1561 [ - + ]: 264 : if( tmp_curve == NULL )
1562 : 0 : return CUBIT_FAILURE;
1563 : :
1564 : : // Add curve to FacetPoints
1565 [ + - ]: 264 : facet_points[data[0]]->add_curve( tmp_curve );
1566 [ + - ]: 264 : facet_points[data[1]]->add_curve( tmp_curve );
1567 : :
1568 : 264 : num_facet_curves++;
1569 : 264 : facet_curves[i] = tmp_curve;
1570 [ + - ]: 264 : tmp_curve->restore_attribs( file_ptr, endian );
1571 : : }
1572 : :
1573 : : //-----------------Read FacetCoEdges------------------
1574 : : //Read number of FacetCoEdges
1575 [ + - ]: 11 : file_reader.Read( &size, 1 );
1576 [ + - ][ + - ]: 11 : facet_coedges = new FacetCoEdge*[ size ];
1577 [ + + ]: 539 : for(i=0; i<size; i++)
1578 : : {
1579 : : int data[2];
1580 [ + - ]: 528 : file_reader.Read( reinterpret_cast<unsigned int*>(data), 2 );
1581 : :
1582 [ + - ][ - + ]: 528 : if( data[0] >= num_facet_curves || data[0] < 0 )
1583 : : {
1584 [ # # ]: 0 : delete [] facet_coedges;
1585 : 0 : return CUBIT_FAILURE;
1586 : : }
1587 : :
1588 : : CubitSense sense;
1589 [ - + ]: 528 : if (data[1] == -1 )
1590 : 0 : sense = CUBIT_UNKNOWN;
1591 : : else
1592 [ + + ]: 528 : sense = data[1] ? CUBIT_REVERSED : CUBIT_FORWARD;
1593 : :
1594 [ + - ][ + - ]: 528 : tmp_coedge = new FacetCoEdge( facet_curves[ data[0] ], sense );
1595 [ - + ]: 528 : if( tmp_coedge == NULL )
1596 : 0 : return CUBIT_FAILURE;
1597 : :
1598 : 528 : facet_coedges[i] = tmp_coedge;
1599 : 528 : num_facet_coedges++;
1600 : :
1601 : : // Add FacetCoEdge to FacetCurve
1602 [ + - ]: 528 : facet_curves[ data[0] ]->add_coedge( tmp_coedge );
1603 : : }
1604 : :
1605 : : //-----------------Read FacetLoops------------------
1606 : : //Read number of FacetLoops
1607 [ + - ]: 11 : file_reader.Read( &size, 1 );
1608 [ + - ][ + - ]: 22 : DLIList<CoEdgeSM*> temp_coedge_list;
1609 [ + - ][ + - ]: 11 : facet_loops = new FacetLoop*[ size ];
1610 [ + + ]: 143 : for(i=0; i<size; i++)
1611 : : {
1612 [ + - ]: 132 : temp_coedge_list.clean_out();
1613 : :
1614 : 132 : unsigned int num_coedges = 0;
1615 [ + - ]: 132 : file_reader.Read( &num_coedges, 1);
1616 : :
1617 [ + - ][ + - ]: 132 : int* coedge_ids = new int[ num_coedges];
1618 [ + - ]: 132 : file_reader.Read( (unsigned*)coedge_ids, num_coedges );
1619 : :
1620 [ + + ]: 660 : for( j=0; j<num_coedges; j++)
1621 : : {
1622 [ + - ][ - + ]: 528 : if( coedge_ids[j] >= num_facet_coedges || coedge_ids[j] < 0 )
1623 : : {
1624 [ # # ]: 0 : delete [] facet_loops;
1625 : 0 : return CUBIT_FAILURE;
1626 : : }
1627 [ + - ]: 528 : temp_coedge_list.append( facet_coedges[ coedge_ids[j] ] );
1628 : : }
1629 : :
1630 [ + - ][ + - ]: 132 : tmp_loop = new FacetLoop( temp_coedge_list );
1631 [ - + ]: 132 : if( tmp_loop == NULL)
1632 : 0 : return CUBIT_FAILURE;
1633 : :
1634 : 132 : num_facet_loops++;
1635 : 132 : facet_loops[i] = tmp_loop;
1636 : :
1637 [ + + ]: 660 : for( j=0; j<num_coedges; j++)
1638 [ + - ]: 528 : facet_coedges[ coedge_ids[j] ]->add_loop( tmp_loop );
1639 : :
1640 [ + - ]: 132 : delete [] coedge_ids;
1641 : : }
1642 : :
1643 : : //-----------------Read FacetSurfaces------------------
1644 : : //Read number of FacetSurfaces
1645 [ + - ]: 11 : file_reader.Read( &size, 1 );
1646 [ + - ][ + - ]: 11 : facet_surfaces = new FacetSurface*[size];
1647 [ + - ][ + - ]: 22 : DLIList<LoopSM*> temp_loops;
1648 [ + + ]: 143 : for(i=0; i<size; i++)
1649 : : {
1650 [ + - ]: 132 : temp_loops.clean_out();
1651 : : int data[6];
1652 [ + - ]: 132 : file_reader.Read( (unsigned int*)data, 6);
1653 : :
1654 : : CubitSense sense, sense0;
1655 [ - + ]: 132 : if (data[0] == -1 )
1656 : 0 : sense = CUBIT_UNKNOWN;
1657 : : else
1658 [ - + ]: 132 : sense = data[0] ? CUBIT_REVERSED : CUBIT_FORWARD;
1659 : :
1660 : : CubitBoolean useFacets;
1661 [ + - ]: 132 : useFacets = data[1] ? CUBIT_TRUE : CUBIT_FALSE;
1662 : :
1663 : : // make sure FacetEvalTool ID is in range
1664 [ + - ][ - + ]: 132 : if( data[2] >= num_fet || data[2] < 0 )
1665 : : {
1666 [ # # ]: 0 : delete [] facet_surfaces;
1667 : 0 : return CUBIT_FAILURE;
1668 : : }
1669 : :
1670 [ - + ]: 132 : if (data[3] == -1 )
1671 : 0 : sense0 = CUBIT_UNKNOWN;
1672 : : else
1673 [ - + ]: 132 : sense0 = data[3] ? CUBIT_REVERSED : CUBIT_FORWARD;
1674 : :
1675 : 132 : int num_loops = data[5];
1676 [ + - ][ + - ]: 132 : int* loop_ids = new int[ num_loops ];
1677 [ + - ]: 132 : file_reader.Read( (unsigned*)loop_ids, num_loops );
1678 : :
1679 [ + + ]: 264 : for( k=0; k<num_loops; k++)
1680 : : {
1681 [ + - ][ - + ]: 132 : if( loop_ids[k] >= num_facet_loops ||
1682 : 132 : loop_ids[k] < 0 )
1683 : : {
1684 [ # # ]: 0 : delete [] loop_ids;
1685 : 0 : return CUBIT_FAILURE;
1686 : : }
1687 [ + - ]: 132 : temp_loops.append( facet_loops[ loop_ids[k] ] );
1688 : : }
1689 : 132 : tmp_surf = new FacetSurface( fev_array[ data[2] ],
1690 : : sense, sense0,
1691 [ + - ][ + - ]: 132 : useFacets, temp_loops );
1692 [ - + ]: 132 : if( tmp_surf == NULL)
1693 : 0 : return CUBIT_FAILURE;
1694 : :
1695 : 132 : facet_surfaces[i] = tmp_surf;
1696 : 132 : num_facet_surfaces++;
1697 : :
1698 : : // Add FacetSurface to FacetLoops
1699 [ + + ]: 264 : for( k=0; k<num_loops; k++)
1700 [ + - ]: 132 : facet_loops[ loop_ids[k] ]->add_surface( tmp_surf );
1701 : :
1702 [ + - ]: 132 : delete [] loop_ids;
1703 [ + - ]: 132 : tmp_surf->restore_attribs( file_ptr, endian );
1704 : : }
1705 : :
1706 : : //-----------------Read FacetShells------------------
1707 : : //Read number of FacetShells
1708 [ + - ]: 11 : file_reader.Read( &size, 1 );
1709 [ + - ][ + - ]: 11 : facet_shells = new FacetShell*[size];
1710 [ + - ][ + - ]: 22 : DLIList<Surface*> temp_surfs;
1711 [ + + ]: 33 : for(i=0; i<size; i++)
1712 : : {
1713 [ + - ]: 22 : temp_surfs.clean_out();
1714 : 22 : unsigned int num_surfs = 0;
1715 [ + - ]: 22 : file_reader.Read( &num_surfs, 1 );
1716 : :
1717 [ + - ][ + - ]: 22 : int* surface_ids = new int[ num_surfs ];
1718 [ + - ]: 22 : file_reader.Read( (unsigned*)surface_ids, num_surfs );
1719 : :
1720 [ + + ]: 154 : for( j=0; j<num_surfs; j++)
1721 : : {
1722 [ + - ][ - + ]: 132 : if( surface_ids[j] >= num_facet_surfaces ||
1723 : 132 : surface_ids[j] < 0 )
1724 : : {
1725 [ # # ]: 0 : delete [] facet_shells;
1726 : 0 : return CUBIT_FAILURE;
1727 : : }
1728 : :
1729 [ + - ]: 132 : temp_surfs.append( facet_surfaces[ surface_ids[j] ] );
1730 : : }
1731 : :
1732 [ + - ][ + - ]: 22 : tmp_shell = new FacetShell( temp_surfs );
1733 : 22 : facet_shells[i] = tmp_shell;
1734 : 22 : num_facet_shells++;
1735 : :
1736 : : // Add this shell to surfaces
1737 [ + + ]: 154 : for( j=0; j<num_surfs; j++)
1738 [ + - ]: 132 : facet_surfaces[ surface_ids[j] ]->add_shell( tmp_shell );
1739 : :
1740 [ + - ]: 22 : delete [] surface_ids;
1741 : : }
1742 : :
1743 : : //-----------------Read FacetLumps------------------
1744 : : //Read number of FacetLumps
1745 [ + - ]: 11 : file_reader.Read( &size, 1 );
1746 [ + - ][ + - ]: 11 : facet_lumps = new FacetLump*[size];
1747 [ + - ][ + - ]: 22 : DLIList<ShellSM*> temp_shells;
1748 [ + + ]: 33 : for(i=0; i<size; i++)
1749 : : {
1750 [ + - ]: 22 : temp_shells.clean_out();
1751 : :
1752 : 22 : unsigned int num_shells = 0;
1753 [ + - ]: 22 : file_reader.Read( &num_shells, 1 );
1754 : :
1755 [ + - ][ + - ]: 22 : int* shell_ids = new int[ num_shells ];
1756 [ + - ]: 22 : file_reader.Read( (unsigned*)shell_ids, num_shells );
1757 : :
1758 [ + + ]: 44 : for( j=0; j<num_shells; j++)
1759 : : {
1760 [ - + ]: 22 : if( shell_ids[j] >= num_facet_shells )
1761 : : {
1762 [ # # ]: 0 : delete [] facet_lumps;
1763 : 0 : return CUBIT_FAILURE;
1764 : : }
1765 [ + - ]: 22 : temp_shells.append( facet_shells[ shell_ids[j] ] );
1766 : : }
1767 : :
1768 [ + - ][ + - ]: 22 : tmp_lump = new FacetLump( temp_shells );
1769 [ - + ]: 22 : if( tmp_lump == NULL )
1770 : 0 : return CUBIT_FAILURE;
1771 : :
1772 : 22 : facet_lumps[i] = tmp_lump;
1773 : 22 : num_facet_lumps++;
1774 : :
1775 [ + + ]: 44 : for( j=0; j<num_shells; j++)
1776 [ + - ]: 22 : facet_shells[ shell_ids[j] ]->add_lump( tmp_lump );
1777 : :
1778 [ + - ]: 22 : delete [] shell_ids;
1779 [ + - ]: 22 : tmp_lump->restore_attribs( file_ptr, endian );
1780 : : }
1781 : :
1782 : : //-----------------Read FacetBodies ------------------
1783 : : //Read number of FacetBodies
1784 [ + - ]: 11 : file_reader.Read( &size, 1 );
1785 [ + - ][ + - ]: 11 : facet_bodies = new FacetBody*[size];
1786 [ + - ][ + - ]: 22 : DLIList<Lump*> temp_lumps;
1787 [ + + ]: 33 : for(i=0; i<size; i++)
1788 : : {
1789 [ + - ]: 22 : temp_lumps.clean_out();
1790 : :
1791 : 22 : unsigned int num_lumps= 0;
1792 [ + - ]: 22 : file_reader.Read( &num_lumps, 1 );
1793 : :
1794 [ + - ][ + - ]: 22 : int* lump_ids = new int[ num_lumps ];
1795 [ + - ]: 22 : file_reader.Read( (unsigned*)lump_ids, num_lumps );
1796 : :
1797 [ + + ]: 44 : for( j=0; j<num_lumps; j++)
1798 : : {
1799 [ - + ]: 22 : if( lump_ids[j] >= num_facet_lumps )
1800 : : {
1801 [ # # ]: 0 : delete [] facet_bodies;
1802 : 0 : return CUBIT_FAILURE;
1803 : : }
1804 [ + - ]: 22 : temp_lumps.append( facet_lumps[ lump_ids[j] ] );
1805 : : }
1806 : :
1807 [ + - ][ + - ]: 22 : tmp_body = new FacetBody( temp_lumps );
1808 [ - + ]: 22 : if( tmp_body == NULL )
1809 : 0 : return CUBIT_FAILURE;
1810 : :
1811 : 22 : facet_bodies[i] = tmp_body;
1812 : 22 : num_facet_bodies++;
1813 : :
1814 : : // Add this FacetBody to FacetLumps
1815 [ + + ]: 44 : for( j=0; j<num_lumps; j++)
1816 [ + - ]: 22 : facet_lumps[ lump_ids[j] ]->add_body( tmp_body );
1817 : :
1818 [ + - ]: 22 : delete [] lump_ids;
1819 : :
1820 : : //read in trans matrix
1821 : : unsigned int rows_and_cols[2];
1822 [ + - ]: 22 : file_reader.Read( rows_and_cols, 2 );
1823 : :
1824 : 22 : unsigned int num_rows = rows_and_cols[0];
1825 : 22 : unsigned int num_cols = rows_and_cols[1];
1826 : :
1827 [ - + ][ # # ]: 22 : if( num_rows || num_cols)
1828 : : {
1829 [ + - ]: 22 : CubitTransformMatrix trans_matrix;
1830 : :
1831 : : double *trans_matrix_array;
1832 [ + - ][ + - ]: 22 : trans_matrix_array = new double[ num_rows*num_cols ];
1833 [ + - ]: 22 : file_reader.Read( trans_matrix_array, num_rows*num_cols );
1834 : :
1835 : : unsigned c;
1836 [ + + ]: 110 : for(j=0; j<num_rows; j++ )
1837 : : {
1838 [ + + ]: 440 : for(c=0; c<num_cols; c++)
1839 [ + - ]: 352 : trans_matrix.add(j,c, trans_matrix_array[(j*num_cols)+c] );
1840 : : }
1841 [ + - ][ + - ]: 22 : tmp_body->set_transforms( trans_matrix );
[ + - ]
1842 [ + - ][ + - ]: 22 : delete [] trans_matrix_array;
1843 : : }
1844 [ + - ]: 22 : tmp_body->restore_attribs( file_ptr, endian );
1845 : : }
1846 : :
1847 : : // Here is where we determine if the entites are free or not
1848 : : // bodies, all bodies are free
1849 [ + + ]: 33 : for(k=0; k<num_facet_bodies; k++)
1850 [ + - ]: 22 : imported_entities.append( facet_bodies[k] );
1851 : :
1852 : : // surfaces are free if they are not in a shell
1853 [ + - ][ + - ]: 22 : DLIList<FacetShell*> shell_list;
1854 [ + + ]: 143 : for(k=0; k<num_facet_surfaces; k++)
1855 : : {
1856 [ + - ]: 132 : shell_list.clean_out();
1857 [ + - ]: 132 : facet_surfaces[k]->get_shells( shell_list );
1858 [ + - ][ - + ]: 132 : if( shell_list.size() == 0 )
1859 [ # # ]: 0 : imported_entities.append( facet_surfaces[k] );
1860 : : }
1861 : :
1862 : : // curves are free if they are not associate with a coedge
1863 [ + - ][ + - ]: 22 : DLIList<FacetCoEdge*> coedge_list;
1864 [ + + ]: 275 : for(k=0; k<num_facet_curves; k++)
1865 : : {
1866 [ + - ]: 264 : coedge_list.clean_out();
1867 [ + - ]: 264 : facet_curves[k]->get_coedges( coedge_list );
1868 [ + - ][ - + ]: 264 : if( coedge_list.size() == 0 )
1869 [ # # ]: 0 : imported_entities.append( facet_curves[k] );
1870 : : }
1871 : :
1872 : : // points are free if they are not associate with a curve
1873 [ + - ][ + - ]: 22 : DLIList<FacetCurve*> curve_list;
1874 [ + + ]: 187 : for(k=0; k<num_facet_points; k++)
1875 : : {
1876 [ + - ]: 176 : curve_list.clean_out();
1877 [ + - ]: 176 : facet_points[k]->get_curves( curve_list );
1878 [ + - ][ - + ]: 176 : if( curve_list.size() == 0 )
1879 [ # # ]: 0 : imported_entities.append( facet_points[k] );
1880 : : }
1881 : :
1882 : : // clean up
1883 [ + - ]: 11 : delete [] facet_points;
1884 [ + - ]: 11 : delete [] facet_curves;
1885 [ + - ]: 11 : delete [] facet_coedges;
1886 [ + - ]: 11 : delete [] facet_loops;
1887 [ + - ]: 11 : delete [] facet_surfaces;
1888 [ + - ]: 11 : delete [] facet_shells;
1889 [ + - ]: 11 : delete [] facet_lumps;
1890 [ + - ]: 11 : delete [] facet_bodies;
1891 : :
1892 [ + - ]: 11 : return CUBIT_SUCCESS;
1893 : : }
1894 : :
1895 : 11 : CubitStatus FacetQueryEngine::import_solid_model( const char* file_name ,
1896 : : Model_File_Type file_type,
1897 : : DLIList<TopologyBridge*> &imported_entities,
1898 : : ModelImportOptions &import_options )
1899 : : {
1900 : 11 : errno = 0;
1901 : 11 : FILE *file_ptr = fopen(file_name, "rb");
1902 [ - + ]: 11 : if (!file_ptr)
1903 : : {
1904 [ # # ][ # # ]: 0 : PRINT_ERROR("Cannot open file: %s (%s)\n", file_name, strerror(errno) );
1905 : 0 : return CUBIT_FAILURE;
1906 : : }
1907 : :
1908 : 11 : CubitStatus status = import_solid_model(file_ptr, imported_entities );
1909 : :
1910 : 11 : fclose(file_ptr);
1911 : 11 : return status;
1912 : : }
1913 : :
1914 : 11 : CubitStatus FacetQueryEngine::import_solid_model(FILE *file_ptr,
1915 : : DLIList<TopologyBridge*> &imported_entities )
1916 : :
1917 : : {
1918 : 11 : CubitPoint **points_array = NULL;
1919 : 11 : CurveFacetEvalTool **cfet_array = NULL;
1920 : 11 : FacetEvalTool **fet_array = NULL;
1921 : :
1922 : : int num_points, num_edges, num_facets;
1923 : : int num_cfet, num_fet;
1924 : :
1925 : : // read in the file type "MESHED_BASED_GEOMETRY"
1926 : 11 : char fileType[19] = {0};
1927 : :
1928 [ + - ][ - + ]: 11 : if( fread( fileType, 1, 19, file_ptr) != 19 )
1929 : : {
1930 [ # # ][ # # ]: 0 : PRINT_ERROR("Trouble reading in file type for MBG\n");
[ # # ][ # # ]
1931 : 0 : return CUBIT_FAILURE;
1932 : : }
1933 : :
1934 [ - + ]: 11 : if( strncmp( fileType, "MESH_BASED_GEOMETRY", 19 ) )
1935 : : {
1936 [ # # ][ # # ]: 0 : PRINT_ERROR("Not MESH_BASED_GEOMETRY file type\n");
[ # # ][ # # ]
1937 : 0 : return CUBIT_FAILURE;
1938 : : }
1939 : :
1940 : : // read in the endian value
1941 [ + - ]: 11 : NCubitFile::CIOWrapper file_reader(file_ptr, 19, 0);
1942 : :
1943 : : // read in version #
1944 : : UnsignedInt32 version;
1945 [ + - ]: 11 : file_reader.Read( &version, 1 );
1946 : :
1947 : : //Read in points/edges/facets
1948 : : CubitStatus status;
1949 : : status = restore_facets( file_ptr, file_reader.get_endian(),
1950 : : num_points, num_edges,
1951 : : num_facets, points_array, num_cfet,
1952 [ + - ][ + - ]: 11 : num_fet, cfet_array, fet_array );
1953 [ - + ]: 11 : if( status == CUBIT_FAILURE)
1954 : : {
1955 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems restore facets\n");
[ # # ][ # # ]
1956 : 0 : return CUBIT_FAILURE;
1957 : : }
1958 : :
1959 : : //Restore Topology
1960 : : status = restore_topology( file_ptr, file_reader.get_endian(),
1961 : : num_points, points_array,
1962 : : num_cfet, cfet_array, num_fet,
1963 [ + - ][ + - ]: 11 : fet_array, imported_entities);
1964 [ - + ]: 11 : if( status == CUBIT_FAILURE)
1965 : : {
1966 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems restore MDB topology\n");
[ # # ][ # # ]
1967 : 0 : return CUBIT_FAILURE;
1968 : : }
1969 : :
1970 : :
1971 [ + - ]: 11 : if(cfet_array != NULL)
1972 [ + - ]: 11 : delete [] cfet_array;
1973 [ + - ]: 11 : if(fet_array != NULL)
1974 [ + - ]: 11 : delete [] fet_array;
1975 [ + - ]: 11 : if(points_array != NULL)
1976 [ + - ]: 11 : delete [] points_array;
1977 : :
1978 [ + - ]: 11 : return CUBIT_SUCCESS;
1979 : : }
1980 : :
1981 : :
1982 : : //===============================================================================
1983 : : // Function : restore_facets
1984 : : // Member Type: PUBLIC
1985 : : // Description: restore facets and eval tools onto the list of entities
1986 : : // Author : sjowen
1987 : : // Date : 1/26/03
1988 : : //===============================================================================
1989 : 11 : CubitStatus FacetQueryEngine::restore_facets(
1990 : : FILE *fp, // CUB file we are currently reading
1991 : : unsigned int endian,
1992 : : int &num_points,
1993 : : int &num_edges,
1994 : : int &num_facets,
1995 : : CubitPoint **&points,
1996 : : int &num_cfet,
1997 : : int &num_fet,
1998 : : CurveFacetEvalTool **&cfet_array,
1999 : : FacetEvalTool **&fet_array)
2000 : : {
2001 : 11 : CubitStatus rv = CUBIT_SUCCESS;
2002 : :
2003 : 11 : CubitFacet **facets = NULL;
2004 : 11 : CubitFacetEdge **edges = NULL;
2005 : :
2006 : : // read facets from the file and build arrays of facet entities
2007 : :
2008 : : rv = read_facets( fp, endian,
2009 : : num_facets, num_edges, num_points,
2010 [ + - ]: 11 : facets, edges, points );
2011 : :
2012 : : // create the CurveFacetEvalTools and FacetEval Tools
2013 : :
2014 [ + - ]: 11 : if (rv != CUBIT_FAILURE )
2015 : : {
2016 : : rv = restore_eval_tools( fp, endian,
2017 : : num_facets, num_edges, num_points,
2018 : : facets, edges, points,
2019 : : num_cfet, num_fet,
2020 [ + - ]: 11 : cfet_array, fet_array );
2021 : : }
2022 : :
2023 [ + - ]: 11 : if (facets != NULL)
2024 [ + - ]: 11 : delete [] facets;
2025 [ + - ]: 11 : if(edges != NULL)
2026 [ + - ]: 11 : delete [] edges;
2027 : 11 : return rv;
2028 : :
2029 : : }
2030 : :
2031 : :
2032 : : //===============================================================================
2033 : : // Function : read_facets
2034 : : // Member Type: PUBLIC
2035 : : // Description: read facets from the file and create facet entities
2036 : : // Author : sjowen
2037 : : // Date : 1/26/03
2038 : : //===============================================================================
2039 : 11 : CubitStatus FacetQueryEngine::read_facets(
2040 : : FILE *fp,
2041 : : unsigned int endian,
2042 : : int &num_facets,
2043 : : int &num_edges,
2044 : : int &num_points,
2045 : : CubitFacet **&facets,
2046 : : CubitFacetEdge **&edges,
2047 : : CubitPoint **&points )
2048 : : {
2049 : :
2050 [ + - ]: 11 : NCubitFile::CIOWrapper cio(endian, fp );
2051 : : int ii;
2052 : :
2053 : : // read points
2054 : : UnsignedInt32 npoints;
2055 : : double uu,vv,ss;
2056 [ + - ]: 11 : cio.Read(&npoints, 1);
2057 : 11 : num_points = (int)npoints;
2058 [ + - ]: 11 : if (num_points > 0)
2059 : : {
2060 [ + - ][ + - ]: 11 : double* coord_array = new double [num_points * 3];
2061 [ + - ][ + - ]: 11 : double* uvs_array = new double [num_points * 3];
2062 [ + - ]: 11 : cio.Read(coord_array, npoints*3);
2063 [ + - ]: 11 : cio.Read(uvs_array, npoints*3);
2064 : :
2065 : : // create CubitPoints
2066 : : CubitPoint *point_ptr;
2067 : : //CubitVector normal;
2068 [ + - ][ + - ]: 11 : points = new CubitPoint * [num_points];
2069 [ + + ]: 319 : for(ii=0; ii<num_points; ii++)
2070 : : {
2071 : 308 : point_ptr = (CubitPoint *) new CubitPointData( coord_array[ii*3],
2072 : 308 : coord_array[ii*3+1],
2073 [ + - ][ + - ]: 308 : coord_array[ii*3+2] );
2074 : 308 : points[ii] = point_ptr;
2075 : 308 : uu = uvs_array[ii*3];
2076 : 308 : vv = uvs_array[ii*3+1];
2077 : 308 : ss = uvs_array[ii*3+2];
2078 [ + - ]: 308 : point_ptr->set_uvs(uu, vv, ss);
2079 : : }
2080 : :
2081 : : //Clean up
2082 [ + - ]: 11 : delete [] coord_array;
2083 [ + - ]: 11 : delete [] uvs_array;
2084 : : }
2085 : :
2086 : :
2087 : : //Read in Normals
2088 : : int nnormals;
2089 [ + - ]: 11 : cio.Read(reinterpret_cast<UnsignedInt32*>(&nnormals), 1);
2090 [ - + ]: 11 : if( nnormals > 0 )
2091 : : {
2092 [ # # ][ # # ]: 0 : double* normal_array = new double [nnormals * 3];
2093 [ # # ][ # # ]: 0 : int* normal_ids = new int[nnormals * 3];
2094 [ # # ]: 0 : cio.Read(normal_array, nnormals * 3);
2095 [ # # ]: 0 : cio.Read(reinterpret_cast<UnsignedInt32*>(normal_ids), nnormals);
2096 [ # # ]: 0 : CubitVector normal;
2097 [ # # ]: 0 : for(ii=0; ii<nnormals; ii++)
2098 : : {
2099 [ # # ]: 0 : normal.x( normal_array[ii*3] );
2100 [ # # ]: 0 : normal.y( normal_array[ii*3+1] );
2101 [ # # ]: 0 : normal.z( normal_array[ii*3+2] );
2102 [ # # ]: 0 : points[ normal_ids[ii] ]->normal( normal );
2103 : : }
2104 : :
2105 : : //Clean up
2106 [ # # ]: 0 : delete [] normal_array;
2107 [ # # ]: 0 : delete [] normal_ids;
2108 : : }
2109 : :
2110 : :
2111 : : // read edges and edge control points
2112 : :
2113 : : UnsignedInt32 nedges;
2114 [ + - ]: 11 : cio.Read(&nedges, 1);
2115 : 11 : num_edges = (int)nedges;
2116 [ + - ]: 11 : if (num_edges > 0)
2117 : : {
2118 [ + - ][ + - ]: 11 : UnsignedInt32 *edge_vert_array = new UnsignedInt32 [nedges*2];
2119 [ + - ]: 11 : cio.Read(edge_vert_array, nedges*2);
2120 : : UnsignedInt32 nctrl_pts;
2121 [ + - ]: 11 : cio.Read(&nctrl_pts, 1);
2122 : 11 : double *control_points = NULL;
2123 [ + - ]: 11 : if (nctrl_pts > 0)
2124 : : {
2125 [ + - ][ + - ]: 11 : control_points = new double [nctrl_pts*3];
2126 [ + - ]: 11 : cio.Read(control_points, nctrl_pts*3);
2127 : : }
2128 : :
2129 : : unsigned id0, id1, ii;
2130 [ + - ][ + - ]: 11 : edges = new CubitFacetEdge * [num_edges];
2131 : : CubitFacetEdge *edge_ptr;
2132 [ + + ]: 803 : for(ii=0; ii<nedges; ii++)
2133 : : {
2134 : 792 : id0 = edge_vert_array[ii*2];
2135 : 792 : id1 = edge_vert_array[ii*2+1];
2136 : :
2137 [ + - ][ + - ]: 792 : edge_ptr = (CubitFacetEdge *) new CubitFacetEdgeData( points[id0], points[id1] );
2138 : 792 : edges[ii] = edge_ptr;
2139 [ + - ]: 792 : if (nctrl_pts > 0)
2140 : : {
2141 [ + - ]: 792 : edge_ptr->set_control_points(&control_points[ii*NUM_EDGE_CPTS*3]);
2142 : : }
2143 : : }
2144 : :
2145 : : //Clean up
2146 [ + - ]: 11 : delete [] edge_vert_array;
2147 [ + - ]: 11 : delete [] control_points;
2148 : 11 : edge_vert_array = NULL;
2149 : 11 : control_points = NULL;
2150 : : }
2151 : :
2152 : : // read the facets and the facet control points
2153 : :
2154 : : UnsignedInt32 nfacets;
2155 [ + - ]: 11 : cio.Read(&nfacets, 1);
2156 : 11 : num_facets = (int)nfacets;
2157 [ + - ]: 11 : if(num_facets > 0)
2158 : : {
2159 [ + - ][ + - ]: 11 : UnsignedInt32 *facet_edge_array = new UnsignedInt32 [nfacets*3];
2160 [ + - ]: 11 : cio.Read(facet_edge_array, nfacets*3);
2161 [ + - ][ + - ]: 11 : int *int_data = new int [nfacets*2];
2162 [ + - ]: 11 : cio.Read(reinterpret_cast<UnsignedInt32*>(int_data), nfacets*2);
2163 : :
2164 : : UnsignedInt32 nctrl_pts;
2165 [ + - ]: 11 : cio.Read(&nctrl_pts, 1);
2166 : 11 : double *control_points = NULL;
2167 [ - + ]: 11 : if (nctrl_pts > 0)
2168 : : {
2169 [ # # ][ # # ]: 0 : control_points = new double [nctrl_pts*3];
2170 [ # # ]: 0 : cio.Read(control_points, nctrl_pts*3);
2171 : : }
2172 : :
2173 : : unsigned id0, id1, id2, ii;
2174 : : CubitFacet *facet_ptr;
2175 [ + - ][ + - ]: 11 : facets = new CubitFacet * [num_facets];
2176 [ + + ]: 539 : for (ii=0; ii<nfacets; ii++)
2177 : : {
2178 : 528 : id0 = facet_edge_array[ii*3];
2179 : 528 : id1 = facet_edge_array[ii*3+1];
2180 : 528 : id2 = facet_edge_array[ii*3+2];
2181 [ + - ][ + - ]: 528 : facet_ptr = (CubitFacet *) new CubitFacetData(edges[id0], edges[id1], edges[id2]);
2182 : 528 : facets[ii] = facet_ptr;
2183 [ + - ]: 528 : facet_ptr->is_flat( int_data[ii*2] );
2184 [ + - ]: 528 : facet_ptr->is_backwards( int_data[ii*2+1] );
2185 : :
2186 [ - + ]: 528 : if(nctrl_pts > 0)
2187 : : {
2188 [ # # ]: 0 : facet_ptr->set_control_points(&control_points[ii*NUM_TRI_CPTS*3]);
2189 : : }
2190 : : }
2191 : :
2192 : : //Clean up
2193 [ + - ]: 11 : delete [] facet_edge_array;
2194 [ - + ]: 11 : delete [] control_points;
2195 [ + - ]: 11 : delete [] int_data;
2196 : 11 : facet_edge_array = NULL;
2197 : 11 : control_points = NULL;
2198 : 11 : int_data = NULL;
2199 : : }
2200 : :
2201 : : // read the extra info at the surface boundaries
2202 : :
2203 : 11 : UnsignedInt32 num_c_zero_points = 0;
2204 [ + - ]: 11 : cio.Read(&num_c_zero_points, 1);
2205 [ + - ]: 11 : if (num_c_zero_points > 0)
2206 : : {
2207 : : UnsignedInt32 c_zero_int_data_size;
2208 : :
2209 [ + - ]: 11 : cio.Read(&c_zero_int_data_size, 1);
2210 [ - + ]: 11 : if (c_zero_int_data_size <= 0)
2211 : 0 : return CUBIT_FAILURE;
2212 [ + - ][ + - ]: 11 : UnsignedInt32 *c_zero_int32_data = new UnsignedInt32 [c_zero_int_data_size];
2213 [ + - ]: 11 : cio.Read(c_zero_int32_data, c_zero_int_data_size);
2214 [ + - ][ + - ]: 11 : int *c_zero_int_data = new int [c_zero_int_data_size];
2215 : : unsigned int jj;
2216 [ + + ]: 2475 : for (jj=0; jj<c_zero_int_data_size; jj++)
2217 : 2464 : c_zero_int_data[jj] = (int) c_zero_int32_data[jj];
2218 : :
2219 : : UnsignedInt32 c_zero_double_data_size;
2220 : :
2221 [ + - ]: 11 : cio.Read(&c_zero_double_data_size, 1);
2222 [ - + ]: 11 : if (c_zero_double_data_size <= 0) {
2223 [ # # ]: 0 : delete [] c_zero_int_data;
2224 [ # # ]: 0 : delete [] c_zero_int32_data;
2225 : 0 : return CUBIT_FAILURE;
2226 : : }
2227 [ + - ][ + - ]: 11 : double *c_zero_double_data = new double [c_zero_double_data_size];
2228 [ + - ]: 11 : cio.Read(c_zero_double_data, c_zero_double_data_size);
2229 : :
2230 : : // create the facet boundary tool datas and assign to points
2231 : :
2232 : 11 : int didx = 0;
2233 : 11 : int iidx = 0;
2234 : : UnsignedInt32 zz;
2235 [ + + ]: 187 : for (zz=0; zz<num_c_zero_points; zz++)
2236 : : {
2237 [ + - ][ - + ]: 176 : if (didx >= (int)c_zero_double_data_size ||
2238 : 176 : iidx >= (int)c_zero_int_data_size)
2239 : 0 : return CUBIT_FAILURE;
2240 : : TDFacetBoundaryPoint::new_facet_boundary_point( points, facets,
2241 [ + - ]: 176 : iidx, didx, c_zero_int_data, c_zero_double_data );
2242 : : }
2243 : :
2244 : : //Clean up
2245 [ + - ]: 11 : delete [] c_zero_int_data;
2246 [ + - ]: 11 : delete [] c_zero_int32_data;
2247 [ + - ]: 11 : delete [] c_zero_double_data;
2248 : : }
2249 : :
2250 [ + - ]: 11 : return CUBIT_SUCCESS;
2251 : : }
2252 : :
2253 : :
2254 : :
2255 : :
2256 : : //-------------------------------------------------------------------------
2257 : : // Purpose : Deletes all solid model entities associated with the
2258 : : // Bodies in the input list.
2259 : : //
2260 : : // Special Notes :
2261 : : //
2262 : : // Creator : Steve Owen
2263 : : //
2264 : : // Creation Date : 4/23/01
2265 : : //-------------------------------------------------------------------------
2266 : 0 : void FacetQueryEngine::delete_solid_model_entities(DLIList<BodySM*>&BodyList) const
2267 : : {
2268 : 0 : BodySM* BodyPtr = NULL;
2269 [ # # ]: 0 : for (int i = 0; i < BodyList.size(); i++ )
2270 : : {
2271 : 0 : BodyPtr = BodyList.get_and_step();
2272 : 0 : this->delete_solid_model_entities(BodyPtr);
2273 : : }
2274 : :
2275 : 0 : return;
2276 : : }
2277 : :
2278 : : //-------------------------------------------------------------------------
2279 : : // Purpose : Delete a FacetBody and child entities.
2280 : : //
2281 : : // Special Notes :
2282 : : //
2283 : : // Creator : Jason Kraftcheck
2284 : : //
2285 : : // Creation Date : 09/29/03
2286 : : //-------------------------------------------------------------------------
2287 : : CubitStatus
2288 : 0 : FacetQueryEngine::delete_solid_model_entities( BodySM* bodysm ) const
2289 : : {
2290 [ # # ]: 0 : FacetBody* fbody = dynamic_cast<FacetBody*>(bodysm);
2291 [ # # ]: 0 : if (!fbody)
2292 : 0 : return CUBIT_FAILURE;
2293 : :
2294 [ # # ]: 0 : DLIList<FacetLump*> lumps;
2295 [ # # ][ # # ]: 0 : DLIList<FacetShell*> shells;
2296 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> surfaces;
2297 : :
2298 [ # # ]: 0 : fbody->get_lumps(lumps);
2299 [ # # ]: 0 : fbody->disconnect_all_lumps();
2300 [ # # ][ # # ]: 0 : delete fbody;
2301 : :
2302 [ # # ][ # # ]: 0 : for (int i = lumps.size(); i--; )
2303 : : {
2304 [ # # ]: 0 : FacetLump* lump = lumps.get_and_step();
2305 : :
2306 [ # # ]: 0 : shells.clean_out();
2307 [ # # ]: 0 : lump->get_shells(shells);
2308 [ # # ]: 0 : lump->disconnect_all_shells();
2309 [ # # ][ # # ]: 0 : delete lump;
2310 : :
2311 [ # # ][ # # ]: 0 : for (int j = shells.size(); j--; )
2312 : : {
2313 [ # # ]: 0 : FacetShell* shell = shells.get_and_step();
2314 : :
2315 [ # # ]: 0 : surfaces.clean_out();
2316 [ # # ]: 0 : shell->get_surfaces(surfaces);
2317 [ # # ]: 0 : shell->disconnect_all_surfaces();
2318 [ # # ][ # # ]: 0 : delete shell;
2319 : :
2320 [ # # ][ # # ]: 0 : for (int k = surfaces.size(); k--; )
2321 : : {
2322 [ # # ]: 0 : FacetSurface* surface = surfaces.get_and_step();
2323 [ # # ][ # # ]: 0 : if (!surface->has_parent_shell())
2324 [ # # ]: 0 : delete_solid_model_entities(surface);
2325 : : }
2326 : : }
2327 : : }
2328 : :
2329 [ # # ]: 0 : return CUBIT_SUCCESS;
2330 : : }
2331 : :
2332 : : //-------------------------------------------------------------------------
2333 : : // Purpose : Delete a FacetSurface and child entities.
2334 : : //
2335 : : // Special Notes :
2336 : : //
2337 : : // Creator : Jason Kraftcheck
2338 : : //
2339 : : // Creation Date : 09/29/03
2340 : : //-------------------------------------------------------------------------
2341 : : CubitStatus
2342 : 0 : FacetQueryEngine::delete_solid_model_entities( Surface* surface ) const
2343 : : {
2344 [ # # ]: 0 : FacetSurface* fsurf = dynamic_cast<FacetSurface*>(surface);
2345 [ # # ][ # # ]: 0 : if (!fsurf || fsurf->has_parent_shell())
[ # # ][ # # ]
2346 : 0 : return CUBIT_FAILURE;
2347 : :
2348 [ # # ]: 0 : DLIList<FacetLoop*> loops;
2349 [ # # ][ # # ]: 0 : DLIList<FacetCoEdge*> coedges;
2350 : :
2351 [ # # ]: 0 : fsurf->get_loops(loops);
2352 [ # # ]: 0 : fsurf->disconnect_all_loops();
2353 [ # # ][ # # ]: 0 : delete fsurf;
2354 : :
2355 [ # # ][ # # ]: 0 : for (int i = loops.size(); i--; )
2356 : : {
2357 [ # # ]: 0 : FacetLoop* loop = loops.get_and_step();
2358 : :
2359 [ # # ]: 0 : coedges.clean_out();
2360 [ # # ]: 0 : loop->get_coedges(coedges);
2361 [ # # ]: 0 : loop->disconnect_all_coedges();
2362 [ # # ][ # # ]: 0 : delete loop;
2363 : :
2364 [ # # ][ # # ]: 0 : for (int j = coedges.size(); j--; )
2365 : : {
2366 [ # # ]: 0 : FacetCoEdge* coedge = coedges.get_and_step();
2367 [ # # ][ # # ]: 0 : FacetCurve* curve = dynamic_cast<FacetCurve*>(coedge->curve());
2368 [ # # ]: 0 : if (curve)
2369 : : {
2370 [ # # ]: 0 : curve->disconnect_coedge(coedge);
2371 [ # # ][ # # ]: 0 : if (!curve->has_parent_coedge())
2372 [ # # ]: 0 : delete_solid_model_entities(curve);
2373 : : }
2374 : :
2375 [ # # ][ # # ]: 0 : delete coedge;
2376 : : }
2377 : : }
2378 : :
2379 [ # # ]: 0 : return CUBIT_SUCCESS;
2380 : : }
2381 : :
2382 : : //-------------------------------------------------------------------------
2383 : : // Purpose : Delete a FacetCurve and child entities.
2384 : : //
2385 : : // Special Notes :
2386 : : //
2387 : : // Creator : Jason Kraftcheck
2388 : : //
2389 : : // Creation Date : 09/29/03
2390 : : //-------------------------------------------------------------------------
2391 : : CubitStatus
2392 : 0 : FacetQueryEngine::delete_solid_model_entities( Curve* curve ) const
2393 : : {
2394 [ # # ]: 0 : FacetCurve* fcurve = dynamic_cast<FacetCurve*>(curve);
2395 [ # # ][ # # ]: 0 : if (!fcurve || fcurve->has_parent_coedge())
[ # # ]
2396 : 0 : return CUBIT_FAILURE;
2397 : :
2398 [ # # ]: 0 : FacetPoint* start = dynamic_cast<FacetPoint*>(fcurve->start_point());
2399 [ # # ]: 0 : FacetPoint* end = dynamic_cast<FacetPoint*>(fcurve->end_point() );
2400 : :
2401 [ # # ]: 0 : if (start == end )
2402 : 0 : end = NULL;
2403 : :
2404 [ # # ]: 0 : if (start)
2405 : : {
2406 : 0 : start->disconnect_curve(fcurve);
2407 [ # # ]: 0 : if (!start->has_parent_curve())
2408 : 0 : delete_solid_model_entities(start);
2409 : : }
2410 : :
2411 [ # # ]: 0 : if (end)
2412 : : {
2413 : 0 : end->disconnect_curve(fcurve);
2414 [ # # ]: 0 : if (!end->has_parent_curve())
2415 : 0 : delete_solid_model_entities(end);
2416 : : }
2417 : :
2418 [ # # ]: 0 : delete curve;
2419 : 0 : return CUBIT_SUCCESS;
2420 : : }
2421 : :
2422 : : //-------------------------------------------------------------------------
2423 : : // Purpose : Delete a FacetPoint and child entities.
2424 : : //
2425 : : // Special Notes :
2426 : : //
2427 : : // Creator : Jason Kraftcheck
2428 : : //
2429 : : // Creation Date : 09/29/03
2430 : : //-------------------------------------------------------------------------
2431 : : CubitStatus
2432 : 0 : FacetQueryEngine::delete_solid_model_entities( TBPoint* point ) const
2433 : : {
2434 [ # # ]: 0 : FacetPoint* fpoint = dynamic_cast<FacetPoint*>(point);
2435 [ # # ][ # # ]: 0 : if (!fpoint || fpoint->has_parent_curve())
[ # # ]
2436 : 0 : return CUBIT_FAILURE;
2437 : :
2438 [ # # ]: 0 : delete point;
2439 : 0 : return CUBIT_SUCCESS;
2440 : : }
2441 : :
2442 : 0 : CubitStatus FacetQueryEngine::fire_ray( CubitVector &origin,
2443 : : CubitVector &direction,
2444 : : DLIList<TopologyBridge*> &at_entity_list,
2445 : : DLIList<double> &ray_params,
2446 : : int max_hits,
2447 : : double ray_radius,
2448 : : DLIList<TopologyBridge*> *hit_entity_list) const
2449 : : {
2450 : :
2451 : : TopologyBridge *bridge_ptr;
2452 : : int i, j;
2453 : 0 : bool hit = false;
2454 : :
2455 [ # # ]: 0 : DLIList<double> tmp_ray_params;
2456 [ # # ][ # # ]: 0 : DLIList<FacetSurface*> at_surface_list;
2457 [ # # ][ # # ]: 0 : DLIList<FacetCurve*> at_curve_list;
2458 [ # # ][ # # ]: 0 : DLIList<FacetPoint*> at_point_list;
2459 : :
2460 [ # # ]: 0 : if( ray_radius == 0.0 )
2461 [ # # ]: 0 : ray_radius = get_sme_resabs_tolerance();
2462 : :
2463 [ # # ]: 0 : at_entity_list.reset();
2464 [ # # ][ # # ]: 0 : for (i=0; i<at_entity_list.size(); i++)
2465 : : {
2466 : 0 : hit = false;
2467 [ # # ]: 0 : bridge_ptr = at_entity_list.get_and_step();
2468 : :
2469 : : //determine which type of geometry we have. body, lump, face, curve?
2470 [ # # ][ # # ]: 0 : if (CAST_TO(bridge_ptr, FacetBody))
[ # # ]
2471 : : {
2472 [ # # ]: 0 : FacetBody* f_body = CAST_TO(bridge_ptr, FacetBody);
2473 [ # # ]: 0 : DLIList<Surface*> surface_list;
2474 [ # # ][ # # ]: 0 : f_body->surfaces(surface_list);
2475 : : }
2476 [ # # ][ # # ]: 0 : else if (CAST_TO(bridge_ptr, FacetLump))
[ # # ]
2477 : : {
2478 [ # # ]: 0 : FacetLump* f_lump = CAST_TO(bridge_ptr, FacetLump);
2479 [ # # ][ # # ]: 0 : PRINT_INFO("Found FacetLump.\n");
[ # # ][ # # ]
2480 [ # # ]: 0 : DLIList<FacetSurface*> f_surface_list;
2481 [ # # ]: 0 : f_lump->get_surfaces(f_surface_list);
2482 [ # # ][ # # ]: 0 : at_surface_list.merge_unique(f_surface_list);
2483 : : }
2484 [ # # ][ # # ]: 0 : else if (CAST_TO(bridge_ptr, Surface))
[ # # ]
2485 : : {
2486 [ # # ]: 0 : FacetSurface* f_surface = CAST_TO(bridge_ptr, FacetSurface);
2487 : :
2488 [ # # ]: 0 : DLIList<CubitFacet*> facet_list;
2489 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> point_list;
2490 [ # # ]: 0 : f_surface->get_my_facets(facet_list, point_list);
2491 : :
2492 : : //PRINT_INFO("There are %d facets.\n", facet_list.size());
2493 : :
2494 : : //RTree<CubitFacet*> rtree(ray_radius);
2495 : : //for (j=0; j<facet_list.size(); j++)
2496 : : // rtree.add(facet_list.get_and_step();
2497 : :
2498 : : //DLIList<CubitFacet*> facet_list1;
2499 : : //CubitBox range_box();
2500 : : //make range box for the ray
2501 : : //rtree.find(range_box, facet_list1);
2502 : :
2503 [ # # ][ # # ]: 0 : CubitVector* intersection_pt = new CubitVector();
2504 : : double distance;
2505 : :
2506 [ # # ][ # # ]: 0 : for (j=0; j<facet_list.size(); j++)
2507 : : {
2508 [ # # ]: 0 : if (hit)
2509 : 0 : break;
2510 : :
2511 [ # # ]: 0 : CubitFacet* facet = facet_list.get_and_step();
2512 : :
2513 : : // Find intersection of ray with triangle
2514 [ # # ]: 0 : int rv = FacetEvalTool::intersect_ray(origin, direction, facet, intersection_pt, distance);
2515 : :
2516 [ # # # # : 0 : switch (rv)
# ]
2517 : : {
2518 : : case -1:
2519 : : //PRINT_INFO("Facet is degenerate (segment or point).\n");
2520 : 0 : break;
2521 : : case 0:
2522 : : //PRINT_INFO("Ray does not intersect the facet.\n");
2523 : 0 : break;
2524 : : case 1:
2525 : : {
2526 : 0 : hit = true;
2527 [ # # ]: 0 : if (hit_entity_list)
2528 [ # # ]: 0 : hit_entity_list->append(bridge_ptr);
2529 [ # # ]: 0 : ray_params.append(distance);
2530 : : //PRINT_INFO("Ray intersects facet at %f, %f, %f.\n", intersection_pt->x(), intersection_pt->y(), intersection_pt->z());
2531 : :
2532 : 0 : continue;
2533 : : }
2534 : : case 2:
2535 : : //PRINT_INFO("Ray is in same plane as the facet.\n");
2536 : 0 : break;
2537 : : }
2538 : : }
2539 [ # # ]: 0 : if (intersection_pt)
2540 [ # # ]: 0 : delete intersection_pt;
2541 : :
2542 : : }
2543 [ # # ][ # # ]: 0 : else if (CAST_TO(bridge_ptr, Curve))
[ # # ]
2544 : : {
2545 [ # # ]: 0 : FacetCurve* f_curve = CAST_TO(bridge_ptr, FacetCurve);
2546 [ # # ]: 0 : DLIList<CubitFacetEdge*> facet_edge_list;
2547 [ # # ]: 0 : f_curve->get_facets(facet_edge_list);
2548 : :
2549 : : //PRINT_INFO("There are %d facetedges.\n", facet_edge_list.size());
2550 [ # # ][ # # ]: 0 : CubitVector* intersection_pt = new CubitVector();
2551 : : double distance;
2552 : :
2553 [ # # ][ # # ]: 0 : for (j=0; j<facet_edge_list.size(); j++)
2554 : : {
2555 [ # # ]: 0 : if (hit)
2556 : 0 : break;
2557 : :
2558 [ # # ]: 0 : CubitFacetEdge* facet_edge = facet_edge_list.get_and_step();
2559 : :
2560 [ # # ]: 0 : int rv = FacetEvalTool::intersect_ray(origin, direction, facet_edge, intersection_pt, distance);
2561 : :
2562 [ # # # # : 0 : switch (rv)
# ]
2563 : : {
2564 : : case -1:
2565 : : //PRINT_INFO("Facet is degenerate (segment or point).\n");
2566 : 0 : break;
2567 : : case 0:
2568 : : //PRINT_INFO("Ray does not intersect the facet edge.\n");
2569 : 0 : break;
2570 : : case 1:
2571 : : {
2572 : 0 : hit = true;
2573 [ # # ]: 0 : if (hit_entity_list)
2574 [ # # ]: 0 : hit_entity_list->append(bridge_ptr);
2575 [ # # ]: 0 : ray_params.append(distance);
2576 : : //PRINT_INFO("Ray intersects facet at %f, %f, %f.\n", intersection_pt->x(), intersection_pt->y(), intersection_pt->z());
2577 : :
2578 : 0 : continue;
2579 : : }
2580 : : case 2:
2581 : : //PRINT_INFO("Ray is parallel to the facet.\n");
2582 : 0 : break;
2583 : : }
2584 : :
2585 : : }
2586 [ # # ]: 0 : if (intersection_pt)
2587 [ # # ]: 0 : delete intersection_pt;
2588 : : }
2589 [ # # ][ # # ]: 0 : else if (CAST_TO(bridge_ptr, FacetPoint))
[ # # ]
2590 : : {
2591 [ # # ]: 0 : FacetPoint* f_point = CAST_TO(bridge_ptr, FacetPoint);
2592 [ # # ]: 0 : at_point_list.append_unique(f_point);
2593 : : }
2594 : : else
2595 : : ;//PRINT_INFO("Cast error in FacetQueryEngine::fire_ray.\n");
2596 : :
2597 : : }
2598 : :
2599 [ # # ]: 0 : return CUBIT_SUCCESS;
2600 : : }
2601 : : //- fire a ray at the specified entities, returning the parameters
2602 : : //- (distances) along the ray and optionally the entities hit
2603 : :
2604 : :
2605 : 0 : double FacetQueryEngine::get_sme_resabs_tolerance() const
2606 : : {
2607 : 0 : return GEOMETRY_RESABS;
2608 : : }
2609 : : // Gets solid modeler's resolution absolute tolerance
2610 : :
2611 : 0 : double FacetQueryEngine::set_sme_resabs_tolerance( double )
2612 : : {
2613 [ # # ][ # # ]: 0 : PRINT_ERROR("FacetQueryEngine::set_sme_resabs_tolerance not yet implemented.\n");
2614 : 0 : return CUBIT_FAILURE;
2615 : : }
2616 : :
2617 : 0 : CubitStatus FacetQueryEngine::set_int_option( const char* , int )
2618 : : {
2619 [ # # ][ # # ]: 0 : PRINT_ERROR("FacetQueryEngine::set_int_option not yet implemented.\n");
2620 : 0 : return CUBIT_FAILURE;
2621 : : }
2622 : :
2623 : 0 : CubitStatus FacetQueryEngine::set_dbl_option( const char* , double )
2624 : : {
2625 [ # # ][ # # ]: 0 : PRINT_ERROR("FacetQueryEngine::set_dbl_option not yet implemented.\n");
2626 : 0 : return CUBIT_FAILURE;
2627 : : }
2628 : :
2629 : 0 : CubitStatus FacetQueryEngine::set_str_option( const char* , const char* )
2630 : : {
2631 [ # # ][ # # ]: 0 : PRINT_ERROR("FacetQueryEngine::set_str_option not yet implemented.\n");
2632 : 0 : return CUBIT_FAILURE;
2633 : : }
2634 : : //- Set solid modeler options
2635 : :
2636 : : //===========================================================================
2637 : : //Function Name: make_facets
2638 : : //Member Type: PUBLIC
2639 : : //Description: creates Cubit quad facet entities from the hash points and
2640 : : // connectivity
2641 : : //===========================================================================
2642 : 0 : CubitStatus FacetQueryEngine::make_facets(
2643 : : int *conn, // conectivity array (size = 4 * nfacets)
2644 : : int nfacets, // total number of facets (tri+quad)
2645 : : DLIList<CubitQuadFacet *> &facet_list ) // return the facet list
2646 : : {
2647 : 0 : CubitQuadFacet *facet_ptr = NULL;
2648 : 0 : CubitStatus rv = CUBIT_SUCCESS;
2649 : : CubitPoint *point0, *point1, *point2, *point3;
2650 : :
2651 : : // create the facet array
2652 : :
2653 [ # # ]: 0 : for(int ii=0; ii<nfacets; ii++)
2654 : : {
2655 [ # # ]: 0 : if (conn[ii*4+2] != conn[ii*4+3])
2656 : : {
2657 [ # # ]: 0 : point0 = get_hash_point(conn[ii*4]);
2658 [ # # ]: 0 : point1 = get_hash_point(conn[ii*4+1]);
2659 [ # # ]: 0 : point2 = get_hash_point(conn[ii*4+2]);
2660 [ # # ]: 0 : point3 = get_hash_point(conn[ii*4+3]);
2661 : :
2662 [ # # ][ # # ]: 0 : facet_ptr = new CubitQuadFacetData( point0, point1, point2, point3 );
2663 : :
2664 [ # # ]: 0 : if (!facet_ptr)
2665 : : {
2666 : 0 : rv = CUBIT_FAILURE;
2667 : 0 : return rv;
2668 : : }
2669 [ # # ]: 0 : facet_list.append( facet_ptr );
2670 : : }
2671 : : }
2672 : 0 : return rv;
2673 : : }
2674 : :
2675 : : //===========================================================================
2676 : : //Function Name: make_facets
2677 : : //Member Type: PUBLIC
2678 : : //Description: creates Cubit tri facet entities from the hash points and
2679 : : // connectivity
2680 : : //===========================================================================
2681 : 0 : CubitStatus FacetQueryEngine::make_facets(
2682 : : int *conn, // conectivity array (size = 4 * nfacets)
2683 : : int nfacets, // total number of facets (tri+quad)
2684 : : DLIList<CubitFacet *> &facet_list ) // return the facet list
2685 : : {
2686 : 0 : CubitFacet *facet_ptr = NULL;
2687 : 0 : CubitStatus rv = CUBIT_SUCCESS;
2688 : : CubitPoint *point0, *point1, *point2;
2689 : :
2690 : : // create the facet array
2691 : :
2692 [ # # ]: 0 : for(int ii=0; ii<nfacets; ii++)
2693 : : {
2694 [ # # ]: 0 : if (conn[ii*4+2] == conn[ii*4+3])
2695 : : {
2696 [ # # ]: 0 : point0 = get_hash_point(conn[ii*4]);
2697 [ # # ]: 0 : point1 = get_hash_point(conn[ii*4+1]);
2698 [ # # ]: 0 : point2 = get_hash_point(conn[ii*4+2]);
2699 [ # # ][ # # ]: 0 : if( (point0 == point1) || (point0 == point2) || (point1 == point2) ){
[ # # ]
2700 [ # # ][ # # ]: 0 : PRINT_ERROR("Point used more than once in a single facet. This is not allowed.\n");
[ # # ][ # # ]
2701 : 0 : return CUBIT_FAILURE;
2702 : : }
2703 [ # # ][ # # ]: 0 : if( !point0 || !point1 || !point2 ){
[ # # ]
2704 [ # # ][ # # ]: 0 : PRINT_ERROR("Point in facet is undefined. This is not allowed.\n");
[ # # ][ # # ]
2705 : 0 : return CUBIT_FAILURE;
2706 : : }
2707 : :
2708 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( point0, point1, point2 );
2709 : :
2710 [ # # ]: 0 : if (!facet_ptr)
2711 : : {
2712 : 0 : rv = CUBIT_FAILURE;
2713 : 0 : return rv;
2714 : : }
2715 [ # # ]: 0 : facet_list.append( facet_ptr );
2716 : : }
2717 : : }
2718 : :
2719 : 0 : return rv;
2720 : : }
2721 : :
2722 : : //===========================================================================
2723 : : //Function Name: ensure_is_ascii_stl_file
2724 : : //Member Type:
2725 : : //Description: returns CUBIT_TRUE in is_ascii if fp is an ascii stl file
2726 : : //Author: Plamen Stoyanov (USF)
2727 : : //===========================================================================
2728 : 11 : CubitStatus FacetQueryEngine::ensure_is_ascii_stl_file(FILE * fp, CubitBoolean &is_ascii)
2729 : : {
2730 : :
2731 : 11 : char line[128]="";
2732 : :
2733 [ + - ][ - + ]: 11 : if (fgets(line, 128, fp)==NULL)
2734 : : {
2735 : 0 : return CUBIT_FAILURE;
2736 : : }
2737 [ + - ][ - + ]: 11 : if (fgets(line, 128, fp)==NULL)
2738 : : {
2739 : 0 : return CUBIT_FAILURE;
2740 : : }
2741 [ - + ]: 11 : if (strlen(line)==127)
2742 : : {
2743 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)==NULL)
2744 : : {
2745 : 0 : return CUBIT_FAILURE;
2746 : : }
2747 : : }
2748 : :
2749 : :
2750 : 11 : unsigned int dummy_int=0;
2751 : :
2752 : : // One of the functions called by isspace() has an assert that can fail in debug mode if
2753 : : // line[dummy_int] is negative so check for it here.
2754 [ + - ][ - + ]: 11 : while (line[dummy_int] > -1 && isspace(line[dummy_int]) && dummy_int < strlen(line))
[ # # ]
2755 : 0 : dummy_int++;
2756 : :
2757 [ + - ]: 11 : if (strlen(line)-dummy_int>5)
2758 : : {
2759 [ + - ][ + - ]: 22 : if (tolower(line[dummy_int++])=='f' &&
2760 [ + - ]: 11 : tolower(line[dummy_int++])=='a' &&
2761 [ + - ]: 11 : tolower(line[dummy_int++])=='c' &&
2762 [ + - ][ + - ]: 22 : tolower(line[dummy_int++])=='e' &&
2763 : 11 : tolower(line[dummy_int])=='t')
2764 : : {
2765 [ + - ][ - + ]: 11 : if (fgets(line, 128, fp)==NULL)
2766 : : {
2767 : 0 : return CUBIT_FAILURE;
2768 : : }
2769 : 11 : dummy_int=0;
2770 [ - + ][ # # ]: 11 : while (isspace(line[dummy_int])&& dummy_int<strlen(line))
2771 : : {
2772 : 0 : dummy_int++;
2773 : : }
2774 [ + - ]: 11 : if (strlen(line)-dummy_int>5)
2775 : : {
2776 [ + - ][ + - ]: 22 : if (tolower(line[dummy_int++])=='o' &&
2777 [ + - ]: 11 : tolower(line[dummy_int++])=='u' &&
2778 [ + - ]: 11 : tolower(line[dummy_int++])=='t' &&
2779 [ + - ][ + - ]: 22 : tolower(line[dummy_int++])=='e' &&
2780 : 11 : tolower(line[dummy_int])=='r')
2781 : : {
2782 [ + - ][ - + ]: 11 : if (fgets(line, 128, fp)==NULL)
2783 : : {
2784 : 0 : return CUBIT_FAILURE;
2785 : : }
2786 : 11 : dummy_int=0;
2787 [ - + ][ # # ]: 11 : while (isspace(line[dummy_int])&& dummy_int<strlen(line)) {
2788 : 0 : dummy_int++;
2789 : : }
2790 [ + - ]: 11 : if (strlen(line)-dummy_int>6)
2791 : : {
2792 [ + - ][ + - ]: 22 : if (tolower(line[dummy_int++])=='v' &&
2793 [ + - ]: 11 : tolower(line[dummy_int++])=='e' &&
2794 [ + - ]: 11 : tolower(line[dummy_int++])=='r' &&
2795 [ + - ]: 11 : tolower(line[dummy_int++])=='t' &&
2796 [ + - ][ + - ]: 22 : tolower(line[dummy_int++])=='e' &&
2797 : 11 : tolower(line[dummy_int])=='x')
2798 : : {
2799 : 11 : is_ascii=CUBIT_TRUE;
2800 : : }
2801 : : }
2802 : : }
2803 : : }
2804 : : }
2805 : : }
2806 : 11 : return CUBIT_SUCCESS;
2807 : : }
2808 : :
2809 : : //===========================================================================
2810 : : //Function Name: read_facets_stl
2811 : : //Member Type:
2812 : : //Description: read facets from stl file combining vertices within tolerance
2813 : : //distance
2814 : : //Author: Plamen Stoyanov (USF)
2815 : : //===========================================================================
2816 : 11 : CubitStatus FacetQueryEngine::read_facets_stl_tolerance(
2817 : : DLIList<CubitFacet *> &tfacet_list,
2818 : : DLIList<CubitPoint *> & /*point_list*/,
2819 : : const char * file_name,
2820 : : int &npoints,
2821 : : int &ntri,
2822 : : long& seek_address,
2823 : : double tolerance
2824 : : )
2825 : : {
2826 : :
2827 [ + - ]: 11 : FILE *fp = fopen(file_name, "r");
2828 [ - + ]: 11 : if (fp == NULL)
2829 : : {
2830 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not open file %s for reading\n", file_name);
[ # # ][ # # ]
2831 : 0 : seek_address = 0;
2832 : 0 : return CUBIT_FAILURE;
2833 : : }
2834 : :
2835 [ + - ]: 11 : DLIList <CubitPoint *> file_points;
2836 : : CubitPoint *current_point;
2837 : 11 : int points_in_file=0;
2838 : : int ii;
2839 : :
2840 : 11 : CubitBoolean is_ascii=CUBIT_FALSE;
2841 [ + - ][ - + ]: 11 : if (!ensure_is_ascii_stl_file(fp, is_ascii))
2842 : : {
2843 : 0 : seek_address = 0;
2844 [ # # ]: 0 : fclose(fp);
2845 : 0 : return CUBIT_FAILURE;
2846 : : }
2847 : :
2848 [ + - ]: 11 : if (is_ascii==CUBIT_TRUE)
2849 : : {
2850 : :
2851 [ + - ][ + - ]: 11 : PRINT_INFO("Reading facets...\n");
[ + - ][ + - ]
2852 [ + - ]: 11 : fclose(fp);
2853 [ + - ]: 11 : fp = fopen(file_name, "r");
2854 : 11 : fseek(fp,seek_address,SEEK_SET);
2855 : :
2856 : : char line[128], junk[30];
2857 : : int numverts;
2858 : : double xx[3], yy[3], zz[3];
2859 : : int linenumber, num;
2860 : : bool done, error_found, eof_found;
2861 : :
2862 : 11 : linenumber = 0;
2863 : :
2864 : 11 : strcpy(line,"");
2865 : 11 : done = false;
2866 : 11 : error_found = false;
2867 : 11 : eof_found = false;
2868 [ + - ][ + - ]: 143 : while ( (strstr(line,"endsolid") == 0) && (error_found == false) ) {
2869 : 143 : numverts = 0;
2870 [ + + ]: 1078 : while ( numverts < 3 ) {
2871 [ + - ][ - + ]: 946 : if ( fgets(line,127,fp) == 0 ) {
2872 : 0 : linenumber++;
2873 : 0 : eof_found = true;
2874 : 0 : break; // EOF
2875 : : }
2876 : 946 : linenumber++;
2877 : : // makelowercase(line);
2878 : : int len, ij;
2879 : 946 : len = strlen(line);
2880 [ + + ]: 34639 : for ( ij = 0; ij < len; ij++ )
2881 : 33693 : line[ij] = tolower(line[ij]);
2882 : :
2883 [ + + ]: 946 : if ( strstr(line,"endsolid") != 0 ) {
2884 : 11 : done = true;
2885 : 11 : break; // End of part definition
2886 : : }
2887 [ + + ]: 935 : if ( strstr(line,"vertex") != 0 ) {
2888 : 396 : num = sscanf(line,"%s %le %le %le",junk,&xx[numverts],&yy[numverts],&zz[numverts]);
2889 [ - + ]: 396 : if ( num != 4 ) {
2890 : 0 : error_found = true;
2891 : 0 : break; // error in reading vertices
2892 : : }
2893 : 396 : numverts += 1;
2894 : : }
2895 : : } // end of while ( numverts < 3 )
2896 : :
2897 [ + - ][ + + ]: 143 : if ( (eof_found == true) || (done == true) ||
[ + - ]
2898 [ + - ]: 132 : (error_found == true) || (numverts != 3) ) break;
2899 : :
2900 [ + - ][ + - ]: 132 : current_point = (CubitPoint *) new CubitPointData(xx[0],yy[0],zz[0]);
2901 [ + - ]: 132 : current_point->set_id(points_in_file++);
2902 [ + - ]: 132 : file_points.append(current_point);
2903 [ + - ][ + - ]: 132 : current_point = (CubitPoint *) new CubitPointData(xx[1],yy[1],zz[1]);
2904 [ + - ]: 132 : current_point->set_id(points_in_file++);
2905 [ + - ]: 132 : file_points.append(current_point);
2906 [ + - ][ + - ]: 132 : current_point = (CubitPoint *) new CubitPointData(xx[2],yy[2],zz[2]);
2907 [ + - ]: 132 : current_point->set_id(points_in_file++);
2908 [ + - ]: 132 : file_points.append(current_point);
2909 : :
2910 : : }
2911 : 11 : seek_address = 0;
2912 [ - + ]: 11 : if ( eof_found == true ) {
2913 [ # # ][ # # ]: 0 : PRINT_WARNING("Premature end-of-file on STL file. Body may be incomplete.\n");
[ # # ][ # # ]
2914 [ # # ]: 0 : fclose(fp);
2915 : 0 : goto end_read_file_points;
2916 : : }
2917 [ - + ]: 11 : if ( error_found == true ) {
2918 [ # # ][ # # ]: 0 : PRINT_WARNING("Error found while reading line number %d of file %s. Body may be incomplete.\n",
[ # # ]
2919 [ # # ]: 0 : linenumber,file_name);
2920 [ # # ]: 0 : fclose(fp);
2921 : 0 : goto end_read_file_points;
2922 : : }
2923 [ - + ]: 11 : if ( done == false ) {
2924 [ # # ][ # # ]: 0 : PRINT_WARNING("Error found while reading line number %d of file %s. Body may be incomplete.\n",
[ # # ]
2925 [ # # ]: 0 : linenumber,file_name);
2926 [ # # ]: 0 : fclose(fp);
2927 : 0 : goto end_read_file_points;
2928 : : }
2929 : :
2930 [ + - ][ + - ]: 11 : if ( (eof_found == false) && (error_found == false) && (done == true) ) {
[ + - ]
2931 [ + - ][ - + ]: 11 : while ( fgets(line,127,fp) != 0 ) {
2932 [ # # ][ # # ]: 0 : if ( (strstr(line,"solid") != 0) && (strstr(line,"endsolid") == 0) ) {
2933 [ # # ]: 0 : seek_address = ftell(fp);
2934 : 0 : break;
2935 : : }
2936 : : }
2937 : : }
2938 [ + - ]: 11 : fclose(fp);
2939 : 11 : goto end_read_file_points;
2940 : : }
2941 : : else
2942 : : {
2943 [ # # ]: 0 : fclose(fp);
2944 : : // file is closed so that it can be opened as binary
2945 [ # # ]: 0 : fp = fopen(file_name, "rb");
2946 [ # # ]: 0 : if (fp == NULL)
2947 : : {
2948 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not open file %s for reading\n", file_name);
[ # # ][ # # ]
2949 : 0 : return CUBIT_FAILURE;
2950 : : }
2951 : :
2952 : : char dummy;
2953 : : // iterates through the facets of the file
2954 : : float cur[12]; // an array to hold 48 bytes representing 1AVS facet
2955 : :
2956 : 0 : fseek(fp, 80, SEEK_SET);
2957 [ # # ]: 0 : size_t count = fread(&ntri, 4, 1, fp);
2958 [ # # ]: 0 : if (count != 1) {
2959 [ # # ][ # # ]: 0 : PRINT_ERROR("Trouble reading in number of triangles\n");
[ # # ][ # # ]
2960 : 0 : return CUBIT_FAILURE;
2961 : : }
2962 : :
2963 [ # # ][ # # ]: 0 : PRINT_INFO ("Reading facets...\n");
[ # # ][ # # ]
2964 [ # # ]: 0 : for (ii=0; ii<ntri; ii++) {
2965 : : // read in 1 facet
2966 [ # # ][ # # ]: 0 : if (fread(cur, 4, 12, fp) != 12)
2967 : : {
2968 [ # # ][ # # ]: 0 : PRINT_INFO ("Abnormal file termination %s \n", file_name); break;
[ # # ][ # # ]
2969 : : }
2970 [ # # ]: 0 : count = fread(&dummy, 1, 1, fp);
2971 [ # # ]: 0 : count = fread(&dummy, 1, 1, fp);
2972 : :
2973 : : //make point
2974 [ # # ][ # # ]: 0 : current_point = (CubitPoint *) new CubitPointData(cur[3],cur[4],cur[5]);
2975 [ # # ]: 0 : current_point->set_id(points_in_file++);
2976 [ # # ]: 0 : file_points.append(current_point);
2977 [ # # ][ # # ]: 0 : current_point = (CubitPoint *) new CubitPointData(cur[6],cur[7],cur[8]);
2978 [ # # ]: 0 : current_point->set_id(points_in_file++);
2979 [ # # ]: 0 : file_points.append(current_point);
2980 [ # # ][ # # ]: 0 : current_point = (CubitPoint *) new CubitPointData(cur[9],cur[10],cur[11]);
2981 [ # # ]: 0 : current_point->set_id(points_in_file++);
2982 [ # # ]: 0 : file_points.append(current_point);
2983 : : }
2984 : : }
2985 [ # # ]: 0 : fclose(fp);
2986 : :
2987 : : // at this point all points from the file are in file_points
2988 : : end_read_file_points:
2989 : :
2990 : : // grid search tree to hold points
2991 [ + - ][ + - ]: 11 : GridSearchTree * node_grid = new GridSearchTree (tolerance);
2992 : :
2993 : : CubitPoint
2994 : : *point0,
2995 : : *point1,
2996 : : *point2;
2997 : : CubitFacet
2998 : : *facet_ptr;
2999 : 11 : ntri=0;
3000 : 11 : npoints=0;
3001 : :
3002 [ + - ][ - + ]: 11 : if (file_points.size() % 3 != 0)
3003 : : {
3004 [ # # ][ # # ]: 0 : PRINT_INFO("File Error.");
[ # # ][ # # ]
3005 : 0 : return CUBIT_FAILURE;
3006 : : }
3007 : :
3008 [ + - ][ + + ]: 143 : for (ii = file_points.size(); ii>0; ii-=3)
3009 : : {
3010 : :
3011 : : // get three points from the file_points list
3012 : : // and compare them against the data already in the
3013 : : // grid search tree; if it contains a point within
3014 : : // epsilon tolerance this point would replace the
3015 : : // current point
3016 [ + - ][ + - ]: 132 : point0 = node_grid->fix(file_points.get_and_step());
3017 [ + - ][ + - ]: 132 : point1 = node_grid->fix(file_points.get_and_step());
3018 [ + - ][ + - ]: 132 : point2 = node_grid->fix(file_points.get_and_step());
3019 : :
3020 : :
3021 [ + - ][ + - ]: 132 : if (point0 && point1 && point2 && point0 != point1 && point1!=point2 && point2!=point0 )
[ + - ][ + - ]
[ + - ][ + - ]
3022 : : {
3023 : :
3024 [ + - ][ + - ]: 132 : facet_ptr = new CubitFacetData(point0, point1, point2);
3025 : :
3026 [ + - ]: 132 : if (facet_ptr)
3027 : : {
3028 [ + - ]: 132 : tfacet_list.append(facet_ptr);
3029 : 132 : ntri++;
3030 : : }
3031 : :
3032 : : }
3033 : : }
3034 : :
3035 : : //delete node_grid;
3036 [ + - ]: 11 : return CUBIT_SUCCESS;
3037 : : }
3038 : :
3039 : :
3040 : : //===========================================================================
3041 : : //Function Name: read_facets_stl
3042 : : //Member Type:
3043 : : //Description: read facets from stl file
3044 : : //Author: Plamen Stoyanov (USF)
3045 : : //===========================================================================
3046 : :
3047 : 0 : CubitStatus FacetQueryEngine::read_facets_stl(
3048 : : DLIList<CubitFacet *> &tfacet_list,
3049 : : DLIList<CubitPoint *> &point_list,
3050 : : const char * file_name,
3051 : : int &npoints,
3052 : : int &ntri,
3053 : : long& seek_address
3054 : : )
3055 : : {
3056 : :
3057 : 0 : ntri = 0;
3058 : 0 : npoints = 0;
3059 [ # # ]: 0 : FILE *fp = fopen(file_name, "r");
3060 [ # # ]: 0 : if (fp == NULL)
3061 : : {
3062 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not open file %s for reading\n", file_name);
[ # # ][ # # ]
3063 : 0 : seek_address = 0;
3064 : 0 : return CUBIT_FAILURE;
3065 : : }
3066 : :
3067 : : typedef std::map< CubitPoint * , int, CubitPointComparator > vMap;
3068 : :
3069 [ # # ]: 0 : vMap mm; // binary search tree to hold the vertices for efficiency
3070 [ # # ]: 0 : vMap::iterator pos;
3071 : 0 : bool append_to_facet_list=CUBIT_TRUE;
3072 : :
3073 : 0 : CubitBoolean is_ascii=CUBIT_FALSE;
3074 : :
3075 [ # # ][ # # ]: 0 : if (!ensure_is_ascii_stl_file(fp, is_ascii))
3076 : : {
3077 : 0 : seek_address = 0;
3078 [ # # ]: 0 : fclose(fp);
3079 : 0 : return CUBIT_FAILURE;
3080 : : }
3081 : :
3082 [ # # ]: 0 : if (is_ascii==CUBIT_TRUE)
3083 : : {
3084 : : CubitPoint *point0,*point1,*point2;
3085 : 0 : CubitFacet *facet_ptr = NULL;
3086 : :
3087 [ # # ][ # # ]: 0 : PRINT_INFO("Reading facets...\n");
[ # # ][ # # ]
3088 [ # # ]: 0 : fclose(fp);
3089 [ # # ]: 0 : fp = fopen(file_name, "r");
3090 : 0 : fseek(fp,seek_address,SEEK_SET);
3091 : : char line[128], junk[30];
3092 : : int numverts;
3093 : : double xx[3], yy[3], zz[3];
3094 : : int linenumber, num;
3095 : : bool done, error_found, eof_found;
3096 : :
3097 : 0 : linenumber = 0;
3098 : :
3099 : 0 : strcpy(line,"");
3100 : 0 : done = false;
3101 : 0 : error_found = false;
3102 : 0 : eof_found = false;
3103 [ # # ][ # # ]: 0 : while ( (strstr(line,"endsolid") == 0) && (error_found == false) ) {
3104 : 0 : numverts = 0;
3105 [ # # ]: 0 : while ( numverts < 3 ) {
3106 [ # # ][ # # ]: 0 : if ( fgets(line,127,fp) == 0 ) {
3107 : 0 : linenumber++;
3108 : 0 : eof_found = true;
3109 : 0 : break; // EOF
3110 : : }
3111 : 0 : linenumber++;
3112 : : // makelowercase(line);
3113 : : int len, ij;
3114 : 0 : len = strlen(line);
3115 [ # # ]: 0 : for ( ij = 0; ij < len; ij++ )
3116 : 0 : line[ij] = tolower(line[ij]);
3117 : :
3118 [ # # ]: 0 : if ( strstr(line,"endsolid") != 0 ) {
3119 : 0 : done = true;
3120 : 0 : break; // End of part definition
3121 : : }
3122 [ # # ]: 0 : if ( strstr(line,"vertex") != 0 ) {
3123 : 0 : num = sscanf(line,"%s %le %le %le",junk,&xx[numverts],&yy[numverts],&zz[numverts]);
3124 [ # # ]: 0 : if ( num != 4 ) {
3125 : 0 : error_found = true;
3126 : 0 : break; // error in reading vertices
3127 : : }
3128 : 0 : numverts += 1;
3129 : : }
3130 : : } // end of while ( numverts < 3 )
3131 : :
3132 [ # # ][ # # ]: 0 : if ( (eof_found == true) || (done == true) ||
[ # # ]
3133 [ # # ]: 0 : (error_found == true) || (numverts != 3) ) break;
3134 [ # # ][ # # ]: 0 : point0 = (CubitPoint *) new CubitPointData(xx[0],yy[0],zz[0]);
3135 [ # # ]: 0 : pos=mm.find(point0);
3136 : :
3137 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3138 : : {
3139 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point0, npoints));
3140 [ # # ]: 0 : point0->set_id( npoints ++ );
3141 : : //point_list is output of functionAVS
3142 [ # # ]: 0 : point_list.append(point0);
3143 : : }
3144 : : else
3145 : : {
3146 [ # # ][ # # ]: 0 : delete point0;
3147 [ # # ]: 0 : point0=((*pos).first);
3148 : : }
3149 [ # # ][ # # ]: 0 : point1 = (CubitPoint *) new CubitPointData(xx[1],yy[1],zz[1]);
3150 [ # # ]: 0 : pos=mm.find(point1);
3151 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3152 : : {
3153 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point1, npoints));
3154 [ # # ]: 0 : point1->set_id( npoints ++ );
3155 : : //point_list is output of function
3156 [ # # ]: 0 : point_list.append(point1);
3157 : : }
3158 : : else
3159 : : {
3160 [ # # ][ # # ]: 0 : delete point1;
3161 [ # # ]: 0 : point1=((*pos).first);
3162 : : }
3163 [ # # ][ # # ]: 0 : point2 = (CubitPoint *) new CubitPointData(xx[2],yy[2],zz[2]);
3164 [ # # ]: 0 : pos=mm.find(point2);
3165 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3166 : : {
3167 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point2, npoints));
3168 [ # # ]: 0 : point2->set_id( npoints ++ );
3169 : : //point_list is output of function
3170 [ # # ]: 0 : point_list.append(point2);
3171 : : }
3172 : : else
3173 : : {
3174 [ # # ][ # # ]: 0 : delete point2;
3175 [ # # ]: 0 : point2=((*pos).first);
3176 : : }
3177 : :
3178 [ # # ][ # # ]: 0 : if (point0 && point1 && point2 && point0!=point1 && point1!=point2 && point2 !=point0)
[ # # ][ # # ]
[ # # ][ # # ]
3179 : : {
3180 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( point0, point1, point2 );
3181 : 0 : append_to_facet_list=CUBIT_TRUE;
3182 : : }
3183 : : else
3184 : : {
3185 : 0 : append_to_facet_list=CUBIT_FALSE;
3186 : : }
3187 : :
3188 [ # # ]: 0 : if (!facet_ptr)
3189 : : {
3190 : 0 : seek_address = 0;
3191 [ # # ]: 0 : fclose(fp);
3192 : 0 : return CUBIT_FAILURE;
3193 : : }
3194 : :
3195 : : /// APPEND facet to output facet_ptr list
3196 [ # # ]: 0 : if (append_to_facet_list)
3197 : : {
3198 [ # # ]: 0 : tfacet_list.append( facet_ptr );
3199 : 0 : ntri++;
3200 : : }
3201 : :
3202 : : }
3203 : 0 : seek_address = 0;
3204 [ # # ]: 0 : if ( eof_found == true ) {
3205 [ # # ][ # # ]: 0 : PRINT_WARNING("Premature end-of-file on STL file. Body may be incomplete.\n");
[ # # ][ # # ]
3206 [ # # ]: 0 : fclose(fp);
3207 : 0 : return CUBIT_SUCCESS;
3208 : : }
3209 [ # # ]: 0 : if ( error_found == true ) {
3210 [ # # ][ # # ]: 0 : PRINT_WARNING("Error found while reading line number %d of file %s. Body may be incomplete.\n",
[ # # ]
3211 [ # # ]: 0 : linenumber,file_name);
3212 [ # # ]: 0 : fclose(fp);
3213 : 0 : return CUBIT_SUCCESS;
3214 : : }
3215 [ # # ]: 0 : if ( done == false ) {
3216 [ # # ][ # # ]: 0 : PRINT_WARNING("Error found while reading line number %d of file %s. Body may be incomplete.\n",
[ # # ]
3217 [ # # ]: 0 : linenumber,file_name);
3218 [ # # ]: 0 : fclose(fp);
3219 : 0 : return CUBIT_SUCCESS;
3220 : : }
3221 : :
3222 [ # # ][ # # ]: 0 : if ( (eof_found == false) && (error_found == false) && (done == true) ) {
[ # # ]
3223 [ # # ][ # # ]: 0 : while ( fgets(line,127,fp) != 0 ) {
3224 [ # # ][ # # ]: 0 : if ( (strstr(line,"solid") != 0) && (strstr(line,"endsolid") == 0) ) {
3225 [ # # ]: 0 : seek_address = ftell(fp);
3226 : : // PRINT_INFO("This STL file is a multipart file. Only the first part was read.\n");
3227 : 0 : break;
3228 : : }
3229 : : }
3230 : : }
3231 [ # # ]: 0 : fclose(fp);
3232 : :
3233 : 0 : return CUBIT_SUCCESS;
3234 : : }
3235 : : else
3236 : : {
3237 [ # # ]: 0 : fclose(fp);
3238 : : // file is closed so that it can be opened as binary
3239 [ # # ]: 0 : fp = fopen(file_name, "rb");
3240 [ # # ]: 0 : if (fp == NULL)
3241 : : {
3242 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not open file %s for reading\n", file_name);
[ # # ][ # # ]
3243 : 0 : return CUBIT_FAILURE;
3244 : : }
3245 : :
3246 : :
3247 : 0 : CubitFacet *facet_ptr = NULL;
3248 : : CubitPoint *point0,
3249 : : *point1,
3250 : : *point2;
3251 : :
3252 : : char dummy;
3253 : 0 : int ii=0; // iterates through the facets of the file
3254 : : float cur[12]; // an array to hold 48 bytes representing 1 facet
3255 : 0 : npoints=0; // only tri facets in stl files
3256 : :
3257 : : //put file pointer back where you found it
3258 : 0 : fseek(fp, seek_address+80, SEEK_SET);
3259 [ # # ]: 0 : size_t count = fread(&ntri, 4, 1, fp);
3260 [ # # ]: 0 : if (count != 1) {
3261 [ # # ][ # # ]: 0 : PRINT_ERROR("Trouble reading in number of triangles\n");
[ # # ][ # # ]
3262 : 0 : return CUBIT_FAILURE;
3263 : : }
3264 : 0 : int distinct_ntri=ntri;
3265 : :
3266 [ # # ][ # # ]: 0 : PRINT_INFO ("Reading facets...\n");
[ # # ][ # # ]
3267 [ # # ]: 0 : for (ii=0; ii<ntri; ii++) {
3268 : : // read in 1 facet
3269 [ # # ][ # # ]: 0 : if (fread(cur, 4, 12, fp) != 12)
3270 : : {
3271 [ # # ][ # # ]: 0 : PRINT_INFO ("Abnormal file termination %s \n", file_name); break;
[ # # ][ # # ]
3272 : : }
3273 [ # # ]: 0 : count = fread(&dummy, 1, 1, fp);
3274 [ # # ]: 0 : count = fread(&dummy, 1, 1, fp);
3275 : :
3276 : : //make point
3277 [ # # ][ # # ]: 0 : point0 = (CubitPoint *) new CubitPointData( cur[3], cur[4], cur[5] );
3278 : :
3279 [ # # ]: 0 : pos=mm.find(point0);
3280 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3281 : : {
3282 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point0, npoints));
3283 [ # # ]: 0 : point0->set_id( npoints ++ );
3284 : : //point_list is output of function
3285 [ # # ]: 0 : point_list.append(point0);
3286 : : }
3287 : : else
3288 : : {
3289 [ # # ][ # # ]: 0 : delete point0;
3290 [ # # ]: 0 : point0=((*pos).first);
3291 : : }
3292 : :
3293 : : //make point
3294 [ # # ][ # # ]: 0 : point1 = (CubitPoint *) new CubitPointData( cur[6], cur[7], cur[8] );
3295 : :
3296 [ # # ]: 0 : pos=mm.find(point1);
3297 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3298 : : {
3299 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point1, npoints));
3300 [ # # ]: 0 : point1->set_id( npoints ++ );
3301 : : //point_list is output of function
3302 [ # # ]: 0 : point_list.append(point1);
3303 : : }
3304 : : else
3305 : : {
3306 [ # # ][ # # ]: 0 : delete point1;
3307 [ # # ]: 0 : point1=((*pos).first);
3308 : : }
3309 : :
3310 : : //make point
3311 [ # # ][ # # ]: 0 : point2 = (CubitPoint *) new CubitPointData( cur[9], cur[10], cur[11] );
3312 : :
3313 [ # # ]: 0 : pos=mm.find(point2);
3314 [ # # ][ # # ]: 0 : if (pos==mm.end())
[ # # ]
3315 : : {
3316 [ # # ][ # # ]: 0 : mm.insert ( vMap::value_type(point2, npoints));
3317 [ # # ]: 0 : point2->set_id( npoints ++ );
3318 : : //point_list is output of function
3319 [ # # ]: 0 : point_list.append(point2);
3320 : : }
3321 : : else
3322 : : {
3323 [ # # ][ # # ]: 0 : delete point2;
3324 [ # # ]: 0 : point2=((*pos).first);
3325 : : }
3326 : :
3327 : : // this is to avoid a facet with all points on same line, which crashes CUBIT
3328 : : // because of assertion
3329 [ # # ][ # # ]: 0 : if (point0 && point1 && point2 && point0!=point1 && point1!=point2 && point2 !=point0)
[ # # ][ # # ]
[ # # ][ # # ]
3330 : : {
3331 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( point0, point1, point2 );
3332 : 0 : append_to_facet_list=CUBIT_TRUE;
3333 : : }
3334 : : else
3335 : : {
3336 : 0 : append_to_facet_list=CUBIT_FALSE;
3337 : : }
3338 : :
3339 [ # # ]: 0 : if (!facet_ptr)
3340 : : {
3341 [ # # ]: 0 : fclose(fp);
3342 : 0 : return CUBIT_FAILURE;
3343 : : }
3344 : :
3345 [ # # ]: 0 : if (append_to_facet_list)
3346 : : {
3347 [ # # ]: 0 : tfacet_list.append( facet_ptr );
3348 : : }
3349 : : else
3350 : : {
3351 : 0 : distinct_ntri--;
3352 : : }
3353 : : }
3354 : 0 : ntri=distinct_ntri;
3355 : :
3356 : : //reading at or past EOF
3357 [ # # ]: 0 : long previous_pos = ftell(fp);
3358 [ # # ]: 0 : fread(&dummy, 1, 1, fp);
3359 : :
3360 [ # # ]: 0 : if( feof(fp) )
3361 : 0 : seek_address = 0;
3362 : : else
3363 : : {
3364 : 0 : fseek(fp, previous_pos, SEEK_SET);
3365 [ # # ]: 0 : seek_address = ftell(fp);
3366 : : }
3367 : :
3368 [ # # ]: 0 : fclose(fp);
3369 : 0 : return CUBIT_SUCCESS;
3370 [ # # ]: 0 : }
3371 : : }
3372 : :
3373 : :
3374 : : //===========================================================================
3375 : : //Function Name: import_facets
3376 : : //Member Type: PUBLIC
3377 : : //Description: import facets and create geometry
3378 : : //===========================================================================
3379 : 11 : CubitStatus FacetQueryEngine::import_facets(
3380 : : const char *file_name, // to be read
3381 : : CubitBoolean use_feature_angle, // to define where surfaces are broken
3382 : : double feature_angle, // angle where surfaces are broken (degrees)
3383 : : double tolerance, // for stl files loading
3384 : : int interp_order, // Facet representation 1= linear, 4= Bezier
3385 : : CubitBoolean smooth_non_manifold, // continutiy accross non-manifold edges
3386 : : CubitBoolean split_surfaces, // break facet rep at surface boundaries
3387 : : CubitBoolean stitch, // attempt to stitch together facets at the boundary
3388 : : CubitBoolean improve, // smooth, swap and collapse to improve quality
3389 : : DLIList<CubitQuadFacet *> &quad_facet_list, // return quad facets
3390 : : DLIList<CubitFacet *> &tri_facet_list, // return tri facets
3391 : : DLIList<Surface *> &surface_list, // return list of surfaces
3392 : : FacetFileFormat file_format )
3393 : : {
3394 [ + - ]: 11 : DLIList <CubitFacet *>tfacet_list;
3395 [ + - ][ + - ]: 22 : DLIList <CubitQuadFacet *>qfacet_list;
3396 [ + - ][ + - ]: 22 : DLIList <CubitPoint *>point_list;
3397 : :
3398 : : ShellSM *shell_ptr;
3399 [ + - ][ + - ]: 22 : DLIList<ShellSM*> shell_list;
3400 : : Lump *lump_ptr;
3401 [ + - ][ + - ]: 22 : DLIList<Lump*> lump_list;
3402 : : BodySM *bodysm_ptr;
3403 : : Body *body_ptr;
3404 [ + - ]: 11 : GeometryQueryTool *gti = GeometryQueryTool::instance();
3405 : : FacetShell* facet_shell;
3406 [ + - ][ + - ]: 22 : DLIList<DLIList<CubitFacet *> *> shell_facet_list;
3407 : : int ishell, ii;
3408 : 11 : CubitBoolean is_water_tight = CUBIT_TRUE;
3409 : :
3410 : : // read the facets from a file
3411 : :
3412 : 11 : int *conn = NULL;
3413 : 11 : int npoints = 0;
3414 : 11 : int nfacets = 0;
3415 : 11 : int nquad = 0;
3416 : 11 : int ntri = 0;
3417 : :
3418 : : int prev_vert;
3419 : : int prev_edge;
3420 : : int prev_face;
3421 : : int prev_vol;
3422 : : int prev_bod;
3423 : :
3424 : 11 : long stl_seek_address=0;
3425 : 11 : bool stl_multiple_parts = true;
3426 : :
3427 : : CubitStatus rv;
3428 : : // Here we add the capability to read stl files with more than one part.
3429 [ + + ]: 22 : while ( stl_multiple_parts == true ) {
3430 : 11 : stl_multiple_parts = false;
3431 [ + - ]: 11 : prev_vert = gti->num_ref_vertices();
3432 [ + - ]: 11 : prev_edge = gti->num_ref_edges();
3433 [ + - ]: 11 : prev_face = gti->num_ref_faces();
3434 [ + - ]: 11 : prev_vol = gti->num_ref_volumes();
3435 [ + - ]: 11 : prev_bod = gti->num_bodies();
3436 [ + - - - : 11 : switch (file_format)
- ]
3437 : : {
3438 : : case STL_FILE:
3439 [ + - ]: 11 : tfacet_list.clean_out(); // In case there are multiple parts in the stl file
3440 [ + - ]: 11 : point_list.clean_out();
3441 [ + - ]: 11 : shell_list.clean_out();
3442 [ + - ]: 11 : lump_list.clean_out();
3443 [ + - ]: 11 : shell_facet_list.clean_out();
3444 [ + - ]: 11 : if (tolerance>0)
3445 : : {
3446 [ + - ]: 11 : rv = read_facets_stl_tolerance(tfacet_list, point_list, file_name, npoints, ntri, stl_seek_address, tolerance);
3447 : : }
3448 : : else
3449 : : {
3450 [ # # ]: 0 : rv = read_facets_stl(tfacet_list, point_list, file_name, npoints, ntri, stl_seek_address);
3451 : : }
3452 [ + - ][ + - ]: 11 : PRINT_INFO(" %d facets read.\n", ntri);
[ + - ][ + - ]
3453 [ + - ][ - + ]: 11 : if ( (rv == CUBIT_SUCCESS) && (stl_seek_address) > 0 ) stl_multiple_parts = true;
3454 : 11 : nfacets = ntri;
3455 : :
3456 [ - + ]: 11 : if (rv != CUBIT_SUCCESS)
3457 : : {
3458 : 0 : goto end_import_facets;
3459 : : }
3460 : 11 : break;
3461 : :
3462 : : case CUBIT_FACET_FILE:
3463 : : case AVS_FILE:
3464 [ # # ]: 0 : rv = read_facets( file_name, conn, npoints, nquad, ntri, file_format );
3465 : :
3466 : 0 : nfacets = ntri + nquad;
3467 : :
3468 [ # # ]: 0 : if (rv != CUBIT_SUCCESS)
3469 : 0 : goto end_import_facets;
3470 : :
3471 : : // make cubit facet entities from the points and connectivity
3472 : :
3473 [ # # ]: 0 : if (nquad > 0)
3474 [ # # ]: 0 : rv = make_facets(conn, nfacets, qfacet_list);
3475 [ # # ]: 0 : if (ntri > 0)
3476 [ # # ]: 0 : rv = make_facets(conn, nfacets, tfacet_list);
3477 [ # # ]: 0 : if (rv != CUBIT_SUCCESS)
3478 : 0 : goto end_import_facets;
3479 [ # # ]: 0 : get_all_hash_points(point_list);
3480 [ # # ]: 0 : delete_hash_points();
3481 : 0 : break;
3482 : : case CHOLLA_FILE:
3483 [ # # ]: 0 : rv = read_cholla_file( file_name, feature_angle, point_list, tfacet_list );
3484 : 0 : nquad = 0;
3485 [ # # ]: 0 : ntri = tfacet_list.size();
3486 [ # # ]: 0 : npoints = point_list.size();
3487 : 0 : break;
3488 : : case FROM_FACET_LIST:
3489 [ # # ]: 0 : tfacet_list = tri_facet_list;
3490 [ # # ]: 0 : qfacet_list = quad_facet_list;
3491 [ # # ][ # # ]: 0 : if (tfacet_list.size() + qfacet_list.size() == 0)
[ # # ]
3492 : : {
3493 [ # # ][ # # ]: 0 : PRINT_ERROR("No facets found to build geometry\n");
[ # # ][ # # ]
3494 : 0 : rv = CUBIT_FAILURE;
3495 : 0 : goto end_import_facets;
3496 : : }
3497 : 0 : break;
3498 : : default:
3499 : 0 : assert(0); // unrecognized file format
3500 : : break;
3501 : : }
3502 : :
3503 [ + - ][ + - ]: 11 : if (tfacet_list.size() + qfacet_list.size() == 0)
[ - + ]
3504 : : {
3505 [ # # ][ # # ]: 0 : PRINT_ERROR("No facets read from file %s.\n", file_name);
[ # # ][ # # ]
3506 : 0 : rv = CUBIT_FAILURE;
3507 : 0 : goto end_import_facets;
3508 : : }
3509 : : else
3510 : : {
3511 [ + - ][ + - ]: 22 : PRINT_INFO("Building facet-based geometry from %d facets...\n",
[ + - ][ + - ]
[ + - ]
3512 [ + - ]: 11 : tfacet_list.size() + qfacet_list.size() );
3513 : : }
3514 : :
3515 : : // if (fix)
3516 : : // {
3517 : : // rv = check_facets( point_list, tfacet_list );
3518 : : // }
3519 : :
3520 : : if (0)
3521 : : {
3522 : : // Call function to generate an x-y-z file for a CTH/SPH simulation
3523 : : // the following is an exampl call...
3524 : : //make_sph( point_list, tfacet_list, 100.0, "fem1-sph100.xyz" );
3525 : : }
3526 : :
3527 : : if (0)
3528 : : {
3529 : : // This is an example of using the export_facets function. Writes
3530 : : // a facet file of all facets in the list
3531 : :
3532 : : //commented out because otherwise it's a compiler warning.
3533 : :
3534 : : // char filename[128];
3535 : : // strcpy(filename, "my_test.facets");
3536 : : // export_facets(tfacet_list,filename);
3537 : : }
3538 : :
3539 : :
3540 : : // split the facets into shells if needed
3541 : :
3542 : : rv = FacetDataUtil::split_into_shells(tfacet_list, qfacet_list,
3543 [ + - ]: 11 : shell_facet_list, is_water_tight);
3544 [ - + ]: 11 : if (rv != CUBIT_SUCCESS)
3545 : : {
3546 [ # # ][ # # ]: 0 : PRINT_ERROR("Error processing facets from %s.\n", file_name);
[ # # ][ # # ]
3547 : 0 : goto end_import_facets;
3548 : : }
3549 : :
3550 : : // if the facets aren't watertight, see if they can be merged
3551 : :
3552 [ - + ][ # # ]: 11 : if (!is_water_tight && stitch)
3553 : : {
3554 : : rv = FacetDataUtil::stitch_facets(shell_facet_list,
3555 : : GEOMETRY_RESABS,
3556 [ # # ]: 0 : is_water_tight);
3557 [ # # ]: 0 : if (rv != CUBIT_SUCCESS)
3558 : : {
3559 [ # # ][ # # ]: 0 : PRINT_WARNING("Couldn't stitch facets.\n");
[ # # ][ # # ]
3560 : : }
3561 : : }
3562 : :
3563 : : DLIList <CubitFacet *> *facet_list_ptr;
3564 [ + - ]: 11 : if (improve)
3565 : : {
3566 [ + - ][ + + ]: 22 : for (ishell = 0; ishell < shell_facet_list.size(); ishell++)
3567 : : {
3568 [ + - ]: 11 : facet_list_ptr = shell_facet_list.get_and_step();
3569 [ + - ]: 11 : rv = FacetDataUtil::collapse_short_edges( *facet_list_ptr, CUBIT_TRUE );
3570 [ - + ]: 11 : if (rv != CUBIT_SUCCESS)
3571 : : {
3572 [ # # ][ # # ]: 0 : PRINT_WARNING("Couldn't improve facets.\n");
[ # # ][ # # ]
3573 : : }
3574 : : }
3575 : : }
3576 : :
3577 : : // check for consistent orientations on the facets for each shell
3578 : :
3579 [ + - ][ + + ]: 22 : for (ishell = 0; ishell < shell_facet_list.size(); ishell++)
3580 : : {
3581 [ + - ]: 11 : facet_list_ptr = shell_facet_list.get_and_step();
3582 : : rv = ChollaEngine::check_all_facet_orientations(*facet_list_ptr,
3583 [ + - ]: 11 : CUBIT_TRUE);
3584 [ - + ]: 11 : if (rv != CUBIT_SUCCESS)
3585 : : {
3586 [ # # ][ # # ]: 0 : PRINT_WARNING("Couldn't set consistent orientation for facets.\n");
[ # # ][ # # ]
3587 : : }
3588 : : // check to see that we have a positive enclosed volume (note this only works for
3589 : : // a single shell. Will need to do something else for multiple shells
3590 : :
3591 [ + - ][ + - ]: 11 : if (shell_facet_list.size() == 1)
3592 : : {
3593 [ + - ]: 11 : double volume = FacetEvalTool::contained_volume(*facet_list_ptr);
3594 [ - + ]: 11 : if (volume < 0.0)
3595 : : {
3596 [ # # ]: 11 : FacetEvalTool::reverse_facets(*facet_list_ptr);
3597 : : }
3598 : : }
3599 : : }
3600 : :
3601 : : // create the surface geometry
3602 : :
3603 [ - + ]: 11 : if (!use_feature_angle)
3604 : 0 : feature_angle = -1.0;
3605 : :
3606 [ + - ]: 11 : std::vector< std::vector<Surface*> > list_of_shells;
3607 : :
3608 [ + - ][ + + ]: 22 : for (ishell = 0; ishell < shell_facet_list.size(); ishell++)
3609 : : {
3610 [ + - ]: 11 : DLIList <Surface *> shell_surfaces;
3611 [ + - ][ + - ]: 22 : DLIList <CubitPoint *> mypoint_list;
[ + - ]
3612 [ + - ]: 11 : facet_list_ptr = shell_facet_list.get_and_step();
3613 [ - + ]: 11 : if(facet_list_ptr == NULL)
3614 : 0 : rv = CUBIT_FAILURE;
3615 : : else
3616 : : rv = FacetModifyEngine::instance()->build_facet_surface( NULL,
3617 : : *facet_list_ptr, mypoint_list,
3618 : : feature_angle, interp_order,
3619 : : smooth_non_manifold,
3620 [ + - ][ + - ]: 11 : split_surfaces, shell_surfaces);
3621 [ + - ][ + - ]: 11 : if (rv != CUBIT_SUCCESS || shell_surfaces.size() == 0)
[ - + ][ - + ]
3622 : : {
3623 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't build facet based geometry from facets in %s\n", file_name);
[ # # ][ # # ]
3624 : 0 : rv = CUBIT_FAILURE;
3625 : 0 : goto end_import_facets;
3626 : : }
3627 : :
3628 [ + - ][ + - ]: 11 : list_of_shells.push_back( shell_surfaces.as_vector() );
[ + - ][ + - ]
3629 : 11 : }
3630 : :
3631 : : // make a shell out of these surfaces
3632 [ - + ]: 11 : if( split_surfaces ) //make a shell for each and every surface
3633 : : {
3634 [ # # ][ # # ]: 0 : for( size_t k=0; k<list_of_shells.size(); k++ )
3635 : : {
3636 [ # # ][ # # ]: 0 : std::vector<Surface*> shell_surfaces = list_of_shells[k];
3637 : :
3638 [ # # ][ # # ]: 0 : for( size_t i=0; i<shell_surfaces.size(); i++ )
[ # # ][ # # ]
3639 : : {
3640 [ # # ]: 0 : DLIList<Surface*> sheet_body_surfaces;
3641 [ # # ][ # # ]: 0 : sheet_body_surfaces.append( shell_surfaces[i] );
3642 : :
3643 [ # # ][ # # ]: 0 : rv = FacetModifyEngine::instance()->make_facet_shell(sheet_body_surfaces, shell_ptr);
3644 [ # # ][ # # ]: 0 : if ( shell_ptr == NULL || rv != CUBIT_SUCCESS )
3645 : : {
3646 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based shell entity.\n");
[ # # ][ # # ]
3647 : 0 : rv = CUBIT_FAILURE;
3648 : 0 : goto end_import_facets;
3649 : : }
3650 : :
3651 : : //set the sense
3652 [ # # ]: 0 : facet_shell = CAST_TO( shell_ptr, FacetShell );
3653 [ # # ][ # # ]: 0 : FacetSurface* facet_surf = CAST_TO( sheet_body_surfaces.get(), FacetSurface );
3654 [ # # ]: 0 : facet_surf->set_shell_sense( facet_shell, CUBIT_FORWARD );
3655 : :
3656 [ # # ][ # # ]: 0 : surface_list.append( sheet_body_surfaces.get() );
3657 : :
3658 [ # # ]: 0 : shell_list.clean_out();
3659 [ # # ]: 0 : shell_list.append( shell_ptr );
3660 [ # # ][ # # ]: 0 : rv = FacetModifyEngine::instance()->make_facet_lump(shell_list,lump_ptr);
3661 [ # # ][ # # ]: 0 : if ( lump_ptr == NULL || rv != CUBIT_SUCCESS )
3662 : : {
3663 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based lump entity.\n");
[ # # ][ # # ]
3664 : 0 : rv = CUBIT_FAILURE;
3665 : 0 : goto end_import_facets;
3666 : : }
3667 : :
3668 [ # # ]: 0 : lump_list.clean_out();
3669 [ # # ]: 0 : lump_list.append(lump_ptr);
3670 [ # # ][ # # ]: 0 : rv = FacetModifyEngine::instance()->make_facet_body(lump_list,bodysm_ptr);
3671 [ # # ][ # # ]: 0 : body_ptr = GeometryQueryTool::instance()->make_Body(bodysm_ptr);
3672 : :
3673 [ # # ][ # # ]: 0 : if ( body_ptr == NULL || rv != CUBIT_SUCCESS )
3674 : : {
3675 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based body entity.\n");
[ # # ][ # # ]
3676 : 0 : rv = CUBIT_FAILURE;
3677 [ # # ][ # # ]: 0 : goto end_import_facets;
3678 : : }
3679 : 0 : }
3680 : 0 : }
3681 : : }
3682 : : else //make a shell out of all these surfaces
3683 : : {
3684 [ + - ][ + + ]: 22 : for( size_t k=0; k<list_of_shells.size(); k++ )
3685 : : {
3686 [ + - ][ + - ]: 11 : DLIList<Surface*> shell_surfaces( list_of_shells[k] );
3687 : :
3688 : : // make a shell out of these surfaces
3689 [ + - ][ + - ]: 11 : rv = FacetModifyEngine::instance()->make_facet_shell(shell_surfaces, shell_ptr);
3690 [ + - ][ - + ]: 11 : if ( shell_ptr == NULL || rv != CUBIT_SUCCESS )
3691 : : {
3692 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based shell entity.\n");
[ # # ][ # # ]
3693 : 0 : rv = CUBIT_FAILURE;
3694 : 0 : goto end_import_facets;
3695 : : }
3696 : :
3697 : : //Set the sense for the surfaces (will be cofaces) on this shell.
3698 : : //Assumption: The sense is always forward when creating geom from facets.
3699 : : // (This may not be correct -especially with multiple shells in a body)
3700 : :
3701 [ - + ]: 11 : facet_shell = CAST_TO( shell_ptr, FacetShell );
3702 [ + - ][ + + ]: 77 : for( ii = shell_surfaces.size(); ii > 0; ii-- )
3703 : : {
3704 [ + - ]: 66 : Surface* surf = shell_surfaces.get_and_step();
3705 [ - + ]: 66 : FacetSurface* facet_surf = CAST_TO( surf, FacetSurface );
3706 [ + - ]: 66 : facet_surf->set_shell_sense( facet_shell, CUBIT_FORWARD );
3707 : : }
3708 : :
3709 [ + - ]: 11 : surface_list += shell_surfaces;
3710 [ + - ][ + - ]: 11 : shell_list.append(shell_ptr);
[ + - ]
3711 : 11 : }
3712 : :
3713 : : // make a body out of it
3714 [ + - ][ + - ]: 11 : rv = FacetModifyEngine::instance()->make_facet_lump(shell_list,lump_ptr);
3715 [ + - ][ - + ]: 11 : if ( lump_ptr == NULL || rv != CUBIT_SUCCESS )
3716 : : {
3717 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based lump entity.\n");
[ # # ][ # # ]
3718 : 0 : rv = CUBIT_FAILURE;
3719 : 0 : goto end_import_facets;
3720 : : }
3721 : :
3722 [ + - ]: 11 : lump_list.append(lump_ptr);
3723 [ + - ][ + - ]: 11 : rv = FacetModifyEngine::instance()->make_facet_body(lump_list,bodysm_ptr);
3724 [ + - ][ + - ]: 11 : body_ptr = GeometryQueryTool::instance()->make_Body(bodysm_ptr);
3725 : :
3726 [ + - ][ - + ]: 11 : if ( body_ptr == NULL || rv != CUBIT_SUCCESS )
3727 : : {
3728 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based body entity.\n");
[ # # ][ # # ]
3729 : 0 : rv = CUBIT_FAILURE;
3730 : 0 : goto end_import_facets;
3731 : : }
3732 : : }
3733 : :
3734 [ + - ][ - + ]: 11 : if(gti->num_bodies() - prev_bod > 1)
3735 [ # # ][ # # ]: 0 : PRINT_INFO("Bodies successfully created.\n");
[ # # ][ # # ]
3736 : : else
3737 [ + - ][ + - ]: 11 : PRINT_INFO("Body successfully created.\n");
[ + - ][ + - ]
3738 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new vertices = %d\n", gti->num_ref_vertices() - prev_vert);
[ + - ][ + - ]
[ + - ]
3739 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new curves = %d\n", gti->num_ref_edges() - prev_edge);
[ + - ][ + - ]
[ + - ]
3740 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new surfaces = %d\n", gti->num_ref_faces() - prev_face);
[ + - ][ + - ]
[ + - ]
3741 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new shells = %d\n", shell_facet_list.size());
[ + - ][ + - ]
[ + - ]
3742 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new volumes = %d\n", gti->num_ref_volumes() - prev_vol);
[ + - ][ + - ]
[ + - ]
3743 [ + - ][ + - ]: 11 : PRINT_INFO(" Number of new bodies = %d\n", gti->num_bodies() - prev_bod);
[ + - ][ + - ]
[ + - ]
3744 : :
3745 [ - + ]: 11 : if (!is_water_tight)
3746 : : {
3747 [ # # ][ # # ]: 0 : PRINT_WARNING("Volume generated does not completely close. 3D meshing (ie. hex/tet) will not be permitted.\n");
[ # # ][ # # ]
3748 [ # # ][ # # ]: 11 : PRINT_INFO("Hint: In some cases the \"stitch\" option on the import command may correct the problem.\n");
[ # # ][ # # ]
[ + - ][ + - ]
3749 : : }
3750 : 11 : } // end while ( stl_multiple_parts == true )
3751 : :
3752 : : end_import_facets:
3753 [ - + ]: 11 : if (conn != NULL)
3754 [ # # ]: 0 : delete [] conn;
3755 [ + - ][ + + ]: 22 : for (ii=0; ii<shell_list.size(); ii++)
3756 [ + - ][ + - ]: 11 : delete shell_facet_list.get_and_step();
[ + - ]
3757 : :
3758 [ + - ]: 11 : quad_facet_list = qfacet_list;
3759 [ + - ]: 11 : tri_facet_list = tfacet_list;
3760 [ + - ]: 11 : return rv;
3761 : : }
3762 : :
3763 : :
3764 : :
3765 : : //===========================================================================
3766 : : //Function Name: read_facets
3767 : : //Member Type: PUBLIC
3768 : : //Description: read facets from facet file
3769 : : //===========================================================================
3770 : 0 : CubitStatus FacetQueryEngine::read_facets( const char * file_name,
3771 : : int *&conn,
3772 : : int &npoints,
3773 : : int &nquad, int &ntri,
3774 : : FacetFileFormat file_format )
3775 : : {
3776 : : // open the file
3777 [ # # ]: 0 : FILE *fp = fopen(file_name, "r");
3778 [ # # ]: 0 : if (fp == NULL)
3779 : : {
3780 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not open file %s for reading\n", file_name);
[ # # ][ # # ]
3781 : 0 : return CUBIT_FAILURE;
3782 : : }
3783 : :
3784 [ # # ][ # # ]: 0 : PRINT_INFO("Reading facets...\n");
[ # # ][ # # ]
3785 : :
3786 : : // read the number of nodes
3787 : :
3788 : : int id;
3789 : 0 : int nfacets = 0;
3790 : 0 : int iline = 1;
3791 : : char line[128];
3792 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp) == NULL)
3793 : : {
3794 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3795 [ # # ]: 0 : fclose( fp );
3796 : 0 : return CUBIT_FAILURE;
3797 : : }
3798 : :
3799 : : int n;
3800 : : char type_header[8];
3801 : 0 : CubitBoolean is_off_file = CUBIT_FALSE;
3802 : 0 : n = sscanf( line, "%s", type_header );
3803 [ # # ][ # # ]: 0 : if( !strcmp( type_header, "OFF" ) ||
3804 : 0 : !strcmp( type_header, "off" ) )
3805 : : {
3806 [ # # ][ # # ]: 0 : PRINT_INFO( "Reading OFF file...\n" );
[ # # ][ # # ]
3807 : 0 : iline++;
3808 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp) == NULL) {
3809 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3810 [ # # ]: 0 : fclose( fp );
3811 : 0 : return CUBIT_FAILURE;
3812 : : }
3813 : 0 : is_off_file = CUBIT_TRUE;
3814 : : }
3815 : :
3816 : 0 : n = sscanf(line, "%d %d", &npoints, &nfacets);
3817 [ # # ]: 0 : if( !is_off_file )
3818 : : {
3819 [ # # ][ # # ]: 0 : if (n < 1 || ( n > 2 && file_format == CUBIT_FACET_FILE ) )
[ # # ]
3820 : : {
3821 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3822 [ # # ]: 0 : fclose( fp );
3823 : 0 : return CUBIT_FAILURE;
3824 : : }
3825 : : }
3826 : :
3827 [ # # ]: 0 : if (npoints <= 0)
3828 : : {
3829 [ # # ][ # # ]: 0 : PRINT_ERROR("Expecting number of nodes in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3830 [ # # ]: 0 : fclose( fp );
3831 : 0 : return CUBIT_FAILURE;
3832 : : }
3833 [ # # ]: 0 : if (n==1)
3834 : : {
3835 : 0 : nfacets = 0;
3836 : : }
3837 [ # # ]: 0 : else if (nfacets <= 0)
3838 : : {
3839 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d reading number of facets\n", file_name, iline);
[ # # ][ # # ]
3840 [ # # ]: 0 : fclose( fp );
3841 : 0 : return CUBIT_FAILURE;
3842 : : }
3843 : :
3844 [ # # ][ # # ]: 0 : if (init_hash_points( npoints ) == CUBIT_FAILURE)
3845 : : {
3846 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't allocate memory for points in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3847 [ # # ]: 0 : fclose( fp );
3848 : 0 : return CUBIT_FAILURE;
3849 : : }
3850 : :
3851 : : // read the nodes
3852 : :
3853 : : int ii;
3854 : : double xx, yy, zz;
3855 : : CubitPoint *new_point;
3856 [ # # ]: 0 : for (ii=0; ii<npoints; ii++)
3857 : : {
3858 : 0 : iline++;
3859 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp)== NULL)
3860 : : {
3861 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3862 [ # # ]: 0 : fclose( fp );
3863 : 0 : return CUBIT_FAILURE;
3864 : : }
3865 [ # # ]: 0 : if( is_off_file )
3866 : : {
3867 : 0 : n = sscanf( line, "%lf %lf %lf", &xx, &yy, &zz );
3868 : 0 : id = ii;
3869 [ # # ]: 0 : if (n != 3)
3870 : : {
3871 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in OFF file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3872 [ # # ][ # # ]: 0 : PRINT_INFO(" Expecting 3 doubles, but instead read %d values\n", n);
[ # # ][ # # ]
3873 [ # # ]: 0 : fclose( fp );
3874 : 0 : return CUBIT_FAILURE;
3875 : : }
3876 : : }
3877 : : else
3878 : : {
3879 : 0 : n = sscanf(line, "%d %lf %lf %lf", &id, &xx, &yy, &zz );
3880 [ # # ]: 0 : if (n != 4)
3881 : : {
3882 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3883 [ # # ][ # # ]: 0 : PRINT_INFO(" Expecting 1 integer and 3 doubles, but instead read %d values\n", n);
[ # # ][ # # ]
3884 [ # # ]: 0 : fclose( fp );
3885 : 0 : return CUBIT_FAILURE;
3886 : : }
3887 : : }
3888 : :
3889 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( xx, yy, zz );
3890 [ # # ]: 0 : new_point->set_id( id );
3891 [ # # ]: 0 : add_hash_point( new_point );
3892 : : }
3893 : :
3894 : : // read the number of facets
3895 : :
3896 [ # # ]: 0 : if (nfacets == 0)
3897 : : {
3898 : 0 : iline++;
3899 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp) == NULL)
3900 : : {
3901 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d reading number of facets\n", file_name, iline);
[ # # ][ # # ]
3902 [ # # ]: 0 : fclose( fp );
3903 : 0 : return CUBIT_FAILURE;
3904 : : }
3905 : :
3906 : 0 : n = sscanf(line, "%d", &nfacets);
3907 [ # # ]: 0 : if (n != 1)
3908 : : {
3909 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d reading number of facets\n", file_name, iline);
[ # # ][ # # ]
3910 [ # # ][ # # ]: 0 : PRINT_INFO(" Expecting <num facets>\n");
[ # # ][ # # ]
3911 [ # # ]: 0 : fclose( fp );
3912 : 0 : return CUBIT_FAILURE;
3913 : : }
3914 [ # # ]: 0 : if (nfacets <= 0)
3915 : : {
3916 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d reading number of facets\n", file_name, iline);
[ # # ][ # # ]
3917 [ # # ]: 0 : fclose( fp );
3918 : 0 : return CUBIT_FAILURE;
3919 : : }
3920 : : }
3921 : :
3922 [ # # ][ # # ]: 0 : conn = new int [4*nfacets];
3923 [ # # ]: 0 : if (!conn)
3924 : : {
3925 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't allocate memory for facets in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3926 [ # # ]: 0 : fclose( fp );
3927 : 0 : return CUBIT_FAILURE;
3928 : : }
3929 : 0 : ntri = nquad = 0;
3930 : :
3931 : : // read the facets
3932 : :
3933 [ # # ]: 0 : for (ii=0; ii<nfacets; ii++)
3934 : : {
3935 : 0 : iline++;
3936 [ # # ][ # # ]: 0 : if (fgets(line, 128, fp) == NULL)
3937 : : {
3938 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d\n", file_name, iline);
[ # # ][ # # ]
3939 [ # # ]: 0 : fclose( fp );
3940 : 0 : return CUBIT_FAILURE;
3941 : : }
3942 : :
3943 [ # # ]: 0 : if( AVS_FILE == file_format )
3944 : : {
3945 : : n = sscanf( line, "%d %*d %*s %d %d %d %d", &id, &conn[4*ii],
3946 : 0 : &conn[4*ii+1], &conn[4*ii+2], &conn[4*ii+3] );
3947 : :
3948 [ # # ][ # # ]: 0 : if( n < 4 || n > 5 )
3949 : : {
3950 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in avs file %s on line %d reading facets\n", file_name, iline);
[ # # ][ # # ]
3951 [ # # ][ # # ]: 0 : PRINT_INFO("Expecting 6 or 7 values, but instead read %d values\n", n);
[ # # ][ # # ]
3952 [ # # ]: 0 : fclose( fp );
3953 : 0 : return CUBIT_FAILURE;
3954 : : }
3955 : :
3956 : : //duplicate the point
3957 [ # # ]: 0 : if( n == 4 )
3958 : : {
3959 : 0 : conn[4*ii+3] = conn[4*ii+2];
3960 : 0 : ntri++;
3961 : : }
3962 : : else
3963 : : {
3964 : 0 : nquad++;
3965 : : }
3966 : : }
3967 : : else
3968 : : {
3969 : : // if( is_off_file )
3970 : : // {
3971 : : // n = sscanf( line, "%d %d %d %d", &id, &conn[4*ii], &conn[4*ii+1],
3972 : : // &conn[4*ii+2], &conn[4*ii+3] );
3973 : : // if (n < 4 || n > 5)
3974 : : // {
3975 : : // PRINT_ERROR("Format error in OFF file %s on line %d reading facets\n", file_name, iline);
3976 : : // PRINT_INFO(" Expecting 4 or 5 integers, but instead read %d values\n", n);
3977 : : // PRINT_INFO(" For example: <facet_size> <i0> <i1> <i2> [<i3>]\n");
3978 : : // fclose( fp );
3979 : : // return CUBIT_FAILURE;
3980 : : // }
3981 : :
3982 : : // // for triangles -- duplicate the point
3983 : : // // if( n==3 )
3984 : : // if( id==3 )
3985 : : // {
3986 : : // conn[4*ii+3] = conn[4*ii+2];
3987 : : // ntri++;
3988 : : // }
3989 : : // else
3990 : : // {
3991 : : // nquad++;
3992 : : // }
3993 : : // }
3994 : : // else
3995 : : // {
3996 : 0 : n = sscanf(line, "%d %d %d %d %d", &id, &conn[4*ii], &conn[4*ii+1],
3997 : 0 : &conn[4*ii+2], &conn[4*ii+3] );
3998 : :
3999 [ # # ][ # # ]: 0 : if (n < 4 || n > 5)
4000 : : {
4001 [ # # ][ # # ]: 0 : PRINT_ERROR("Format error in facet file %s on line %d reading facets\n", file_name, iline);
[ # # ][ # # ]
4002 [ # # ][ # # ]: 0 : PRINT_INFO(" Expecting 4 or 5 integers, but instead read %d values\n", n);
[ # # ][ # # ]
4003 [ # # ][ # # ]: 0 : PRINT_INFO(" For example: <id> <i0> <i1> <i2> [<i3>]\n");
[ # # ][ # # ]
4004 [ # # ]: 0 : fclose( fp );
4005 : 0 : return CUBIT_FAILURE;
4006 : : }
4007 : :
4008 : : // for triangles -- duplicate the point
4009 [ # # ]: 0 : if (n==4)
4010 : : {
4011 : 0 : conn[4*ii+3] = conn[4*ii+2];
4012 : 0 : ntri++;
4013 : : }
4014 : : else
4015 : : {
4016 : 0 : nquad++;
4017 : : }
4018 : : // }
4019 : : }
4020 : : }
4021 : :
4022 [ # # ]: 0 : fclose( fp );
4023 : 0 : return CUBIT_SUCCESS;
4024 : : }
4025 : :
4026 : : //===========================================================================
4027 : : // Function: read_cholla_file
4028 : : // Purpose: import the face mesh from the cholla file
4029 : : // Date: 11/28/2002
4030 : : // Author: sjowen
4031 : : //===========================================================================
4032 : 0 : CubitStatus FacetQueryEngine::read_cholla_file( const char *file_name,
4033 : : double &feature_angle,
4034 : : DLIList<CubitPoint *> &point_list,
4035 : : DLIList<CubitFacet *> &facet_list )
4036 : :
4037 : : {
4038 : :
4039 : 0 : double angle = 135.0;
4040 : 0 : int num_tri = 0;
4041 : 0 : int num_quad = 0;
4042 : 0 : int num_edge = 0;
4043 : 0 : int num_vert = 0;
4044 : 0 : int* tri_edge = NULL;
4045 : 0 : int* quad_edge = NULL;
4046 : 0 : int* edge_vert = NULL;
4047 : 0 : double* vert = NULL;
4048 : 0 : double* edge_ctrl_pts = NULL;
4049 : 0 : double* tri_ctrl_pts = NULL;
4050 : 0 : double* quad_ctrl_pts = NULL;
4051 : 0 : int results_included = 0;
4052 : :
4053 : : // importMesh and resolveFaceVectors are in Cholla.h
4054 : :
4055 : : importMesh(file_name, &results_included, &angle, &num_tri, &num_quad, &num_edge,
4056 : : &num_vert, &tri_edge, &quad_edge, &edge_vert, &vert,
4057 [ # # ]: 0 : &edge_ctrl_pts, &tri_ctrl_pts, &quad_ctrl_pts);
4058 : :
4059 : 0 : feature_angle = angle;
4060 : :
4061 : : // create the points
4062 : :
4063 [ # # ][ # # ]: 0 : CubitPoint **point_array = new CubitPoint * [num_vert];
4064 : : double x, y, z;
4065 : : int ii;
4066 : :
4067 [ # # ]: 0 : for (ii=0; ii<num_vert; ii++)
4068 : : {
4069 : 0 : x = vert[ii*3];
4070 : 0 : y = vert[ii*3 + 1];
4071 : 0 : z = vert[ii*3 + 2];
4072 [ # # ][ # # ]: 0 : point_array[ii] = (CubitPoint *) new CubitPointData( x, y, z );
4073 [ # # ]: 0 : point_list.append( point_array[ii] );
4074 : : }
4075 : :
4076 : : // create the edges
4077 : :
4078 [ # # ][ # # ]: 0 : CubitFacetEdge **edge_array = new CubitFacetEdge * [num_edge];
4079 : : int ip, jp;
4080 [ # # ]: 0 : for (ii=0; ii<num_edge; ii++)
4081 : : {
4082 : 0 : ip = edge_vert[ii*2];
4083 : 0 : jp = edge_vert[ii*2 + 1];
4084 [ # # ][ # # ]: 0 : assert(ip < num_vert && jp < num_vert && ip >= 0 && jp >= 0);
[ # # ][ # # ]
4085 : 0 : edge_array[ii] = (CubitFacetEdge *) new CubitFacetEdgeData( point_array[ip],
4086 [ # # ][ # # ]: 0 : point_array[jp] );
4087 : : }
4088 : :
4089 : : // create the tri facets
4090 : :
4091 : : int begin_face;
4092 : : int jj, iedge;
4093 : : CubitFacetEdge *edges[4];
4094 : 0 : CubitFacet *facet_ptr = NULL;
4095 : 0 : CubitQuadFacet *qfacet_ptr = NULL;
4096 [ # # ]: 0 : for (ii=0; ii<num_tri; ii++)
4097 : : {
4098 : 0 : begin_face = 3 * ii;
4099 [ # # ]: 0 : for(jj=0; jj<3; jj++)
4100 : : {
4101 : 0 : iedge = tri_edge[begin_face+jj];
4102 : 0 : edges[jj] = edge_array[iedge];
4103 : : }
4104 : : facet_ptr = (CubitFacet *)
4105 [ # # ][ # # ]: 0 : new CubitFacetData(edges[0], edges[1], edges[2]);
4106 [ # # ]: 0 : facet_list.append(facet_ptr);
4107 : : }
4108 : :
4109 : : // create the quad facets
4110 : :
4111 [ # # ]: 0 : for (ii=0; ii<num_quad; ii++)
4112 : : {
4113 : 0 : begin_face = 4 * ii;
4114 [ # # ]: 0 : for(jj=0; jj<4; jj++)
4115 : : {
4116 : 0 : iedge = quad_edge[begin_face+jj];
4117 : 0 : edges[jj] = edge_array[iedge];
4118 : : }
4119 : : qfacet_ptr = (CubitQuadFacet *)
4120 [ # # ][ # # ]: 0 : new CubitQuadFacetData(edges[0], edges[1], edges[2], edges[3]);
4121 [ # # ][ # # ]: 0 : facet_list.append(qfacet_ptr->get_tri_facet(0));
4122 [ # # ][ # # ]: 0 : facet_list.append(qfacet_ptr->get_tri_facet(1));
4123 : : }
4124 : :
4125 : : // delete the temp arrays
4126 : :
4127 [ # # ]: 0 : delete [] point_array;
4128 [ # # ]: 0 : delete [] edge_array;
4129 [ # # ]: 0 : delete [] tri_edge;
4130 [ # # ]: 0 : delete [] quad_edge;
4131 [ # # ]: 0 : delete [] edge_vert;
4132 [ # # ]: 0 : delete [] vert;
4133 [ # # ]: 0 : delete [] edge_ctrl_pts;
4134 [ # # ]: 0 : delete [] tri_ctrl_pts;
4135 [ # # ]: 0 : delete [] quad_ctrl_pts;
4136 : :
4137 : 0 : return CUBIT_SUCCESS;
4138 : : }
4139 : :
4140 : :
4141 : : //===========================================================================
4142 : : //Function Name: is_close
4143 : : //
4144 : : //Member Type: PRIVATE
4145 : : //Description: determine if one of the facets in the list is within a
4146 : : // certain distance of the point.
4147 : : //===========================================================================
4148 : : CubitBoolean
4149 : 0 : FacetQueryEngine::is_close(CubitVector &this_point,
4150 : : DLIList<CubitFacet *>&facet_list,
4151 : : CubitFacet *&lastFacet,
4152 : : double tol)
4153 : : {
4154 : 0 : CubitBoolean isclose = CUBIT_FALSE;
4155 [ # # ]: 0 : CubitBox bbox;
4156 [ # # ]: 0 : CubitVector close_point;
4157 : : CubitFacet *facet;
4158 : : int ii;
4159 : :
4160 : : // set the first facet to be checked as the last one located
4161 : :
4162 [ # # ]: 0 : if (lastFacet) {
4163 [ # # ][ # # ]: 0 : if (!facet_list.move_to(lastFacet)) {
4164 [ # # ]: 0 : facet_list.reset();
4165 : : }
4166 : : }
4167 : : else {
4168 [ # # ]: 0 : facet_list.reset();
4169 : : }
4170 : :
4171 : 0 : CubitBoolean done = CUBIT_FALSE;
4172 : :
4173 : : // define a bounding box around the point
4174 : :
4175 [ # # ]: 0 : CubitVector ptmin( this_point.x() - tol,
4176 [ # # ]: 0 : this_point.y() - tol,
4177 [ # # ][ # # ]: 0 : this_point.z() - tol );
4178 [ # # ]: 0 : CubitVector ptmax( this_point.x() + tol,
4179 [ # # ]: 0 : this_point.y() + tol,
4180 [ # # ][ # # ]: 0 : this_point.z() + tol );
4181 : :
4182 [ # # ][ # # ]: 0 : for ( ii = facet_list.size(); ii > 0 && !done; ii-- ) {
[ # # ]
4183 [ # # ]: 0 : facet = facet_list.get_and_step();
4184 : :
4185 : : // Try to trivially reject this facet with a bounding box test
4186 : :
4187 [ # # ][ # # ]: 0 : bbox = facet->bounding_box();
4188 [ # # ][ # # ]: 0 : if (ptmax.x() < bbox.minimum().x() ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
4189 [ # # ][ # # ]: 0 : ptmin.x() > bbox.maximum().x()) {
[ # # ][ # # ]
[ # # ]
4190 : 0 : continue;
4191 : : }
4192 [ # # ][ # # ]: 0 : if (ptmax.y() < bbox.minimum().y() ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
4193 [ # # ][ # # ]: 0 : ptmin.y() > bbox.maximum().y()) {
[ # # ][ # # ]
[ # # ]
4194 : 0 : continue;
4195 : : }
4196 [ # # ][ # # ]: 0 : if (ptmax.z() < bbox.minimum().z() ||
[ # # ][ # # ]
[ # # ][ # # ]
[ # # # # ]
4197 [ # # ][ # # ]: 0 : ptmin.z() > bbox.maximum().z()) {
[ # # ][ # # ]
[ # # ]
4198 : 0 : continue;
4199 : : }
4200 : :
4201 : : // Only facets that pass the bounding box test will get past here!
4202 : :
4203 : : // Project point to plane of the facet and determine its area coordinates
4204 : :
4205 [ # # ]: 0 : CubitVector pt_on_plane;
4206 : : double dist_to_plane;
4207 [ # # ]: 0 : FacetEvalTool::project_to_facet_plane( facet, this_point, pt_on_plane, dist_to_plane );
4208 : :
4209 [ # # ]: 0 : CubitVector areacoord;
4210 [ # # ]: 0 : FacetEvalTool::facet_area_coordinate( facet, pt_on_plane, areacoord );
4211 : :
4212 : : // If sign of areacoords are all positive then its inside the triangle
4213 : : // and we are done - go interpolate the point. (use an absolute
4214 : : // tolerance since the coordinates arenormalized)
4215 : :
4216 [ # # ][ # # ]: 0 : if (areacoord.x() > -GEOMETRY_RESABS &&
[ # # ]
4217 [ # # ][ # # ]: 0 : areacoord.y() > -GEOMETRY_RESABS &&
[ # # ]
4218 [ # # ]: 0 : areacoord.z() > -GEOMETRY_RESABS) {
4219 [ # # ]: 0 : FacetEvalTool::eval_facet( facet, areacoord, &close_point, NULL );
4220 : : }
4221 : :
4222 : : // otherwise find the closest vertex or edge to the projected point
4223 : :
4224 [ # # ][ # # ]: 0 : else if (areacoord.x() < GEOMETRY_RESABS) {
4225 [ # # ][ # # ]: 0 : if (areacoord.y() < GEOMETRY_RESABS) {
4226 [ # # ]: 0 : FacetEvalTool::eval_point( facet, 2, close_point );
4227 : : }
4228 [ # # ][ # # ]: 0 : else if(areacoord.z() < GEOMETRY_RESABS) {
4229 [ # # ]: 0 : FacetEvalTool::eval_point( facet, 1, close_point );
4230 : : }
4231 : : else {
4232 [ # # ]: 0 : FacetEvalTool::eval_edge( facet, 1, 2, pt_on_plane, close_point );
4233 : : }
4234 : : }
4235 [ # # ][ # # ]: 0 : else if (areacoord.y() < GEOMETRY_RESABS) {
4236 [ # # ][ # # ]: 0 : if (areacoord.z() < GEOMETRY_RESABS) {
4237 [ # # ]: 0 : FacetEvalTool::eval_point( facet, 0, close_point );
4238 : : }
4239 : : else {
4240 [ # # ]: 0 : FacetEvalTool::eval_edge( facet, 2, 0, pt_on_plane, close_point);
4241 : : }
4242 : : }
4243 : : else {
4244 [ # # ]: 0 : FacetEvalTool::eval_edge( facet, 0, 1, pt_on_plane, close_point );
4245 : : }
4246 : :
4247 : : // keep track of the minimum distance
4248 : :
4249 [ # # ][ # # ]: 0 : double dist = sqrt(FacetEvalToolUtils::sqr(close_point.x() - this_point.x()) +
[ # # ]
4250 [ # # ][ # # ]: 0 : FacetEvalToolUtils::sqr(close_point.y() - this_point.y()) +
[ # # ]
4251 [ # # ][ # # ]: 0 : FacetEvalToolUtils::sqr(close_point.z() - this_point.z()));
[ # # ]
4252 [ # # ]: 0 : if (dist <= tol) {
4253 : 0 : done = CUBIT_TRUE;
4254 : 0 : isclose = CUBIT_TRUE;
4255 : 0 : lastFacet = facet;
4256 : : }
4257 : : }
4258 [ # # ]: 0 : return isclose;
4259 : : }
4260 : :
4261 : :
4262 : :
4263 : :
4264 : : //=============================================================================
4265 : : // Function Name: export_facets
4266 : : // Member Type: PUBLIC
4267 : : // Description: export a list of facets to a facet file for debugging purposes
4268 : : // Author: sjowen
4269 : : // Date: 10/29/01
4270 : : //=============================================================================
4271 : 0 : CubitStatus FacetQueryEngine::export_facets(DLIList<CubitFacet*> &facet_list,
4272 : : char *filename)
4273 : : {
4274 : :
4275 : : // open the file for writing
4276 : :
4277 [ # # ]: 0 : FILE *fp = fopen(filename, "w");
4278 [ # # ]: 0 : if (!fp)
4279 : : {
4280 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't open file %s for writing.\n", filename);
[ # # ][ # # ]
4281 : 0 : return CUBIT_FAILURE;
4282 : : }
4283 : :
4284 : : // make list of all points
4285 : :
4286 : : CubitPoint *point_ptr;
4287 : : CubitFacet *facet_ptr;
4288 [ # # ]: 0 : DLIList<CubitPoint*>temp_point_list;
4289 : : int ii, jj;
4290 [ # # ][ # # ]: 0 : for (ii=0; ii<facet_list.size(); ii++)
4291 : : {
4292 [ # # ]: 0 : facet_ptr = facet_list.get_and_step();
4293 [ # # ]: 0 : for(jj=0; jj<3; jj++)
4294 : : {
4295 [ # # ]: 0 : point_ptr = facet_ptr->point(jj);
4296 [ # # ]: 0 : point_ptr->marked(-1);
4297 [ # # ]: 0 : temp_point_list.append(point_ptr);
4298 : : }
4299 : : }
4300 : :
4301 : : // assign ids to points and make list unique
4302 : :
4303 : 0 : int id = 0;
4304 [ # # ][ # # ]: 0 : DLIList<CubitPoint*>point_list;
4305 [ # # ][ # # ]: 0 : for (ii=0; ii<temp_point_list.size(); ii++)
4306 : : {
4307 [ # # ]: 0 : point_ptr = temp_point_list.get_and_step();
4308 [ # # ][ # # ]: 0 : if (point_ptr->marked() == -1)
4309 : : {
4310 [ # # ]: 0 : point_ptr->marked(id++);
4311 [ # # ]: 0 : point_list.append( point_ptr );
4312 : : }
4313 : : }
4314 : :
4315 : : // write the points
4316 : :
4317 [ # # ]: 0 : CubitVector coords;
4318 [ # # ][ # # ]: 0 : fprintf(fp, "%d\n", point_list.size());
4319 [ # # ]: 0 : point_list.reset();
4320 [ # # ][ # # ]: 0 : for(ii=0; ii<point_list.size(); ii++)
4321 : : {
4322 [ # # ]: 0 : point_ptr = point_list.get_and_step();
4323 [ # # ][ # # ]: 0 : coords = point_ptr->coordinates();
4324 [ # # ][ # # ]: 0 : fprintf(fp,"%d %f %f %f\n", ii, coords.x(), coords.y(), coords.z());
[ # # ][ # # ]
4325 : : }
4326 : :
4327 : : // write the facets
4328 : :
4329 : : int indx[3];
4330 [ # # ][ # # ]: 0 : fprintf(fp, "%d\n", facet_list.size());
4331 [ # # ][ # # ]: 0 : for (ii=0; ii<facet_list.size(); ii++)
4332 : : {
4333 [ # # ]: 0 : facet_ptr = facet_list.get_and_step();
4334 [ # # ]: 0 : for (jj=0; jj<3; jj++)
4335 : : {
4336 [ # # ][ # # ]: 0 : indx[jj] = facet_ptr->point(jj)->marked();
4337 : : }
4338 [ # # ]: 0 : fprintf(fp,"%d %d %d %d\n", ii, indx[0], indx[1], indx[2]);
4339 : : }
4340 : :
4341 : : //- unmark the points
4342 : :
4343 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
4344 [ # # ][ # # ]: 0 : point_list.get_and_step()->marked(0);
4345 : :
4346 [ # # ]: 0 : fclose(fp);
4347 [ # # ]: 0 : return CUBIT_SUCCESS;
4348 : : }
4349 : :
4350 : : //=============================================================================
4351 : : //Function: init_hash_point (PRIVATE)
4352 : : //Description: create a hash array of all points. They are hashed based on the
4353 : : // id of the point
4354 : : //Author: sjowen
4355 : : //Date: 4/3/01
4356 : : //=============================================================================
4357 : 0 : CubitStatus FacetQueryEngine::init_hash_points( int num_points )
4358 : : {
4359 : : /* === find the next highest prime number */
4360 : :
4361 : 0 : hashPointSize = num_points / 10;
4362 : : int i;
4363 [ # # ]: 0 : if (hashPointSize < 13) hashPointSize = 13;
4364 : : else
4365 : : {
4366 : 0 : i=2;
4367 [ # # ]: 0 : while (i<hashPointSize*0.5 + 1) {
4368 [ # # ]: 0 : if (hashPointSize % i == 0) {
4369 : 0 : i=2;
4370 : 0 : hashPointSize++;
4371 : : }
4372 : : else {
4373 : 0 : i++;
4374 : : }
4375 : : }
4376 : : }
4377 [ # # ][ # # ]: 0 : hashPointArray = new DLIList<CubitPoint*>[hashPointSize];
[ # # # # ]
4378 : :
4379 [ # # ]: 0 : return CUBIT_SUCCESS;
4380 : : }
4381 : :
4382 : : //=============================================================================
4383 : : //Function: add_hash_point (PRIVATE)
4384 : : //Description: hash the point into the hash table
4385 : : //Author: sjowen
4386 : : //Date: 4/3/02
4387 : : //=============================================================================
4388 : 0 : CubitStatus FacetQueryEngine::add_hash_point( CubitPoint *point_ptr )
4389 : : {
4390 : 0 : int id = point_ptr->id();
4391 : 0 : int key = get_hash_key( id );
4392 : 0 : hashPointArray[key].append( point_ptr );
4393 : 0 : return CUBIT_SUCCESS;
4394 : : }
4395 : :
4396 : : //=============================================================================
4397 : : //Function: get_hash_point (PRIVATE)
4398 : : //Description: retreive the CubitPoint pointer from the id
4399 : : //Author: sjowen
4400 : : //Date: 4/3/02
4401 : : //=============================================================================
4402 : 0 : CubitPoint *FacetQueryEngine::get_hash_point( int id )
4403 : : {
4404 : 0 : int key = get_hash_key( id );
4405 : : int ii;
4406 : 0 : int found = 0;
4407 : : CubitPoint *point_ptr;
4408 [ # # ][ # # ]: 0 : for (ii=0; ii<hashPointArray[key].size() && !found; ii++)
[ # # ]
4409 : : {
4410 : 0 : point_ptr = hashPointArray[key].get_and_step();
4411 [ # # ]: 0 : if (point_ptr->id() == id)
4412 : : {
4413 : 0 : return point_ptr;
4414 : : }
4415 : : }
4416 : 0 : return (CubitPoint*)NULL;
4417 : : }
4418 : :
4419 : : //=============================================================================
4420 : : //Function: delete_hash_points (PRIVATE)
4421 : : //Description: delete the hash points stuff
4422 : : //Author: sjowen
4423 : : //Date: 4/3/02
4424 : : //=============================================================================
4425 : 0 : void FacetQueryEngine::delete_hash_points( )
4426 : : {
4427 [ # # ]: 0 : if (hashPointArray)
4428 [ # # ][ # # ]: 0 : delete [] hashPointArray;
4429 : 0 : hashPointArray = NULL;
4430 : 0 : hashPointSize = 0;
4431 : 0 : }
4432 : :
4433 : : //=============================================================================
4434 : : //Function: get_hash_key (PRIVATE)
4435 : : //Description:
4436 : : //Author: sjowen
4437 : : //Date: 4/3/02
4438 : : //=============================================================================
4439 : 0 : int FacetQueryEngine::get_hash_key( int id )
4440 : : {
4441 : 0 : int key = id % hashPointSize;
4442 : 0 : return key;
4443 : : }
4444 : :
4445 : : //===========================================================================
4446 : : //Function Name: get_all_hash_points
4447 : : //Member Type: PUBLIC
4448 : : //Description: makes a single list from all points in the hash table
4449 : : //===========================================================================
4450 : 0 : CubitStatus FacetQueryEngine::get_all_hash_points(
4451 : : DLIList<CubitPoint *> &point_list ) // return point list
4452 : : {
4453 : 0 : CubitStatus rv = CUBIT_SUCCESS;
4454 : :
4455 : : int ii, jj;
4456 : : CubitPoint *point_ptr;
4457 [ # # ]: 0 : for(jj=0; jj<hashPointSize; jj++)
4458 : : {
4459 [ # # ][ # # ]: 0 : for (ii=0; ii<hashPointArray[jj].size(); ii++)
4460 : : {
4461 [ # # ]: 0 : point_ptr = hashPointArray[jj].get_and_step();
4462 [ # # ]: 0 : point_list.append(point_ptr);
4463 : : }
4464 : : }
4465 : :
4466 : 0 : return rv;
4467 : : }
4468 : :
4469 : : //===========================================================================
4470 : : //Function Name: save_facets
4471 : : //Member Type: PUBLIC
4472 : : //Description: save the facets from the entities to a Cubit file
4473 : : //Author: sjowen
4474 : : //Date: 1/16/2003
4475 : : //===========================================================================
4476 : 55 : CubitStatus FacetQueryEngine::save_facets(
4477 : : FILE *fp, // file we are dumping to
4478 : : DLIList<FacetSurface*> facet_surfaces,
4479 : : DLIList<FacetCurve*> facet_curves,
4480 : : DLIList<FacetPoint*> facet_points ) // save facets from these entities
4481 : : {
4482 : 55 : CubitStatus rv = CUBIT_SUCCESS;
4483 : :
4484 [ + - ]: 55 : DLIList<CubitFacet *> facet_list;
4485 [ + - ][ + - ]: 110 : DLIList<CubitFacetEdge *> edge_list;
4486 [ + - ][ + - ]: 110 : DLIList<CubitPoint *> point_list;
4487 : :
4488 : : // get a unique list of all facets, edges and points
4489 : : rv = gather_facets(facet_surfaces, facet_curves, facet_points,
4490 [ + - ][ + - ]: 55 : facet_list, edge_list, point_list );
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
4491 : :
4492 [ - + ]: 55 : if (rv != CUBIT_SUCCESS)
4493 : 0 : return rv;
4494 : :
4495 : : // dump the facet entities the file
4496 : :
4497 [ + - ]: 55 : rv = dump_facets( fp, facet_list, edge_list, point_list );
4498 [ - + ]: 55 : if (rv != CUBIT_SUCCESS)
4499 : 0 : return rv;
4500 : :
4501 : : // dump the CurveFacetEvalTools and FacetEval Tools
4502 [ + - ][ + - ]: 55 : rv = save_eval_tools( fp, facet_surfaces, facet_curves );
[ + - ][ + - ]
[ + - ]
4503 : :
4504 [ + - ]: 110 : return rv;
4505 : : }
4506 : :
4507 : : //===========================================================================
4508 : : //Function Name: save_eval_tools
4509 : : //Member Type: PUBLIC
4510 : : //Description: go through the RefEntities and save the CurveFacetEvalTools
4511 : : // and FacetEvalTools. These are essentially lists of facets
4512 : : // that are owned by the curve or surface
4513 : : //Authors: sjowen & cdernst
4514 : : //Date: 1/21/2003
4515 : : //===========================================================================
4516 : 55 : CubitStatus FacetQueryEngine::save_eval_tools(
4517 : : FILE *fp, // cubit file we are dumping to
4518 : : DLIList<FacetSurface*> facet_surfaces,
4519 : : DLIList<FacetCurve*> facet_curves )
4520 : : {
4521 : :
4522 : : int ii;
4523 : : FacetSurface *fsurf_ptr;
4524 : : FacetCurve *fcurv_ptr;
4525 : :
4526 : : //separate out eval tools and set ids
4527 [ + - ]: 55 : DLIList<CurveFacetEvalTool*> cfe_tools;
4528 [ + - ][ + - ]: 110 : DLIList<FacetEvalTool*> fe_tools;
4529 : 55 : int ft_id = 0;
4530 : 55 : int cft_id = 0;
4531 : :
4532 [ + - ]: 55 : facet_surfaces.reset();
4533 [ + - ][ + + ]: 330 : for (ii=facet_surfaces.size(); ii--; )
4534 : : {
4535 [ + - ]: 275 : fsurf_ptr = facet_surfaces.get_and_step();
4536 [ + - ]: 275 : FacetEvalTool *feval_tool = fsurf_ptr->get_eval_tool();
4537 [ + - ]: 275 : if( feval_tool )
4538 : : {
4539 [ + - ]: 275 : feval_tool->set_output_id( ft_id++ );
4540 [ + - ]: 275 : fe_tools.append( feval_tool );
4541 : : }
4542 : : }
4543 : :
4544 [ + - ]: 55 : facet_curves.reset();
4545 [ + - ][ + + ]: 517 : for (ii=facet_curves.size(); ii--; )
4546 : : {
4547 [ + - ]: 462 : fcurv_ptr = facet_curves.get_and_step();
4548 [ + - ]: 462 : CurveFacetEvalTool *ceval_tool = fcurv_ptr->get_eval_tool();
4549 [ + - ]: 462 : if( ceval_tool )
4550 : : {
4551 [ + - ]: 462 : ceval_tool->set_output_id( cft_id++ );
4552 [ + - ]: 462 : cfe_tools.append( ceval_tool );
4553 : : }
4554 : : }
4555 : :
4556 : : //Write out number of FacetEvalTools
4557 [ + - ]: 55 : int count = fe_tools.size();
4558 [ + - ][ + - ]: 110 : NCubitFile::CIOWrapper cio(fp);
4559 [ + - ]: 55 : cio.Write( reinterpret_cast<UnsignedInt32*>(&count), 1 );
4560 : :
4561 : : //Write out each FacetEvalTool
4562 [ + - ]: 55 : fe_tools.reset();
4563 [ + - ][ + + ]: 330 : for( ii=0; ii<fe_tools.size(); ii++)
4564 : : {
4565 [ + - ]: 275 : FacetEvalTool *feval_tool = fe_tools.get_and_step();
4566 [ + - ]: 275 : feval_tool->save( fp );
4567 : : }
4568 : :
4569 : : //Write out number of CurveFacetEvalTools
4570 [ + - ]: 55 : count = cfe_tools.size();
4571 [ + - ]: 55 : cio.Write( reinterpret_cast<UnsignedInt32*>(&count), 1 );
4572 : :
4573 : : //Write out each CurveFacetEvalTool
4574 [ + - ]: 55 : cfe_tools.reset();
4575 [ + - ][ + + ]: 517 : for( ii=0; ii<cfe_tools.size(); ii++)
4576 : : {
4577 [ + - ]: 462 : CurveFacetEvalTool *ceval_tool = cfe_tools.get_and_step();
4578 [ + - ]: 462 : ceval_tool->save( fp );
4579 : : }
4580 : :
4581 [ + - ]: 55 : return CUBIT_SUCCESS;
4582 : : }
4583 : :
4584 : : //===============================================================================
4585 : : // Function : restore_eval_tools
4586 : : // Member Type: PUBLIC
4587 : : // Description: restore the curve and surface eval tools
4588 : : // Author : sjowen
4589 : : // Date : 1/26/03
4590 : : //===============================================================================
4591 : 11 : CubitStatus FacetQueryEngine::restore_eval_tools(
4592 : : FILE *fp, // CUB file we are currently reading
4593 : : unsigned int endian,
4594 : : int num_facets, // list of facet entities already read from the CUB file
4595 : : int num_edges, // that we will assign to the eval tools. Index into
4596 : : int num_points, // the array is the same as ID
4597 : : CubitFacet **facets,
4598 : : CubitFacetEdge **edges,
4599 : : CubitPoint **points,
4600 : : int &num_cfet,
4601 : : int &num_fet,
4602 : : CurveFacetEvalTool **&cfeval_tools,
4603 : : FacetEvalTool **&feval_tools) // return list of curve and surface tools
4604 : : {
4605 [ + - ]: 11 : NCubitFile::CIOWrapper cio(endian, fp);
4606 : :
4607 : : int ii;
4608 : : FacetEvalTool *fsurf_ptr;
4609 : : CurveFacetEvalTool *fcurv_ptr;
4610 : :
4611 : : // read the number of facet eval tools
4612 : : // we are about to read from the CUB file
4613 [ + - ]: 11 : cio.Read(reinterpret_cast<UnsignedInt32*>(&num_fet), 1);
4614 : :
4615 [ + - ][ + - ]: 11 : feval_tools = new FacetEvalTool *[num_fet];
4616 : :
4617 : : // read all the facet surface eval tools
4618 : :
4619 [ + + ]: 143 : for (ii=0; ii<num_fet; ii++)
4620 : : {
4621 : : /*
4622 : : // read the topo ID from the CUB file. This will be stored as the
4623 : : // FacetEvalTool toolID and serve as the means to associate this
4624 : : // eval tool with it's topology entity
4625 : : UnsignedInt32 surf_id = 0;
4626 : : cio.Read(&surf_id, 1);
4627 : : int topo_id = (int)surf_id; */
4628 : :
4629 : : // read the facet eval tool data and create the tool
4630 [ + - ][ + - ]: 132 : fsurf_ptr = new FacetEvalTool();
4631 : : fsurf_ptr->restore(fp, endian, num_facets,
4632 : : num_edges, num_points,
4633 [ + - ]: 132 : facets, edges, points);
4634 [ - + ]: 132 : if (fsurf_ptr == NULL)
4635 : : {
4636 [ # # ][ # # ]: 0 : PRINT_ERROR("Error restoring mesh-based geometry\n");
[ # # ][ # # ]
4637 : 0 : return CUBIT_FAILURE;
4638 : : }
4639 : 132 : feval_tools[ii] = fsurf_ptr;
4640 : : }
4641 : :
4642 : : // read the number of curves
4643 [ + - ]: 11 : cio.Read(reinterpret_cast<UnsignedInt32*>(&num_cfet), 1);
4644 [ + - ][ + - ]: 11 : cfeval_tools = new CurveFacetEvalTool *[num_cfet];
4645 : :
4646 : : // read all the curve facet eval tools. Same thing as surfaces
4647 : :
4648 [ + + ]: 275 : for (ii=0; ii<num_cfet; ii++)
4649 : : {
4650 : : // read the facet eval tool data and create the tool
4651 [ + - ][ + - ]: 264 : fcurv_ptr = new CurveFacetEvalTool();
4652 : : fcurv_ptr->restore(fp, endian, num_edges, num_points,
4653 [ + - ]: 264 : edges, points, num_fet, feval_tools );
4654 [ - + ]: 264 : if (fcurv_ptr == NULL)
4655 : : {
4656 [ # # ][ # # ]: 0 : PRINT_ERROR("Error restoring mesh-based geometry\n");
[ # # ][ # # ]
4657 : 0 : return CUBIT_FAILURE;
4658 : : }
4659 : :
4660 : 264 : cfeval_tools[ii] = fcurv_ptr;
4661 : : }
4662 : :
4663 [ + - ]: 11 : return CUBIT_SUCCESS;
4664 : : }
4665 : :
4666 : :
4667 : : //===========================================================================
4668 : : //Function Name: dump_facets
4669 : : //Member Type: PUBLIC
4670 : : //Description: dump the facets and associated data to the cubit file
4671 : : //Authors: sjowen & cdernst
4672 : : //Date: 1/16/2003
4673 : : //===========================================================================
4674 : 55 : CubitStatus FacetQueryEngine::dump_facets(
4675 : : FILE *fp, // file we are dumping to
4676 : : DLIList<CubitFacet *> &facet_list, // return unique list of facets
4677 : : DLIList<CubitFacetEdge *> &edge_list, // return unique list of edges
4678 : : DLIList<CubitPoint *> &point_list ) // return unique list of points
4679 : : {
4680 : :
4681 [ + - ]: 55 : NCubitFile::CIOWrapper cio(fp);
4682 : : typedef NCubitFile::UnsignedInt32 UnsignedInt32;
4683 : :
4684 : : // Gather CubitPoint Data
4685 [ + - ]: 55 : int npoints = point_list.size();
4686 : 55 : int nnormals = 0;
4687 [ + - ][ + - ]: 55 : double* uvs_array = new double [npoints * 3];
4688 [ + - ][ + - ]: 55 : double* coord_array = new double [npoints * 3];
4689 : : //double* du_array = new double [npoints * 3];
4690 : : //double* dv_array = new double [npoints * 3];
4691 : 55 : int c_zero_points = 0;
4692 : 55 : int c_zero_int_data_size = 0;
4693 : 55 : int c_zero_double_data_size = 0;
4694 : : int ii;
4695 [ + - ][ + - ]: 110 : DLIList<CubitPoint*> has_td_boundary_point;
4696 [ + - ][ + - ]: 110 : DLIList<CubitPoint*> points_with_normal;
4697 : :
4698 : : TDFacetBoundaryPoint *td_fbp;
4699 : : CubitPoint *cp_ptr;
4700 [ + - ]: 55 : CubitVector coord, *normal;
4701 [ + - ]: 55 : point_list.reset();
4702 [ + - ][ + + ]: 715 : for (ii=0; ii<point_list.size(); ii++)
4703 : : {
4704 [ + - ]: 660 : cp_ptr = point_list.get_and_step();
4705 : :
4706 : : // write out uVal, vVal, sizeVal
4707 [ + - ]: 660 : uvs_array[ii*3] = cp_ptr->u();
4708 [ + - ]: 660 : uvs_array[ii*3+1] = cp_ptr->v();
4709 [ + - ]: 660 : uvs_array[ii*3+2] = cp_ptr->size();
4710 : : // coordinates
4711 [ + - ][ + - ]: 660 : coord = cp_ptr->coordinates();
4712 [ + - ]: 660 : coord_array[ii*3] = coord.x();
4713 [ + - ]: 660 : coord_array[ii*3+1] = coord.y();
4714 [ + - ]: 660 : coord_array[ii*3+2] = coord.z();
4715 : : // surfNormal
4716 [ + - ][ + + ]: 660 : if( cp_ptr->normal_ptr() )
4717 [ + - ]: 88 : points_with_normal.append( cp_ptr );
4718 : :
4719 : : /*
4720 : : // surfU
4721 : : du = cp_ptr->du();
4722 : : du_array[ii*3] = du.x();
4723 : : du_array[ii*3+1] = du.y();
4724 : : du_array[ii*3+2] = du.z();
4725 : : // surfV
4726 : : dv = cp_ptr->dv();
4727 : : dv_array[ii*3] = dv.x();
4728 : : dv_array[ii*3+1] = dv.y();
4729 : : dv_array[ii*3+2] = dv.z(); */
4730 : :
4731 [ + - ][ + + ]: 660 : if ((td_fbp = TDFacetBoundaryPoint::get_facet_boundary_point( cp_ptr ))!= NULL)
4732 : : {
4733 [ + - ]: 484 : has_td_boundary_point.append( cp_ptr );
4734 : 484 : c_zero_points++;
4735 : : td_fbp->get_boundary_point_data_size( c_zero_int_data_size,
4736 [ + - ]: 484 : c_zero_double_data_size );
4737 : : }
4738 : : }
4739 : :
4740 : : // Normals
4741 [ + - ]: 55 : nnormals = points_with_normal.size();
4742 : 55 : double* normal_array = NULL;
4743 : 55 : int* normal_ids = NULL;
4744 [ + - ]: 55 : points_with_normal.reset();
4745 [ + + ]: 55 : if( nnormals > 0 )
4746 : : {
4747 [ + - ][ + - ]: 11 : normal_array = new double [nnormals* 3];
4748 [ + - ][ + - ]: 11 : normal_ids = new int[nnormals];
4749 [ + - ]: 11 : points_with_normal.reset();
4750 [ + + ]: 99 : for( ii=0; ii<nnormals; ii++)
4751 : : {
4752 [ + - ]: 88 : cp_ptr = points_with_normal.get_and_step();
4753 [ + - ]: 88 : normal_ids[ii] = cp_ptr->id();
4754 [ + - ]: 88 : normal = cp_ptr->normal_ptr();
4755 [ + - ]: 88 : normal_array[ii*3] = normal->x();
4756 [ + - ]: 88 : normal_array[ii*3+1] = normal->y();
4757 [ + - ]: 88 : normal_array[ii*3+2] = normal->z();
4758 : : }
4759 : : }
4760 : :
4761 : : // write arrays --CubitPoint
4762 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&npoints), 1);
4763 [ + - ]: 55 : if( npoints > 0 )
4764 : : {
4765 [ + - ]: 55 : cio.Write(coord_array, npoints*3);
4766 [ + - ]: 55 : cio.Write(uvs_array, npoints*3);
4767 : : }
4768 : :
4769 : : // clean up
4770 [ + - ]: 55 : delete [] uvs_array;
4771 [ + - ]: 55 : delete [] coord_array;
4772 : 55 : uvs_array = NULL;
4773 : 55 : coord_array = NULL;
4774 : :
4775 : : // write normals & ids of points to which normals belong
4776 [ + - ]: 55 : cio.Write( reinterpret_cast<UnsignedInt32*>(&nnormals), 1 );
4777 [ + + ]: 55 : if( nnormals > 0 )
4778 : : {
4779 [ + - ]: 11 : cio.Write(normal_array, nnormals*3);
4780 [ + - ]: 11 : cio.Write(reinterpret_cast<UnsignedInt32*>(normal_ids), nnormals);
4781 [ + - ]: 11 : delete [] normal_array;
4782 [ + - ]: 11 : delete [] normal_ids;
4783 : 11 : normal_array = NULL;
4784 : 11 : normal_ids = NULL;
4785 : : }
4786 : :
4787 : : // Gather CubitFacetEdge Data
4788 : : int jj, idx;
4789 [ + - ]: 55 : int nedges = edge_list.size();
4790 : 55 : int nctrl_pts = nedges * NUM_EDGE_CPTS;
4791 : : CubitFacetEdge *edge_ptr;
4792 : : CubitVector *edge_ctrl_pts;
4793 [ + - ][ + - ]: 55 : double* control_points = new double [nctrl_pts * 3];
4794 [ + - ][ + - ]: 55 : UnsignedInt32* edge_vert_array = new UnsignedInt32 [nedges * 2];
4795 [ + + ]: 1353 : for(ii=0; ii<nedges; ii++)
4796 : : {
4797 : : // pointArray[2]
4798 [ + - ]: 1298 : edge_ptr = edge_list.get_and_step();
4799 [ + - ][ + - ]: 1298 : edge_vert_array[ii*2] = edge_ptr->point(0)->id();
4800 [ + - ][ + - ]: 1298 : edge_vert_array[ii*2+1] = edge_ptr->point(1)->id();
4801 [ + - ]: 1298 : edge_ctrl_pts = edge_ptr->control_points();
4802 : :
4803 : : // controlPoints[3]
4804 [ + - ]: 1298 : if (nctrl_pts > 0)
4805 : : {
4806 [ - + ]: 1298 : if (!edge_ctrl_pts)
4807 : : {
4808 : 0 : nctrl_pts = 0;
4809 : 0 : continue;
4810 : : }
4811 [ + + ]: 5192 : for(jj=0; jj<NUM_EDGE_CPTS; jj++)
4812 : : {
4813 : 3894 : idx = (ii*NUM_EDGE_CPTS+jj)*3;
4814 [ + - ]: 3894 : control_points[idx] = edge_ctrl_pts[jj].x();
4815 [ + - ]: 3894 : control_points[idx+1] = edge_ctrl_pts[jj].y();
4816 [ + - ]: 3894 : control_points[idx+2] = edge_ctrl_pts[jj].z();
4817 : : }
4818 : : }
4819 : : }
4820 : :
4821 : : // write arrays --CubitFacetEdge
4822 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&nedges), 1);
4823 [ + - ]: 55 : if( nedges > 0 )
4824 : : {
4825 [ + - ]: 55 : cio.Write(edge_vert_array, nedges*2 );
4826 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&nctrl_pts), 1);
4827 [ + - ]: 55 : if (nctrl_pts > 0)
4828 [ + - ]: 55 : cio.Write(control_points, nctrl_pts*3);
4829 : : }
4830 : :
4831 : : // clean up
4832 [ + - ]: 55 : delete [] edge_vert_array;
4833 [ + - ]: 55 : delete [] control_points;
4834 : 55 : edge_vert_array = NULL;
4835 : 55 : control_points = NULL;
4836 : :
4837 : : // Gather CubitFacet Data
4838 [ + - ]: 55 : int nfacets = facet_list.size();
4839 : 55 : nctrl_pts = nfacets * NUM_TRI_CPTS;
4840 : : CubitFacet *facet_ptr;
4841 : : CubitVector *facet_ctrl_pts;
4842 [ + - ][ + - ]: 55 : control_points = new double [nctrl_pts * 3];
4843 [ + - ][ + - ]: 55 : UnsignedInt32* facet_edge_array = new UnsignedInt32 [nfacets * 3];
4844 [ + - ][ + - ]: 55 : int *int_data = new int[ nfacets * 2 ];
4845 [ + - ]: 55 : facet_list.reset();
4846 [ + + ]: 847 : for (ii=0; ii<nfacets; ii++)
4847 : : {
4848 [ + - ]: 792 : facet_ptr = facet_list.get_and_step();
4849 : :
4850 : : // is Flat and isBackwards
4851 [ + - ]: 792 : int_data[ii*2] = facet_ptr->is_flat();
4852 [ + - ]: 792 : int_data[ii*2+1] = facet_ptr->is_backwards();
4853 : :
4854 : : // edgeArray[3]
4855 [ + - ][ + - ]: 792 : facet_edge_array[ii*3] = facet_ptr->edge(0)->id();
4856 [ + - ][ + - ]: 792 : facet_edge_array[ii*3+1] = facet_ptr->edge(1)->id();
4857 [ + - ][ + - ]: 792 : facet_edge_array[ii*3+2] = facet_ptr->edge(2)->id();
4858 [ + - ]: 792 : facet_ctrl_pts = facet_ptr->control_points();
4859 [ + + ]: 792 : if(nctrl_pts > 0)
4860 : : {
4861 [ + + ]: 176 : if (!facet_ctrl_pts)
4862 : : {
4863 : 44 : nctrl_pts = 0;
4864 : 44 : continue;
4865 : : }
4866 [ + + ]: 924 : for(jj=0; jj<NUM_TRI_CPTS; jj++)
4867 : : {
4868 : 792 : idx = (ii*NUM_TRI_CPTS+jj)*3;
4869 [ + - ]: 792 : control_points[idx] = facet_ctrl_pts[jj].x();
4870 [ + - ]: 792 : control_points[idx+1] = facet_ctrl_pts[jj].y();
4871 [ + - ]: 792 : control_points[idx+2] = facet_ctrl_pts[jj].z();
4872 : : }
4873 : : }
4874 : : }
4875 : :
4876 : : // write arrays --CubitFacet
4877 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&nfacets), 1);
4878 [ + - ]: 55 : if( nfacets > 0 )
4879 : : {
4880 [ + - ]: 55 : cio.Write(facet_edge_array, nfacets*3);
4881 [ + - ]: 55 : cio.Write( reinterpret_cast<UnsignedInt32*>(int_data), nfacets*2 );
4882 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&nctrl_pts), 1);
4883 [ + + ]: 55 : if (nctrl_pts > 0)
4884 [ + - ]: 11 : cio.Write(control_points, nctrl_pts*3);
4885 : : }
4886 : :
4887 : : // clean up
4888 [ + - ]: 55 : delete [] facet_edge_array;
4889 [ + - ]: 55 : delete [] control_points;
4890 [ + - ]: 55 : delete [] int_data;
4891 : 55 : facet_edge_array = NULL;
4892 : 55 : control_points = NULL;
4893 : 55 : int_data = NULL;
4894 : :
4895 : :
4896 : : // At points along the boundary (C0 continuity) there may be
4897 : : // multiple normals. Write this data too. First gether it
4898 : : // into two arrays and then dump.
4899 : :
4900 [ + - ]: 55 : cio.Write(reinterpret_cast<UnsignedInt32*>(&c_zero_points), 1);
4901 [ + + ]: 55 : if (c_zero_points > 0)
4902 : : {
4903 [ + - ][ + - ]: 44 : int *c_zero_int_data = new int [c_zero_int_data_size];
4904 [ + - ][ + - ]: 44 : double *c_zero_double_data = new double [c_zero_double_data_size];
4905 [ + - ]: 44 : point_list.reset();
4906 : 44 : int iidx = 0;
4907 : 44 : int didx = 0;
4908 [ + - ]: 44 : point_list.reset();
4909 [ + - ][ + + ]: 660 : for (ii=0; ii<point_list.size(); ii++)
4910 : : {
4911 [ + - ]: 616 : cp_ptr = point_list.get_and_step();
4912 [ + - ]: 616 : td_fbp = TDFacetBoundaryPoint::get_facet_boundary_point( cp_ptr );
4913 [ + + ]: 616 : if (td_fbp != NULL)
4914 : : {
4915 : : td_fbp->get_boundary_point_data( c_zero_int_data,
4916 : : c_zero_double_data,
4917 [ + - ]: 484 : iidx, didx );
4918 : : }
4919 : : }
4920 : :
4921 : : // dump the int data array
4922 : :
4923 [ + - ]: 44 : cio.Write(reinterpret_cast<UnsignedInt32*>(&c_zero_int_data_size), 1);
4924 : : //convert to UnsignedInt32
4925 [ + - ][ + - ]: 44 : UnsignedInt32 *c_zero_int32_data = new UnsignedInt32 [c_zero_int_data_size];
4926 [ + + ]: 4752 : for (ii=0; ii<c_zero_int_data_size; ii++)
4927 : 4708 : c_zero_int32_data[ii] = (UnsignedInt32)c_zero_int_data[ii];
4928 [ + - ]: 44 : cio.Write(c_zero_int32_data, c_zero_int_data_size);
4929 : :
4930 : : // dump the double array
4931 : :
4932 [ + - ]: 44 : cio.Write(reinterpret_cast<UnsignedInt32*>(&c_zero_double_data_size), 1);
4933 [ + - ]: 44 : cio.Write(c_zero_double_data, c_zero_double_data_size);
4934 : :
4935 : : // clean up
4936 [ + - ]: 44 : delete [] c_zero_int_data;
4937 [ + - ]: 44 : delete [] c_zero_int32_data;
4938 [ + - ]: 44 : delete [] c_zero_double_data;
4939 : : }
4940 : :
4941 [ + - ]: 55 : return CUBIT_SUCCESS;
4942 : : }
4943 : :
4944 : : //===========================================================================
4945 : : //Function Name: gather_facets
4946 : : //Member Type: PUBLIC
4947 : : //Description: get a unique list of facets from the entities
4948 : : //Author: sjowen
4949 : : //Date: 1/16/2003
4950 : : //===========================================================================
4951 : 55 : CubitStatus FacetQueryEngine::gather_facets(
4952 : : DLIList<FacetSurface *> facet_surfaces,
4953 : : DLIList<FacetCurve *> facet_curves,
4954 : : DLIList<FacetPoint *> facet_points,
4955 : : DLIList<CubitFacet *> &facet_list, // return unique list of facets
4956 : : DLIList<CubitFacetEdge *> &edge_list, // return unique list of edges
4957 : : DLIList<CubitPoint *> &point_list) // return unique list of points
4958 : : {
4959 : : int ii, jj, kk;
4960 : : FacetSurface *fsurf_ptr;
4961 : : FacetCurve *fcurv_ptr;
4962 : : FacetPoint *fpoint_ptr;
4963 [ + - ]: 55 : DLIList<CubitFacet *>temp_facets;
4964 [ + - ][ + - ]: 110 : DLIList<CubitPoint *>temp_points;
4965 [ + - ][ + - ]: 110 : DLIList<CubitFacetEdge *>temp_edges;
4966 : :
4967 : : CubitFacet *facet_ptr;
4968 : : CubitFacetEdge *edge_ptr;
4969 : : CubitPoint *cp_ptr;
4970 : :
4971 : : //unmark facets/edges/points on surface
4972 [ + - ][ + + ]: 330 : for(ii=facet_surfaces.size(); ii--;)
4973 : : {
4974 [ + - ]: 275 : fsurf_ptr = facet_surfaces.get_and_step();
4975 [ + - ]: 275 : temp_facets.clean_out();
4976 [ + - ]: 275 : temp_points.clean_out();
4977 [ + - ]: 275 : fsurf_ptr->get_my_facets(temp_facets, temp_points);
4978 [ + - ][ + + ]: 1067 : for(jj=0; jj<temp_facets.size(); jj++)
4979 : : {
4980 [ + - ]: 792 : facet_ptr = temp_facets.get_and_step();
4981 [ + - ]: 792 : facet_ptr->marked( 0 );
4982 [ + + ]: 3168 : for (kk=0; kk<3; kk++)
4983 : : {
4984 [ + - ]: 2376 : edge_ptr = facet_ptr->edge( kk );
4985 [ + - ]: 2376 : edge_ptr->marked( 0 );
4986 : : }
4987 : : }
4988 [ + - ][ + + ]: 1463 : for (jj=0; jj<temp_points.size(); jj++)
4989 : : {
4990 [ + - ]: 1188 : cp_ptr = temp_points.get_and_step();
4991 [ + - ]: 1188 : cp_ptr->marked( 0 );
4992 : : }
4993 : : }
4994 : :
4995 : : //unmark facet-edges/points on curves
4996 [ + - ][ + + ]: 517 : for(ii=facet_curves.size(); ii--; )
4997 : : {
4998 [ + - ]: 462 : fcurv_ptr = facet_curves.get_and_step();
4999 [ + - ]: 462 : temp_edges.clean_out();
5000 [ + - ]: 462 : fcurv_ptr->get_facets( temp_edges );
5001 [ + - ][ + + ]: 1078 : for (jj=0; jj<temp_edges.size(); jj++)
5002 : : {
5003 [ + - ]: 616 : edge_ptr = temp_edges.get_and_step();
5004 [ + - ]: 616 : edge_ptr->marked( 0 );
5005 [ + - ][ + - ]: 616 : edge_ptr->point( 0 )->marked( 0 );
5006 [ + - ][ + - ]: 616 : edge_ptr->point( 1 )->marked( 0 );
5007 : : }
5008 : : }
5009 : :
5010 : : //unmark facet-points on points
5011 [ + - ][ + + ]: 385 : for(ii=facet_points.size(); ii--; )
5012 : : {
5013 [ + - ]: 330 : fpoint_ptr = facet_points.get_and_step();
5014 [ + - ]: 330 : if (fpoint_ptr != NULL)
5015 : : {
5016 [ + - ]: 330 : cp_ptr = fpoint_ptr->get_cubit_point();
5017 [ + - ]: 330 : cp_ptr->marked( 0 );
5018 : : }
5019 : : }
5020 : :
5021 : :
5022 : : // make unique lists
5023 [ + - ][ + + ]: 330 : for(ii=facet_surfaces.size(); ii--;)
5024 : : {
5025 [ + - ]: 275 : fsurf_ptr = facet_surfaces.get_and_step();
5026 [ + - ]: 275 : temp_facets.clean_out();
5027 [ + - ]: 275 : temp_points.clean_out();
5028 [ + - ]: 275 : fsurf_ptr->get_my_facets(temp_facets, temp_points);
5029 [ + - ][ + + ]: 1067 : for(jj=0; jj<temp_facets.size(); jj++)
5030 : : {
5031 [ + - ]: 792 : facet_ptr = temp_facets.get_and_step();
5032 [ + - ][ + - ]: 792 : if (0 == facet_ptr->marked())
5033 : : {
5034 [ + - ]: 792 : facet_ptr->marked( 1 );
5035 [ + - ]: 792 : facet_list.append( facet_ptr );
5036 : : }
5037 [ + + ]: 3168 : for (kk=0; kk<3; kk++)
5038 : : {
5039 [ + - ]: 2376 : edge_ptr = facet_ptr->edge( kk );
5040 [ + - ][ + + ]: 2376 : if (0 == edge_ptr->marked())
5041 : : {
5042 [ + - ]: 1298 : edge_ptr->marked( 1 );
5043 [ + - ]: 1298 : edge_list.append( edge_ptr );
5044 : : }
5045 : : }
5046 : : }
5047 [ + - ][ + + ]: 1463 : for (jj=0; jj<temp_points.size(); jj++)
5048 : : {
5049 [ + - ]: 1188 : cp_ptr = temp_points.get_and_step();
5050 [ + - ][ + + ]: 1188 : if (0 == cp_ptr->marked())
5051 : : {
5052 [ + - ]: 660 : cp_ptr->marked(1);
5053 [ + - ]: 660 : point_list.append( cp_ptr );
5054 : : }
5055 : : }
5056 : : }
5057 : :
5058 [ + - ][ + + ]: 517 : for(ii=facet_curves.size(); ii--;)
5059 : : {
5060 [ + - ]: 462 : fcurv_ptr = facet_curves.get_and_step();
5061 [ + - ]: 462 : temp_edges.clean_out();
5062 [ + - ]: 462 : fcurv_ptr->get_facets( temp_edges );
5063 [ + - ][ + + ]: 1078 : for (jj=0; jj<temp_edges.size(); jj++)
5064 : : {
5065 [ + - ]: 616 : edge_ptr = temp_edges.get_and_step();
5066 [ + - ][ - + ]: 616 : if (0 == edge_ptr->marked())
5067 : : {
5068 [ # # ]: 0 : edge_ptr->marked(1);
5069 [ # # ]: 0 : edge_list.append( edge_ptr );
5070 [ # # ]: 0 : for (kk=0; kk<2; kk++)
5071 : : {
5072 [ # # ]: 0 : cp_ptr = edge_ptr->point( kk );
5073 [ # # ][ # # ]: 0 : if (0 == cp_ptr->marked())
5074 : : {
5075 [ # # ]: 0 : cp_ptr->marked(1);
5076 [ # # ]: 0 : point_list.append(cp_ptr);
5077 : : }
5078 : : }
5079 : : }
5080 : : }
5081 : : }
5082 : :
5083 [ + - ][ + + ]: 385 : for(ii=facet_points.size(); ii--;)
5084 : : {
5085 [ + - ]: 330 : fpoint_ptr = facet_points.get_and_step();
5086 [ + - ]: 330 : cp_ptr = fpoint_ptr->get_cubit_point();
5087 [ + - ][ - + ]: 330 : if (0 == cp_ptr->marked())
5088 : : {
5089 [ # # ]: 0 : cp_ptr->marked( 1 );
5090 [ # # ]: 0 : point_list.append( cp_ptr );
5091 : : }
5092 : : }
5093 : :
5094 : : // set the IDs of the facet entities and clear the marks
5095 [ + - ]: 55 : facet_list.reset();
5096 [ + - ][ + + ]: 847 : for (ii=0; ii<facet_list.size(); ii++)
5097 : : {
5098 [ + - ]: 792 : facet_ptr = facet_list.get_and_step();
5099 [ + - ]: 792 : facet_ptr->set_id(ii);
5100 [ + - ]: 792 : facet_ptr->marked(0);
5101 : : }
5102 [ + - ]: 55 : edge_list.reset();
5103 [ + - ][ + + ]: 1353 : for (ii=0; ii<edge_list.size(); ii++)
5104 : : {
5105 [ + - ]: 1298 : edge_ptr = edge_list.get_and_step();
5106 [ + - ]: 1298 : edge_ptr->set_id(ii);
5107 [ + - ]: 1298 : edge_ptr->marked(0);
5108 : : }
5109 [ + - ][ + + ]: 715 : for (ii=0; ii<point_list.size(); ii++)
5110 : : {
5111 [ + - ]: 660 : cp_ptr = point_list.get_and_step();
5112 [ + - ]: 660 : cp_ptr->set_id(ii);
5113 [ + - ]: 660 : cp_ptr->marked(0);
5114 : : }
5115 : :
5116 [ + - ]: 55 : return CUBIT_SUCCESS;
5117 : : }
5118 : :
5119 : : //=============================================================================
5120 : : //Function: create_super_facet_bounding_box(PUBLIC)
5121 : : //Description: Find the bounding box of a list of BodySMs
5122 : : //Author: jdfowle
5123 : : //Date: 12/15/03
5124 : : //=============================================================================
5125 : 0 : CubitStatus FacetQueryEngine::create_super_facet_bounding_box(
5126 : : DLIList<BodySM*>& body_list,
5127 : : CubitBox& super_box )
5128 : : {
5129 : : BodySM *bodySM;
5130 : : int i;
5131 : 0 : CubitStatus status = CUBIT_SUCCESS;
5132 : :
5133 : 0 : body_list.reset();
5134 [ # # ]: 0 : for ( i = 0; i < body_list.size(); i++ ) {
5135 : 0 : bodySM = body_list.get_and_step();
5136 : 0 : create_facet_bounding_box(bodySM,super_box);
5137 : : }
5138 : :
5139 : 0 : return status;
5140 : : }
5141 : :
5142 : : //=============================================================================
5143 : : //Function: create_facet_bounding_box(PUBLIC)
5144 : : //Description: Find the bounding box of a BodySM
5145 : : //Author: jdfowle
5146 : : //Date: 12/15/03
5147 : : //=============================================================================
5148 : 0 : CubitStatus FacetQueryEngine::create_facet_bounding_box(
5149 : : BodySM* bodySM,
5150 : : CubitBox& bbox )
5151 : : {
5152 : : FacetBody *fbody_ptr;
5153 : : int j;
5154 [ # # ]: 0 : DLIList<FacetSurface*> facet_surf_list;
5155 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> facet_list;
5156 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> point_list;
5157 : : FacetSurface *facet_surface;
5158 [ # # ][ # # ]: 0 : CubitBox surf_bbox, total_box;
[ # # ][ # # ]
5159 : 0 : CubitStatus status = CUBIT_FAILURE;
5160 : :
5161 [ # # ]: 0 : fbody_ptr = dynamic_cast<FacetBody *>(bodySM);
5162 [ # # ]: 0 : fbody_ptr->get_surfaces(facet_surf_list);
5163 [ # # ][ # # ]: 0 : for ( j = 0; j < facet_surf_list.size(); j++ ) {
5164 [ # # ]: 0 : facet_surface = facet_surf_list.get_and_step();
5165 [ # # ]: 0 : facet_list.clean_out();
5166 [ # # ]: 0 : point_list.clean_out();
5167 [ # # ]: 0 : facet_surface->get_my_facets(facet_list,point_list);
5168 [ # # ]: 0 : status = FacetDataUtil::get_bbox_of_points(point_list,surf_bbox);
5169 : :
5170 [ # # ]: 0 : if ( j == 0 )
5171 [ # # ]: 0 : total_box = surf_bbox;
5172 : : else
5173 [ # # ]: 0 : total_box |= surf_bbox;
5174 : : }
5175 [ # # ]: 0 : bbox = total_box;
5176 : :
5177 [ # # ]: 0 : return status;
5178 : : }
5179 : :
5180 : : const char* fqe_xform_err = "Transform not implemented for facet geometry.\n";
5181 : 0 : CubitStatus FacetQueryEngine::restore_transform( BodySM* body )
5182 : : {
5183 [ # # ]: 0 : FacetBody* facetbod = dynamic_cast<FacetBody*>(body);
5184 [ # # ]: 0 : return facetbod ? facetbod->restore( ) : CUBIT_FAILURE;
5185 : : }
5186 : 11 : CubitStatus FacetQueryEngine::translate( BodySM* body, const CubitVector& d )
5187 : : {
5188 [ - + ]: 11 : FacetBody* facetbod = dynamic_cast<FacetBody*>(body);
5189 [ + - ]: 11 : return facetbod ? facetbod->move( d.x(), d.y(), d.z() ) : CUBIT_FAILURE;
5190 : : }
5191 : 0 : CubitStatus FacetQueryEngine::rotate( BodySM* body, const CubitVector& v, double a )
5192 : : {
5193 [ # # ]: 0 : FacetBody* facetbod = dynamic_cast<FacetBody*>(body);
5194 [ # # ]: 0 : return facetbod ? facetbod->rotate( v.x(), v.y(), v.z(), a ) : CUBIT_FAILURE;
5195 : : }
5196 : 0 : CubitStatus FacetQueryEngine::scale( BodySM* body, double factor )
5197 : : {
5198 [ # # ]: 0 : FacetBody* facetbod = dynamic_cast<FacetBody*>(body);
5199 [ # # ]: 0 : return facetbod ? facetbod->scale( factor ) : CUBIT_FAILURE;
5200 : : }
5201 : 0 : CubitStatus FacetQueryEngine::scale( BodySM* body, const CubitVector& f )
5202 : : {
5203 [ # # ]: 0 : FacetBody* facetbod = dynamic_cast<FacetBody*>(body);
5204 [ # # ]: 0 : return facetbod ? facetbod->scale( f.x(), f.y(), f.z() ) : CUBIT_FAILURE;
5205 : : }
5206 : :
5207 : 0 : CubitStatus FacetQueryEngine::translate( GeometryEntity* , const CubitVector& )
5208 : : {
5209 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", fqe_xform_err);
5210 : 0 : return CUBIT_FAILURE;
5211 : : }
5212 : 0 : CubitStatus FacetQueryEngine::rotate( GeometryEntity* , const CubitVector& , double )
5213 : : {
5214 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", fqe_xform_err);
5215 : 0 : return CUBIT_FAILURE;
5216 : : }
5217 : 0 : CubitStatus FacetQueryEngine::scale( GeometryEntity* , double )
5218 : : {
5219 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", fqe_xform_err);
5220 : 0 : return CUBIT_FAILURE;
5221 : : }
5222 : 0 : CubitStatus FacetQueryEngine::scale( GeometryEntity* , const CubitVector& )
5223 : : {
5224 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", fqe_xform_err);
5225 : 0 : return CUBIT_FAILURE;
5226 : : }
5227 : 0 : CubitStatus FacetQueryEngine::reflect( GeometryEntity* , const CubitVector& )
5228 : : {
5229 [ # # ][ # # ]: 0 : PRINT_ERROR("%s", fqe_xform_err);
5230 : 0 : return CUBIT_FAILURE;
5231 : : }
5232 : :
5233 : :
5234 : :
5235 : :
5236 : : //===============================================================================
5237 : : // Function : bodies_overlap
5238 : : // Member Type: PUBLIC
5239 : : // Description: determine if facet-based bodies overlap
5240 : : // Author : John Fowler
5241 : : // Date : 10/02
5242 : : //===============================================================================
5243 : 0 : CubitBoolean FacetQueryEngine::bodies_overlap (BodySM * /*body_ptr_1*/,
5244 : : BodySM * /*body_ptr_2*/ ) const
5245 : : {
5246 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine overlap for Facet-based geometry.\n");
5247 : 0 : return CUBIT_FALSE;
5248 : : //The following should work, but due to bug 5599, we are not
5249 : : // using it. Having this code in the default would cause the
5250 : : // GeometryPowerTool to rely on Facetbool, which isn't robust
5251 : : // yet.
5252 : : /*
5253 : : FacetboolInterface *fbint;
5254 : : CubitFacetboolOp op = CUBIT_FB_INTERSECTION;
5255 : : bool keep_old = true;
5256 : : CubitStatus status;
5257 : : BodySM* body_out = 0;
5258 : : bool intersection_found;
5259 : :
5260 : : fbint = new FacetboolInterface;
5261 : : status = fbint->dofacetboolean_2bodies(body_ptr_1,body_ptr_2,body_out,
5262 : : keep_old,intersection_found,op);
5263 : : if ( status == CUBIT_FAILURE ) return CUBIT_FALSE;
5264 : : else return CUBIT_TRUE;
5265 : : */
5266 : : }
5267 : :
5268 : 0 : CubitBoolean FacetQueryEngine::volumes_overlap (Lump * /*lump_ptr_1*/,
5269 : : Lump * /*lump_ptr_2*/ ) const
5270 : : {
5271 [ # # ][ # # ]: 0 : PRINT_ERROR("Currently, Cubit is unable to determine overlap for Facet-based geometry.\n");
5272 : 0 : return CUBIT_FALSE;
5273 : : }
5274 : :
5275 : 0 : CubitStatus FacetQueryEngine::get_point_containment( DLIList<BodySM*> &bodysm_list,
5276 : : DLIList<CubitVector> &point_list,
5277 : : double tolerance,
5278 : : bool allow_pts_in_multiple_bodies,
5279 : : std::vector< std::pair<BodySM*, std::vector<int> > > &bodysm_to_pt_indices )
5280 : : {
5281 : : //convert all the BodySMs into FacetBodies
5282 [ # # ]: 0 : DLIList<FacetBody*> body_list;
5283 [ # # ][ # # ]: 0 : for( int k=bodysm_list.size(); k--; )
5284 : : {
5285 [ # # ]: 0 : BodySM *body_sm = bodysm_list.get_and_step();
5286 [ # # ]: 0 : FacetBody *facet_body = dynamic_cast<FacetBody*>(body_sm);
5287 [ # # ]: 0 : if( !facet_body )
5288 : 0 : return CUBIT_FAILURE;
5289 [ # # ]: 0 : body_list.append( facet_body );
5290 : : }
5291 : :
5292 : : //stuff all the points into the atree
5293 [ # # ][ # # ]: 0 : AbstractTree<ContainmentPoint*> *atree = new RTree<ContainmentPoint*>( tolerance );
5294 : :
5295 [ # # ][ # # ]: 0 : std::vector<ContainmentPoint*> atree_nodes;
5296 [ # # ]: 0 : int num_points = point_list.size();
5297 [ # # ]: 0 : for( int i=0; i<num_points; i++ )
5298 : : {
5299 [ # # ]: 0 : ContainmentPoint *tmp_pt = new ContainmentPoint();
5300 [ # # ]: 0 : tmp_pt->pt_coordinates = &(point_list[i]);
5301 : 0 : tmp_pt->index = i;
5302 [ # # ]: 0 : atree->add( tmp_pt );
5303 [ # # ]: 0 : atree_nodes.push_back( tmp_pt );
5304 : : }
5305 : :
5306 [ # # ]: 0 : int num_bodies = body_list.size();
5307 : :
5308 [ # # ]: 0 : if( num_bodies > 10 )
5309 : : {
5310 : : char message[128];
5311 : 0 : sprintf(message, "Point containment routine: %d points %d volumes.", num_points, num_bodies );
5312 [ # # ][ # # ]: 0 : AppUtil::instance()->progress_tool()->start(0, num_bodies,
5313 [ # # ]: 0 : "Progress", message, TRUE, TRUE );
5314 : : }
5315 : :
5316 : : //for each body
5317 : : //get the points in the bbox of the body
5318 [ # # ][ # # ]: 0 : for( int i=0; i<body_list.size(); i++ )
5319 : : {
5320 [ # # ]: 0 : FacetBody *facet_body = body_list[i];
5321 [ # # ]: 0 : CubitBox cubit_box = facet_body->bounding_box();
5322 : :
5323 [ # # ][ # # ]: 0 : double range_ratio = cubit_box.maximum_range() / cubit_box.minimum_range();
5324 : :
5325 : : //find the points in the bounding box
5326 [ # # ][ # # ]: 0 : DLIList<ContainmentPoint*> close_pts;
[ # # ]
5327 [ # # ]: 0 : atree->find( cubit_box, close_pts );
5328 : :
5329 [ # # ][ # # ]: 0 : std::vector<int> pts_in_body;
[ # # ]
5330 : :
5331 : :
5332 : : //if( 0 ) // old ray-shooting
5333 : : //if( 1 ) // new octree
5334 [ # # ][ # # ]: 0 : if( range_ratio < CUTOFF_BBOX_RANGE_RATIO && (close_pts.size() > CUTOFF_NUM_NODES /*pow( pow(2, CUTOFF_OCTREE_DEPTH), 3) */ ) ) // smart
[ # # ][ # # ]
5335 : :
5336 : : {
5337 : : // build octree
5338 [ # # ][ # # ]: 0 : RefEntity* ref_ent = dynamic_cast<RefEntity*>( facet_body->topology_entity() );
5339 [ # # ]: 0 : DLIList<RefEntity*> ref_entity_list;
5340 [ # # ]: 0 : ref_entity_list.insert( ref_ent );
5341 [ # # ][ # # ]: 0 : CubitOctreeGeneratorVolumes octree_generator( ref_entity_list);
5342 [ # # ]: 0 : octree_generator.generate_full_octree();
5343 : :
5344 [ # # ][ # # ]: 0 : for( int k=0; k<close_pts.size(); k++ )
5345 : : {
5346 : : //ask each point if it is in the body
5347 [ # # ][ # # ]: 0 : CubitVector tmp_vec = *(close_pts[k]->pt_coordinates);
5348 : :
5349 : : CubitPointContainment pt_cont;
5350 [ # # ][ # # ]: 0 : pt_cont = octree_generator.point_containment( tmp_vec, tolerance );
5351 [ # # # # ]: 0 : switch( pt_cont )
5352 : : {
5353 : : case CUBIT_PNT_INSIDE:
5354 [ # # ]: 0 : if( false == allow_pts_in_multiple_bodies )
5355 [ # # ][ # # ]: 0 : atree->remove( close_pts[k] );
5356 [ # # ][ # # ]: 0 : pts_in_body.push_back( close_pts[k]->index );
5357 : : //GfxDebug::draw_point(tmp_vec.x(), tmp_vec.y(), tmp_vec.z(), CUBIT_BLUE_INDEX);
5358 : : //PRINT_INFO(" INSIDE ");
5359 : 0 : break;
5360 : :
5361 : : case CUBIT_PNT_BOUNDARY:
5362 [ # # ]: 0 : pt_cont = facet_body->point_containment( tmp_vec, tolerance );
5363 [ # # ][ # # ]: 0 : if( CUBIT_PNT_INSIDE == pt_cont || CUBIT_PNT_BOUNDARY == pt_cont )
5364 : : {
5365 [ # # ]: 0 : if( false == allow_pts_in_multiple_bodies )
5366 [ # # ][ # # ]: 0 : atree->remove( close_pts[k] );
5367 [ # # ][ # # ]: 0 : pts_in_body.push_back( close_pts[k]->index );
5368 : : }
5369 : : //GfxDebug::draw_point(tmp_vec.x(), tmp_vec.y(), tmp_vec.z(), CUBIT_GREEN_INDEX);
5370 : : //PRINT_INFO(" BOUNDARY ");
5371 : 0 : break;
5372 : :
5373 : : case CUBIT_PNT_OUTSIDE:
5374 : : // do nothing
5375 : : //GfxDebug::draw_point(tmp_vec.x(), tmp_vec.y(), tmp_vec.z(), CUBIT_RED_INDEX);
5376 : : //PRINT_INFO(" OUTSIDE ");
5377 : 0 : break;
5378 : :
5379 : : default:
5380 : 0 : break;
5381 : : }
5382 [ # # ]: 0 : }
5383 : : }
5384 : : else {
5385 [ # # ][ # # ]: 0 : for( int k=0; k<close_pts.size(); k++ )
5386 : : {
5387 : : //ask each point if it is in the body
5388 [ # # ][ # # ]: 0 : CubitVector tmp_vec = *(close_pts[k]->pt_coordinates);
5389 [ # # ]: 0 : CubitPointContainment pt_cont = facet_body->point_containment( tmp_vec, tolerance );
5390 [ # # ][ # # ]: 0 : if( CUBIT_PNT_INSIDE == pt_cont || CUBIT_PNT_BOUNDARY == pt_cont )
5391 : : {
5392 [ # # ]: 0 : if( false == allow_pts_in_multiple_bodies )
5393 [ # # ][ # # ]: 0 : atree->remove( close_pts[k] );
5394 [ # # ][ # # ]: 0 : pts_in_body.push_back( close_pts[k]->index );
5395 : : }
5396 : : }
5397 : : }
5398 : :
5399 [ # # ]: 0 : if( num_bodies > 10 )
5400 [ # # ][ # # ]: 0 : AppUtil::instance()->progress_tool()->step();
[ # # ]
5401 : :
5402 [ # # ][ # # ]: 0 : if(AppUtil::instance()->interrupt())
[ # # ]
5403 : : {
5404 [ # # ]: 0 : if( num_bodies > 10 )
5405 [ # # ][ # # ]: 0 : AppUtil::instance()->progress_tool()->end();
[ # # ]
5406 : :
5407 : : //clean up
5408 [ # # ][ # # ]: 0 : while( atree_nodes.size() )
5409 : : {
5410 [ # # ]: 0 : delete atree_nodes.back();
5411 [ # # ]: 0 : atree_nodes.pop_back();
5412 : : }
5413 [ # # ][ # # ]: 0 : delete atree;
5414 : 0 : return CUBIT_FAILURE;
5415 : : }
5416 : :
5417 [ # # ][ # # ]: 0 : bodysm_to_pt_indices.push_back( std::make_pair( bodysm_list[i], pts_in_body ) );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
5418 : 0 : }
5419 : :
5420 : : //cleanup
5421 [ # # ][ # # ]: 0 : while( atree_nodes.size() )
5422 : : {
5423 [ # # ]: 0 : delete atree_nodes.back();
5424 [ # # ]: 0 : atree_nodes.pop_back();
5425 : : }
5426 [ # # ][ # # ]: 0 : delete atree;
5427 : :
5428 [ # # ]: 0 : if( num_bodies > 10 )
5429 [ # # ][ # # ]: 0 : AppUtil::instance()->progress_tool()->end();
[ # # ]
5430 : :
5431 [ # # ]: 0 : return CUBIT_SUCCESS;
5432 [ + - ][ + - ]: 6540 : }
5433 : :
5434 : :
5435 : : //EOF
|
