Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : //-------------------------------------------------------------------------
3 : :
4 : : // Filename : FacetModifyEngine.cpp
5 : : //
6 : : // Purpose : ModifyEngine for faceted geometry
7 : : //
8 : : // Special Notes : Modeled after GeometryModifyEngine and OCCModifyEngine.
9 : : //
10 : : // Creator : John Fowler
11 : : //
12 : : // Creation Date : 6/02
13 : : //
14 : : // Owner : John Fowler
15 : : //-------------------------------------------------------------------------
16 : :
17 : : #include "FacetModifyEngine.hpp"
18 : : #include "FacetQueryEngine.hpp"
19 : : #include "SettingHandler.hpp"
20 : :
21 : : #include "CubitMessage.hpp"
22 : : #include "CubitDefines.h"
23 : :
24 : : #include "CubitUtil.hpp"
25 : : #include "CubitPoint.hpp"
26 : : #include "CubitPointData.hpp"
27 : : #include "CubitFacet.hpp"
28 : : #include "CubitQuadFacet.hpp"
29 : : #include "CubitFacetData.hpp"
30 : : #include "CubitFacetEdge.hpp"
31 : : #include "CubitFacetEdgeData.hpp"
32 : : #include "GeometryQueryTool.hpp"
33 : : #include "GeometryModifyTool.hpp"
34 : : #include "ChollaSurface.hpp"
35 : : #include "ChollaCurve.hpp"
36 : : #include "ChollaPoint.hpp"
37 : : #include "FacetPoint.hpp"
38 : : #include "FacetCurve.hpp"
39 : : #include "CurveFacetEvalTool.hpp"
40 : : #include "FacetEvalTool.hpp"
41 : : #include "FacetCoEdge.hpp"
42 : : #include "FacetLoop.hpp"
43 : : #include "FacetSurface.hpp"
44 : : #include "FacetShell.hpp"
45 : : #include "FacetLump.hpp"
46 : : #include "FacetBody.hpp"
47 : : #include "ChollaEngine.hpp"
48 : : #include "TDGeomFacet.hpp"
49 : : #include "CubitFileIOWrapper.hpp"
50 : : #include "TDFacetBoundaryPoint.hpp"
51 : : #include "Cholla.h"
52 : : #include "Body.hpp"
53 : : #include "GfxDebug.hpp"
54 : : #include "RefFace.hpp"
55 : : #include "FacetDataUtil.hpp"
56 : : #include "FBDataUtil.hpp"
57 : : #include "FBIntersect.hpp"
58 : : #include "IntegerHash.hpp"
59 : : #include "FacetboolInterface.hpp"
60 : : #include "CpuTimer.hpp"
61 : : #include "ProgressTool.hpp"
62 : : #include "AppUtil.hpp"
63 : : #include "SphereEvaluator.hpp"
64 : : #include "CylinderEvaluator.hpp"
65 : : #include "CubitLoops.hpp"
66 : : #include "FacetProjectTool.hpp"
67 : :
68 : : #include <algorithm>
69 : :
70 : : FacetModifyEngine* FacetModifyEngine::instance_ = 0;
71 : : CubitBoolean FacetModifyEngine::modifyEnabled = CUBIT_FALSE;
72 : :
73 : : //The do... while(0) trick is to get the trailing semicolon to
74 : : // do nothing in some very rare cases. From Steven Engelhardt's Weblog.
75 : :
76 : : #define MODIFY_CHECK_RETURN_NULL \
77 : : do {if(!modifyEnabled){ \
78 : : PRINT_INFO("Facet-based geometry modification is a beta capability.\n");\
79 : : PRINT_ERROR("This capability is currently disabled.\n");\
80 : : PRINT_INFO("To enable this capability, issue the command 'set developer commands on'. \n");\
81 : : return NULL;} }while(0)
82 : :
83 : : #define MODIFY_CHECK_RETURN_VOID \
84 : : do {if(!modifyEnabled){ \
85 : : PRINT_INFO("Facet-based geometry modification is a beta capability.\n");\
86 : : PRINT_ERROR("This capability is currently disabled.\n");\
87 : : PRINT_INFO("To enable this capability, issue the command 'set developer commands on'. \n");\
88 : : return;} }while(0)
89 : :
90 : : #define MODIFY_CHECK_RETURN_FAILURE \
91 : : do {if(!modifyEnabled){ \
92 : : PRINT_INFO("Facet-based geometry modification is a beta capability.\n");\
93 : : PRINT_ERROR("This capability is currently disabled.\n");\
94 : : PRINT_INFO("To enable this capability, issue the command 'set developer commands on'. \n");\
95 : : return CUBIT_FAILURE;} }while(0)
96 : : //===============================================================================
97 : : // Function : FacetModifyEngine
98 : : // Member Type: PUBLIC
99 : : // Description: constructor
100 : : // Author : John Fowler
101 : : // Date : 10/02
102 : : //===============================================================================
103 : 1748 : FacetModifyEngine::FacetModifyEngine()
104 : : {
105 : : // assert( !instance_ );
106 : :
107 : : // add this modify engine to geometrymodifytool
108 [ + - ][ + - ]: 874 : GeometryModifyTool::instance()->add_gme(this);
109 : 874 : }
110 : : //Initialize all settings in this class
111 : 0 : void FacetModifyEngine::initialize_settings()
112 : : {
113 : :
114 : : SettingHandler::instance()->add_setting(
115 : : "Facet_modify",FacetModifyEngine::set_modify_enabled,
116 : 0 : FacetModifyEngine::is_modify_enabled);
117 : :
118 : 0 : }
119 : :
120 : : //===============================================================================
121 : : // Function : ~FacetModifyEngine
122 : : // Member Type: PUBLIC
123 : : // Description: destructor
124 : : // Author : John Fowler
125 : : // Date : 10/02
126 : : //===============================================================================
127 : 813 : FacetModifyEngine::~FacetModifyEngine()
128 : : {
129 : 271 : instance_ = 0;
130 [ - + ]: 542 : }
131 : :
132 : : //===============================================================================
133 : : // Function : make_Point
134 : : // Member Type: PUBLIC
135 : : // Description: make a geometric entity point
136 : : // Author : John Fowler
137 : : // Date : 10/02
138 : : //===============================================================================
139 : 0 : TBPoint* FacetModifyEngine::make_Point( CubitVector const& point) const
140 : : {
141 : 0 : FacetModifyEngine *self = const_cast<FacetModifyEngine *> (this);
142 : 0 : TBPoint* new_point = NULL;
143 [ # # ]: 0 : self->make_facet_point(point, new_point);
144 : 0 : return new_point;
145 : : }
146 : :
147 : : //===============================================================================
148 : : // Function : make_Curve
149 : : // Member Type: PUBLIC
150 : : // Description: make a curve
151 : : // Author : John Fowler
152 : : // Date : 10/02
153 : : //===============================================================================
154 : 0 : Curve* FacetModifyEngine::make_Curve(Curve * /*curve_ptr*/,
155 : : std::map<TopologyBridge*, TopologyBridge*> *old_tb_to_new_tb ) const
156 : : {
157 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
158 : 0 : return (Curve*) NULL;
159 : : }
160 : :
161 : : //===============================================================================
162 : : // Function : make_Curve
163 : : // Member Type: PUBLIC
164 : : // Description: make a curve
165 : : // Author : John Fowler
166 : : // Date : 10/02
167 : : //===============================================================================
168 : 0 : Curve* FacetModifyEngine::make_Curve( TBPoint const* point1_ptr,
169 : : TBPoint const* point2_ptr,
170 : : Surface* ref_face_ptr,
171 : : const CubitVector * third_point) const
172 : : {
173 : :
174 [ # # ]: 0 : CubitPoint* p1 = static_cast<const FacetPoint*>(point1_ptr)->get_cubit_point();
175 [ # # ]: 0 : CubitPoint* p2 = static_cast<const FacetPoint*>(point2_ptr)->get_cubit_point();
176 : :
177 : : // gather data
178 [ # # ]: 0 : CubitVector v1 = p1->coordinates();
179 [ # # ]: 0 : CubitVector v2 = p2->coordinates();
180 [ # # ][ # # ]: 0 : CubitVector v3 = third_point ? *third_point : CubitVector();
[ # # ]
181 : :
182 [ # # ]: 0 : DLIList<CubitVector*> pts;
183 [ # # ]: 0 : pts.append(&v1);
184 [ # # ]: 0 : if(third_point)
185 [ # # ]: 0 : pts.append(&v3);
186 [ # # ]: 0 : pts.append(&v2);
187 : :
188 [ # # ]: 0 : FacetSurface* facet_surf = CAST_TO( ref_face_ptr, FacetSurface );
189 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> surf_pts;
190 [ # # ][ # # ]: 0 : DLIList<CubitFacet*> surf_facets;
191 [ # # ]: 0 : facet_surf->get_my_facets(surf_facets, surf_pts);
192 : :
193 : :
194 [ # # ][ # # ]: 0 : std::vector<double> facet_pts;
195 [ # # ][ # # ]: 0 : std::vector<int> facet_conn;
196 : :
197 [ # # ][ # # ]: 0 : for(DLIList<CubitPoint*>::iterator iter = surf_pts.begin(), end = surf_pts.end();
[ # # ][ # # ]
[ # # ]
198 : : iter != end; ++iter)
199 : : {
200 [ # # ][ # # ]: 0 : (*iter)->marked(-1);
201 : : }
202 [ # # ][ # # ]: 0 : for(DLIList<CubitFacet*>::iterator iter = surf_facets.begin(), end = surf_facets.end();
[ # # ][ # # ]
[ # # ]
203 : : iter != end; ++iter)
204 : : {
205 : : CubitPoint* p[3];
206 [ # # ][ # # ]: 0 : (*iter)->points(p[0], p[1], p[2]);
207 [ # # ]: 0 : for(int i=0; i<3; i++)
208 : : {
209 [ # # ][ # # ]: 0 : if(p[i]->marked() == -1)
210 : : {
211 [ # # ][ # # ]: 0 : p[i]->marked(facet_pts.size()/3);
212 [ # # ]: 0 : CubitVector v = p[i]->coordinates();
213 [ # # ][ # # ]: 0 : facet_pts.push_back(v.x());
214 [ # # ][ # # ]: 0 : facet_pts.push_back(v.y());
215 [ # # ][ # # ]: 0 : facet_pts.push_back(v.z());
216 : : }
217 [ # # ][ # # ]: 0 : facet_conn.push_back(p[i]->marked());
218 : : }
219 : : }
220 : :
221 : : // project straight line betwee points to surface
222 [ # # ][ # # ]: 0 : std::vector<int> dudded_facets, new_facets, new_facetindex;
[ # # ][ # # ]
[ # # ][ # # ]
223 [ # # ][ # # ]: 0 : std::vector<double> new_pts;
224 [ # # ][ # # ]: 0 : std::vector<int> edges, segmentPts;
[ # # ][ # # ]
225 : :
226 [ # # ][ # # ]: 0 : FacetProjectTool proj_tool;
227 : : CubitStatus stat = proj_tool.project(pts, facet_pts, facet_conn,
228 : : dudded_facets, new_facets, new_facetindex,
229 [ # # ]: 0 : new_pts, edges, segmentPts);
230 : :
231 [ # # ]: 0 : if(stat != CUBIT_SUCCESS)
232 : : {
233 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to project facet curve to surface.\n");
[ # # ][ # # ]
234 : 0 : return NULL;
235 : : }
236 : :
237 [ # # ][ # # ]: 0 : assert(edges[0] + 2 >= 0);
238 [ # # ][ # # ]: 0 : if((size_t)(edges[0] + 2) != edges.size())
[ # # ]
239 : : {
240 [ # # ][ # # ]: 0 : PRINT_ERROR("Facet curve projection produced multiple curves when one was expected.\n");
[ # # ][ # # ]
241 : 0 : return NULL;
242 : : }
243 : :
244 : : // lump new points with old points (we don't care about conforming to the surface mesh)
245 [ # # ][ # # ]: 0 : facet_pts.insert(facet_pts.end(), new_pts.begin(), new_pts.end());
[ # # ][ # # ]
246 : :
247 : :
248 : : // build the new curve
249 [ # # ][ # # ]: 0 : edges.erase(edges.begin());
250 [ # # ][ # # ]: 0 : edges.erase(edges.end()-1);
[ # # ]
251 : :
252 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> curve_pts;
253 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> curve_edges;
254 : 0 : CubitPoint* prev_point = p1;
255 [ # # ][ # # ]: 0 : for(size_t i=1; i<edges.size()-1; i++)
256 : : {
257 [ # # ][ # # ]: 0 : CubitPoint* next_point = new CubitPointData(CubitVector(&facet_pts[3*edges[i]]));
[ # # ][ # # ]
[ # # ]
258 [ # # ]: 0 : curve_pts.append(next_point);
259 [ # # ][ # # ]: 0 : CubitFacetEdgeData* cfe = new CubitFacetEdgeData(prev_point, next_point);
260 [ # # ]: 0 : curve_edges.append(cfe);
261 : 0 : prev_point = next_point;
262 : : }
263 : :
264 [ # # ][ # # ]: 0 : CubitFacetEdgeData* cfe = new CubitFacetEdgeData(prev_point, p2);
265 [ # # ]: 0 : curve_edges.append(cfe);
266 [ # # ]: 0 : curve_pts.append(p2);
267 : :
268 : 0 : Curve* new_curve = NULL;
269 : 0 : FacetModifyEngine* self = const_cast<FacetModifyEngine*>(this);
270 : : self->make_facet_curve(const_cast<TBPoint*>(point1_ptr),
271 : : const_cast<TBPoint*>(point2_ptr),
272 [ # # ]: 0 : curve_edges, curve_pts, new_curve, NULL);
273 : :
274 [ # # ]: 0 : return new_curve;
275 : : }
276 : :
277 : : //===============================================================================
278 : : // Function : make_Curve
279 : : // Member Type: PUBLIC
280 : : // Description: make a curve using point_tangents to describe curvature
281 : : // Author : John Fowler
282 : : // Date : 10/02
283 : : //===============================================================================
284 : 0 : Curve* FacetModifyEngine::make_Curve( DLIList<CubitVector*>& point_list,
285 : : DLIList<CubitVector*>& point_tangents) const
286 : : {
287 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
288 : 0 : return (Curve*)NULL;
289 : : }
290 : :
291 : : //===============================================================================
292 : : // Function : make_Curve
293 : : // Member Type: PUBLIC
294 : : // Description: make a curve
295 : : // Author : John Fowler
296 : : // Date : 10/02
297 : : //===============================================================================
298 : 0 : Curve* FacetModifyEngine::make_Curve(GeometryType /*curve_type*/,
299 : : TBPoint const* point1_ptr,
300 : : TBPoint const* point2_ptr,
301 : : DLIList<CubitVector *> &vector_list,
302 : : Surface* /*ref_face_ptr*/) const
303 : : {
304 : 0 : Curve* new_curve = NULL;
305 : :
306 [ # # ]: 0 : DLIList<CubitPoint*> points;
307 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> edges;
308 : :
309 [ # # ]: 0 : CubitPoint* prev_point = static_cast<const FacetPoint*>(point1_ptr)->get_cubit_point();
310 [ # # ]: 0 : points.append(prev_point);
311 : :
312 [ # # ][ # # ]: 0 : for(int i=0; i<vector_list.size(); i++)
313 : : {
314 [ # # ][ # # ]: 0 : CubitPoint* next_point = new CubitPointData(*vector_list[i]);
[ # # ]
315 [ # # ][ # # ]: 0 : CubitFacetEdgeData* cfe = new CubitFacetEdgeData(prev_point, next_point);
316 [ # # ]: 0 : edges.append(cfe);
317 : 0 : prev_point = next_point;
318 [ # # ]: 0 : points.append(prev_point);
319 : : }
320 : :
321 [ # # ]: 0 : CubitPoint* end_point = static_cast<const FacetPoint*>(point2_ptr)->get_cubit_point();
322 : :
323 [ # # ][ # # ]: 0 : CubitFacetEdgeData* cfe = new CubitFacetEdgeData(prev_point, end_point);
324 [ # # ]: 0 : edges.append(cfe);
325 [ # # ]: 0 : points.append(end_point);
326 : :
327 : 0 : FacetModifyEngine* self = const_cast<FacetModifyEngine*>(this);
328 : : self->make_facet_curve(const_cast<TBPoint*>(point1_ptr),
329 : : const_cast<TBPoint*>(point2_ptr),
330 [ # # ]: 0 : edges, points, new_curve, NULL);
331 : :
332 [ # # ]: 0 : return new_curve;
333 : : }
334 : :
335 : : //===============================================================================
336 : : // Function : make_Curve
337 : : // Member Type: PUBLIC
338 : : // Description: make a curve
339 : : // Author : John Fowler
340 : : // Date : 10/02
341 : : //===============================================================================
342 : 0 : Curve* FacetModifyEngine::make_Curve( GeometryType /*curve_type*/,
343 : : TBPoint const* /*point1_ptr*/,
344 : : TBPoint const* /*point2_ptr*/,
345 : : CubitVector const* /*intermediate_point_ptr*/ ) const
346 : : {
347 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
348 : 0 : return (Curve*) NULL;
349 : : }
350 : :
351 : : //===============================================================================
352 : : // Function : make_Surface
353 : : // Member Type: PUBLIC
354 : : // Description: make a surface
355 : : // Author : John Fowler
356 : : // Date : 10/02
357 : : //===============================================================================
358 : 0 : Surface* FacetModifyEngine::make_Surface( Surface * /*old_surface_ptr*/,
359 : : std::map< TopologyBridge*, TopologyBridge* > * /*old_tb_to_new_tb*/) const
360 : : {
361 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
362 : 0 : return (Surface*) NULL;
363 : : }
364 : :
365 : : //===============================================================================
366 : : // Function : make_extended_sheet
367 : : // Member Type: PUBLIC
368 : : // Description: make an extended sheet from a set of surfaces
369 : : // Author :
370 : : // Date :
371 : : //===============================================================================
372 : 0 : BodySM* FacetModifyEngine::make_extended_sheet( DLIList<Surface*> & /*surface_list*/,
373 : : CubitBox * /*clip_box_ptr*/,
374 : : bool /*preview*/ ) const
375 : : {
376 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
377 : 0 : return (BodySM*) NULL;
378 : : }
379 : :
380 : : //===============================================================================
381 : : // Function : make_Surface
382 : : // Member Type: PUBLIC
383 : : // Description: make a surface
384 : : // Author : John Fowler
385 : : // Date : 10/02
386 : : //===============================================================================
387 : 0 : Surface* FacetModifyEngine::make_Surface( GeometryType /*surface_type*/,
388 : : DLIList<Curve*>& /*curve_list*/,
389 : : Surface * /*old_surface_ptr*/,
390 : : bool /*check_edges*/) const
391 : : {
392 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
393 : 0 : return (Surface*) NULL;
394 : : }
395 : :
396 : : //===============================================================================
397 : : // Function : make_Lump
398 : : // Member Type: PUBLIC
399 : : // Description: make a lump
400 : : // Author : John Fowler
401 : : // Date : 10/02
402 : : //===============================================================================
403 : 0 : Lump* FacetModifyEngine::make_Lump( DLIList<Surface*>& /*surface_list*/ ) const
404 : : {
405 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
406 : 0 : return (Lump*) NULL;
407 : : }
408 : :
409 : : //===============================================================================
410 : : // Function : make_BodySM
411 : : // Member Type: PUBLIC
412 : : // Description: make a BodySM
413 : : // Author : John Fowler
414 : : // Date : 10/02
415 : : //===============================================================================
416 : 0 : BodySM* FacetModifyEngine::make_BodySM( Surface * ) const
417 : 0 : {return NULL ;}
418 : :
419 : : //===============================================================================
420 : : // Function : make_BodySM
421 : : // Member Type: PUBLIC
422 : : // Description: make a BodySM
423 : : // Author : John Fowler
424 : : // Date : 10/02
425 : : //===============================================================================
426 : 0 : BodySM* FacetModifyEngine::make_BodySM( DLIList<Lump*>& /*lump_list*/ ) const
427 : 0 : {return NULL ;}
428 : :
429 : : //===============================================================================
430 : : // Function : fillinedge
431 : : // Member Type: PRIVATE
432 : : // Description: put points on this edge of triangle to be refined
433 : : // Author : John Fowler
434 : : // Date : 11/02
435 : : //===============================================================================
436 : 0 : void FacetModifyEngine::fillinedge(
437 : : int *edge,
438 : : int numpointsonanedge,
439 : : double radius,
440 : : std::vector<CubitPoint *>& points) const
441 : : {
442 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_VOID;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
443 : :
444 : : int numintervals, i;
445 : : double xbegin, ybegin, zbegin, xend, yend, zend, xincr, yincr, zincr;
446 : : double dist;
447 : : CubitPoint *new_point;
448 : :
449 : 0 : numintervals = numpointsonanedge - 1;
450 [ # # ]: 0 : if ( numintervals < 1 ) return;
451 [ # # ][ # # ]: 0 : xbegin = points[edge[0]]->x();
452 [ # # ][ # # ]: 0 : ybegin = points[edge[0]]->y();
453 [ # # ][ # # ]: 0 : zbegin = points[edge[0]]->z();
454 [ # # ][ # # ]: 0 : xend = points[edge[numintervals]]->x();
455 [ # # ][ # # ]: 0 : yend = points[edge[numintervals]]->y();
456 [ # # ][ # # ]: 0 : zend = points[edge[numintervals]]->z();
457 : 0 : xincr = (xend-xbegin)/(double)(numintervals);
458 : 0 : yincr = (yend-ybegin)/(double)(numintervals);
459 : 0 : zincr = (zend-zbegin)/(double)(numintervals);
460 [ # # ]: 0 : for ( i = 0; i < numintervals - 1; i++ ) {
461 : 0 : xbegin += xincr;
462 : 0 : ybegin += yincr;
463 : 0 : zbegin += zincr;
464 : :
465 : 0 : dist = sqrt(xbegin*xbegin + ybegin*ybegin + zbegin*zbegin);
466 : 0 : new_point = (CubitPoint *) new CubitPointData( xbegin*radius/dist, ybegin*radius/dist,
467 [ # # ][ # # ]: 0 : zbegin*radius/dist );
468 [ # # ]: 0 : edge[i+1] = points.size(); // get the point number
469 [ # # ]: 0 : points.push_back(new_point);
470 : : }
471 : :
472 : : }
473 : :
474 : : //===============================================================================
475 : : // Function : refinetriangle
476 : : // Member Type: PRIVATE
477 : : // Description: add internal points and make connections for this triangle
478 : : // Author : John Fowler
479 : : // Date : 11/02
480 : : //===============================================================================
481 : 0 : void FacetModifyEngine::refinetriangle(
482 : : int level,
483 : : int numpointsonanedge,
484 : : int *iedge1,
485 : : int *iedge2,
486 : : int *iedge3,
487 : : int isign1,
488 : : int isign2,
489 : : int isign3,
490 : : double radius,
491 : : std::vector<CubitPoint *>& points,
492 : : DLIList<CubitFacet *>& facet_list) const
493 : : {
494 : :
495 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_VOID;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
496 : :
497 : : int i, numintervals, icount, j, jcount;
498 : : int ntris;
499 : : int iedge1cnt, iedge2cnt, iedge3cnt;
500 : :
501 : : int increment, trissofar, i1s, i2s, i1e;
502 : : int nverts1, nverts;
503 : : double dlev;
504 : : int *vertnumarray, index, iskip;
505 : : CubitFacet *facet_ptr;
506 : : CubitPoint *new_point;
507 : : double x1inc, y1inc, z1inc, x2inc, y2inc, z2inc;
508 : : double xstart, ystart, zstart, xend, yend, zend, dist;
509 : : double xinternalinc, yinternalinc, zinternalinc;
510 : :
511 : 0 : numintervals = numpointsonanedge - 1;
512 [ # # ]: 0 : iedge1cnt = ( isign1 == 1 ) ? 0 : numintervals;
513 [ # # ]: 0 : iedge2cnt = ( isign2 == 1 ) ? 0 : numintervals;
514 [ # # ]: 0 : iedge3cnt = ( isign3 == 1 ) ? 0 : numintervals;
515 : :
516 [ # # ]: 0 : index = points.size();
517 : 0 : dlev = 1. + (double)level;
518 : 0 : nverts1 = (int)(0.5*(dlev+1.)*dlev);
519 : :
520 : 0 : ntris = (level+1)*(level+1);
521 : 0 : dlev += 1.;
522 : 0 : nverts = (int)(0.5*(dlev+1.)*dlev);
523 [ # # ][ # # ]: 0 : vertnumarray = new int[nverts];
524 : :
525 : : // Put the point numbers for the interior points into vertnumarray.
526 [ # # ]: 0 : if ( numintervals > 2 ) { // numintervals must be at least 3 to make interior points
527 : 0 : jcount = 1;
528 : 0 : icount = 2;
529 [ # # ]: 0 : for ( i = 2; i < numintervals; i++ ) {
530 : 0 : icount += 2;
531 [ # # ]: 0 : for ( j = 0; j < jcount; j++ ) {
532 : 0 : vertnumarray[icount] = index++;
533 : 0 : icount += 1;
534 : : }
535 : 0 : jcount += 1;
536 : : }
537 : : }
538 : 0 : i = 3;
539 : :
540 : 0 : iskip = 2;
541 : 0 : vertnumarray[0] = iedge1[iedge1cnt]; iedge1cnt += isign1;
542 : 0 : vertnumarray[1] = iedge1[iedge1cnt]; iedge1cnt += isign1;
543 : 0 : iedge2cnt += isign2;
544 : 0 : vertnumarray[2] = iedge2[iedge2cnt]; iedge2cnt += isign2;
545 : :
546 [ # # ]: 0 : while ( i < nverts1 ) {
547 : 0 : vertnumarray[i] = iedge1[iedge1cnt]; iedge1cnt += isign1;
548 : 0 : vertnumarray[i+iskip] = iedge2[iedge2cnt]; iedge2cnt += isign2;
549 : 0 : i += iskip+1;
550 : 0 : iskip += 1;
551 : : }
552 [ # # ]: 0 : for ( i = nverts1; i < nverts; i++ ) {
553 : 0 : vertnumarray[i] = iedge3[iedge3cnt]; iedge3cnt += isign3;
554 : : }
555 : :
556 : :
557 : : //! Make the internal points, and put them on the sphere.
558 : :
559 [ # # ]: 0 : if ( numintervals > 2 ) {
560 : : int i1first, i1last, i2first, i2last;
561 [ # # ]: 0 : if ( isign1 == 1 ) {
562 : 0 : i1first = 0; i1last = numintervals;
563 : : } else {
564 : 0 : i1last = 0; i1first = numintervals;
565 : : }
566 [ # # ]: 0 : if ( isign2 == 1 ) {
567 : 0 : i2first = 0; i2last = numintervals;
568 : : } else {
569 : 0 : i2last = 0; i2first = numintervals;
570 : : }
571 [ # # ][ # # ]: 0 : x1inc = (points[iedge1[i1last]]->x() - points[iedge1[i1first]]->x())/numintervals;
[ # # ][ # # ]
572 [ # # ][ # # ]: 0 : y1inc = (points[iedge1[i1last]]->y() - points[iedge1[i1first]]->y())/numintervals;
[ # # ][ # # ]
573 [ # # ][ # # ]: 0 : z1inc = (points[iedge1[i1last]]->z() - points[iedge1[i1first]]->z())/numintervals;
[ # # ][ # # ]
574 [ # # ][ # # ]: 0 : x2inc = (points[iedge2[i2last]]->x() - points[iedge2[i2first]]->x())/numintervals;
[ # # ][ # # ]
575 [ # # ][ # # ]: 0 : y2inc = (points[iedge2[i2last]]->y() - points[iedge2[i2first]]->y())/numintervals;
[ # # ][ # # ]
576 [ # # ][ # # ]: 0 : z2inc = (points[iedge2[i2last]]->z() - points[iedge2[i2first]]->z())/numintervals;
[ # # ][ # # ]
577 : :
578 : 0 : icount = 2;
579 : 0 : jcount = 1;
580 [ # # ]: 0 : for ( i = 2; i < numintervals; i++ ) {
581 [ # # ][ # # ]: 0 : xstart = points[iedge1[i1first]]->x() + (double)i*x1inc;
582 [ # # ][ # # ]: 0 : ystart = points[iedge1[i1first]]->y() + (double)i*y1inc;
583 [ # # ][ # # ]: 0 : zstart = points[iedge1[i1first]]->z() + (double)i*z1inc;
584 [ # # ][ # # ]: 0 : xend = points[iedge2[i2first]]->x() + (double)i*x2inc;
585 [ # # ][ # # ]: 0 : yend = points[iedge2[i2first]]->y() + (double)i*y2inc;
586 [ # # ][ # # ]: 0 : zend = points[iedge2[i2first]]->z() + (double)i*z2inc;
587 : 0 : xinternalinc = (xend-xstart)/(icount);
588 : 0 : yinternalinc = (yend-ystart)/(icount);
589 : 0 : zinternalinc = (zend-zstart)/(icount);
590 [ # # ]: 0 : for ( j = 0; j < jcount; j++ ) {
591 : 0 : xstart += xinternalinc;
592 : 0 : ystart += yinternalinc;
593 : 0 : zstart += zinternalinc;
594 : :
595 : 0 : dist = sqrt(xstart*xstart + ystart*ystart + zstart*zstart);
596 : 0 : new_point = (CubitPoint *) new CubitPointData( xstart*radius/dist,
597 : 0 : ystart*radius/dist,
598 [ # # ][ # # ]: 0 : zstart*radius/dist );
599 [ # # ]: 0 : points.push_back(new_point);
600 : : }
601 : 0 : icount += 1;
602 : 0 : jcount += 1;
603 : : }
604 : :
605 : : }
606 : :
607 : : //! Make the connections.
608 : 0 : increment = trissofar = 0;
609 : 0 : i1s = 0;
610 : 0 : i2s = 1;
611 [ # # ]: 0 : while ( trissofar < ntris ) {
612 : 0 : i1e = i1s + increment;
613 [ # # ]: 0 : while ( i1s < i1e) {
614 [ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnumarray[i1s]],
615 [ # # ]: 0 : points[vertnumarray[i2s]],
616 [ # # ][ # # ]: 0 : points[vertnumarray[i2s+1]] );
[ # # ]
617 [ # # ]: 0 : facet_list.append( facet_ptr );
618 [ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnumarray[i1s]],
619 [ # # ]: 0 : points[vertnumarray[i2s+1]],
620 [ # # ][ # # ]: 0 : points[vertnumarray[i1s+1]] );
[ # # ]
621 [ # # ]: 0 : facet_list.append( facet_ptr );
622 : 0 : i1s++;
623 : 0 : i2s++;
624 : 0 : trissofar += 2;
625 : : }
626 [ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnumarray[i1s]],
627 [ # # ]: 0 : points[vertnumarray[i2s]],
628 [ # # ][ # # ]: 0 : points[vertnumarray[i2s+1]] );
[ # # ]
629 [ # # ]: 0 : facet_list.append( facet_ptr );
630 : 0 : increment++;
631 : 0 : trissofar++;
632 : 0 : i1s++;
633 : 0 : i2s += 2;
634 : : }
635 [ # # ]: 0 : delete [] vertnumarray;
636 : : }
637 : :
638 : : //===============================================================================
639 : : // Function : sphere
640 : : // Member Type: PUBLIC
641 : : // Description: build a sphere with facets
642 : : // Author : John Fowler
643 : : // Date : 10/02
644 : : //===============================================================================
645 : 0 : BodySM* FacetModifyEngine::sphere(double radius) const
646 : : {
647 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
648 : :
649 : 0 : CubitStatus rv = CUBIT_SUCCESS;
650 [ # # ]: 0 : DLIList <CubitFacet *>facet_list;
651 [ # # ][ # # ]: 0 : DLIList <CubitPoint *>point_list;
652 : : CubitPoint *new_point;
653 : : double feature_angle;
654 : : int i, interp_order;
655 : : CubitBoolean smooth_non_manifold, split_surfaces;
656 : 0 : BodySM *body_ptr = NULL;
657 [ # # ][ # # ]: 0 : std::vector<CubitPoint *> points;
658 : : //! We use a vector for the points because when refining the triangles, we will
659 : : //! need fast random access to them. After all of the points have been made,
660 : : //! they will go onto the DLIList point_list. Then the points vector will be
661 : : //! deleted.
662 : : //! xp and yp are the fundamental units for an icosahedron.
663 : 0 : const double xp = 0.525731112119133606*radius, zp = 0.850650808352039932*radius;
664 : : //! Makes an icosahedron and then refines the triangles as they are made. Number
665 : : //! of levels is given by the variable "level".
666 : : int level, numpointsonanedge;
667 : : int *edge[30];
668 : : //! 20 faces in an icosahedron. const int basefacets[][] holds the connections.
669 : : //! 30 edges in an icosahedron. const int edgeendverts[][] holds the edge endpoints.
670 : : /*
671 : : const int basefacets[20][3] = { {0,1,2},{0,2,3},{3,2,4},{2,5,4},
672 : : {2,1,5},{5,1,6},{5,6,7},{4,5,7},
673 : : {4,7,8},{8,7,9},{9,7,6},{9,6,10},
674 : : {9,10,11},{11,10,0},{0,10,1},{10,6,1},
675 : : {3,11,0},{3,8,11},{3,4,8},{9,11,8} };
676 : : */
677 : : const int edgeendverts[30][2] = { {0,1},{0,2},{0,3},{0,11},{0,10},{1,2},
678 : : {1,5},{1,6},{1,10},{2,3},{2,4},{2,5},
679 : : {3,4},{3,8},{3,11},{4,5},{4,7},{4,8},
680 : : {5,6},{5,7},{6,7},{6,9},{6,10},{7,8},
681 : 0 : {7,9},{8,9},{8,11},{9,10},{9,11},{10,11} };
682 : : //! triedges[][] holds the three edges for each of the 20 triangles. A minus sign means
683 : : //! that the edge will be traversed backward. To accommodate a zero, one has been added
684 : : //! to the magnitude of the edge. So, for example, the first triangle has edges 0, 5, and 1,
685 : : //! with the last being traversed from end to beginning.
686 : : const int triedges[20][3] = { {1,2,6},{2,3,10},{-10,13,11},{12,11,-16,},
687 : : {-6,12,7,},{-7,19,8,},{19,20,21},{16,17,20},
688 : : {17,18,24,},{-24,26,25},{-25,-22,-21},{-22,28,23},
689 : : {28,29,30},{-30,-4,-5},{5,1,-9},{-23,-9,-8},
690 : 0 : {15,-3,-4},{14,15,27},{13,14,18},{29,-26,-27} };
691 : : //! 12 points in an icosahedron. svert[][] holds these.
692 : : const double svert[12][3] = { {-xp,0.,zp}, {xp,0.,zp}, {0.,zp,xp}, {-zp, xp, 0.},
693 : : {0.,zp,-xp}, {zp,xp,0.}, {zp,-xp,0.}, {xp,0.,-zp},
694 : 0 : {-xp,0.,-zp}, {0.,-zp,-xp}, {0.,-zp,xp}, {-zp,-xp,0.} };
695 : :
696 : 0 : level = 7; // gives a sphere with 642 vertices and 1280 triangles.
697 : : // Eventually this should be user-selectable.
698 : 0 : numpointsonanedge = 2 + level;
699 : :
700 [ # # ]: 0 : for ( i = 0; i < 30; i++ ) { // make the edges
701 [ # # ][ # # ]: 0 : edge[i] = new int[numpointsonanedge];
702 : 0 : edge[i][0] = edgeendverts[i][0];
703 : 0 : edge[i][numpointsonanedge-1] = edgeendverts[i][1];
704 : : }
705 : :
706 [ # # ]: 0 : for ( i = 0; i < 12; i++ ) { // make the icosahedron vertices
707 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( svert[i][0],svert[i][1],svert[i][2] );
708 [ # # ]: 0 : points.push_back(new_point);
709 : : }
710 : :
711 [ # # ]: 0 : for ( i = 0; i < 30; i++ ) { // put points on the edges
712 [ # # ]: 0 : fillinedge(edge[i], numpointsonanedge, radius, points);
713 : : }
714 : :
715 : : int sign1, sign2, sign3, edg1, edg2, edg3;
716 [ # # ]: 0 : for ( i = 0; i < 20; i++ ) { // refine the 20 triangles
717 [ # # ]: 0 : edg1 = ( triedges[i][0] > 0 ) ? triedges[i][0] - 1 : -triedges[i][0] - 1;
718 [ # # ]: 0 : edg2 = ( triedges[i][1] > 0 ) ? triedges[i][1] - 1 : -triedges[i][1] - 1;
719 [ # # ]: 0 : edg3 = ( triedges[i][2] > 0 ) ? triedges[i][2] - 1 : -triedges[i][2] - 1;
720 : : //! sign1, etc., says in which direction to traverse an edge
721 [ # # ]: 0 : sign1 = ( triedges[i][0] > 0 ) ? 1 : -1;
722 [ # # ]: 0 : sign2 = ( triedges[i][1] > 0 ) ? 1 : -1;
723 [ # # ]: 0 : sign3 = ( triedges[i][2] > 0 ) ? 1 : -1;
724 : :
725 : : refinetriangle(level,numpointsonanedge,edge[edg1],edge[edg2],edge[edg3],
726 [ # # ]: 0 : sign1,sign2,sign3,radius,points,facet_list);
727 : : }
728 : :
729 : : //! Put the points in point_list and then delete the points vector.
730 [ # # ][ # # ]: 0 : for ( unsigned int z = 0; z < points.size(); z++ ) {
731 [ # # ][ # # ]: 0 : point_list.append(points[z]);
732 : : }
733 : :
734 [ # # ]: 0 : points.clear();
735 : :
736 [ # # ][ # # ]: 0 : for ( i = 0; i < 30; i++ ) delete[] edge[i];
737 : 0 : feature_angle = -1.0;
738 : 0 : interp_order = 0;
739 : 0 : smooth_non_manifold = CUBIT_TRUE;
740 : 0 : split_surfaces = CUBIT_FALSE;
741 : :
742 : 0 : ChollaEngine *cholla_ptr = NULL;
743 : 0 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
744 : : rv = fme->build_cholla_surfaces( facet_list,
745 : : point_list,
746 : : feature_angle,
747 : : interp_order,
748 : : smooth_non_manifold,
749 : : split_surfaces,
750 [ # # ][ # # ]: 0 : cholla_ptr );
[ # # ][ # # ]
[ # # ]
751 [ # # ]: 0 : if ( rv == CUBIT_SUCCESS )
752 : : {
753 : : CubitEvaluatorData **sphere_data;
754 : :
755 [ # # ]: 0 : set_sphere_eval_data( cholla_ptr, radius, sphere_data );
756 : :
757 : : finish_facet_Body( cholla_ptr,
758 : : (const CubitEvaluatorData **)sphere_data,
759 : : feature_angle,
760 : : interp_order,
761 [ # # ]: 0 : body_ptr);
762 : :
763 [ # # ]: 0 : if ( cholla_ptr )
764 : : {
765 [ # # ]: 0 : cholla_ptr->delete_me();
766 [ # # ][ # # ]: 0 : delete cholla_ptr;
767 : : }
768 [ # # ][ # # ]: 0 : if ( sphere_data[0] ) delete sphere_data[0];
[ # # ]
769 : 0 : delete sphere_data;
770 : : }
771 [ # # ]: 0 : return body_ptr;
772 : : }
773 : :
774 : 0 : CubitStatus FacetModifyEngine::remove_topology(DLIList<Curve*> &curves_to_remove,
775 : : DLIList<Surface*> &surfs_to_remove,
776 : : double backoff_distance,
777 : : double small_edge_size,
778 : : DLIList<BodySM*> &new_bodysm_list,
779 : : CubitBoolean preview) const
780 : : {
781 [ # # ][ # # ]: 0 : PRINT_INFO("This functionality is not implemented for faceted geometry.\n");
782 : 0 : return CUBIT_FAILURE;
783 : : }
784 : :
785 : 0 : void FacetModifyEngine::set_sphere_eval_data
786 : : (
787 : : ChollaEngine *cholla_ptr,
788 : : double radius,
789 : : CubitEvaluatorData **&eval_data ) const
790 : : {
791 : :
792 : : //MODIFY_CHECK_RETURN_VOID;
793 : :
794 : 0 : eval_data = new CubitEvaluatorData*;
795 : :
796 [ # # ]: 0 : SphereEvaluatorData *data = new SphereEvaluatorData;
797 : 0 : data->radius = radius;
798 : 0 : data->center.set( 0.0, 0.0, 0.0 );
799 : 0 : eval_data[0] = data;
800 : 0 : }
801 : :
802 : : //===============================================================================
803 : : // Function : brick
804 : : // Member Type: PUBLIC
805 : : // Description: build a brick with facets
806 : : // Author : John Fowler
807 : : // Date : 10/02
808 : : //===============================================================================
809 : 33 : BodySM* FacetModifyEngine::brick( double wid, double dep, double hi ) const
810 : : {
811 : :
812 : :
813 [ - + ][ # # ]: 33 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
814 : 33 : CubitStatus rv = CUBIT_SUCCESS;
815 : : double xmin, xmax, ymin, ymax, zmin, zmax;
816 [ + - ]: 33 : DLIList <CubitFacet *>facet_list;
817 [ + - ][ + - ]: 66 : DLIList <CubitPoint *>point_list;
818 : : CubitPoint *new_point;
819 : : CubitFacet *facet_ptr;
820 : : int i, numpoints;
821 : : double feature_angle;
822 : : int interp_order;
823 : : CubitBoolean smooth_non_manifold, split_surfaces;
824 : 33 : BodySM *body_ptr = NULL;
825 [ + - ][ + - ]: 66 : std::vector<CubitPoint *> points;
826 : :
827 : 33 : numpoints = 14;
828 : :
829 : 33 : xmin = -0.5*wid;
830 : 33 : xmax = 0.5*wid;
831 : 33 : ymin = -0.5*dep;
832 : 33 : ymax = 0.5*dep;
833 : 33 : zmin = -0.5*hi;
834 : 33 : zmax = 0.5*hi;
835 : :
836 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmin,ymin,zmin );
837 [ + - ]: 33 : points.push_back(new_point);
838 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmax,ymin,zmin );
839 [ + - ]: 33 : points.push_back(new_point);
840 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmax,ymin,zmax );
841 [ + - ]: 33 : points.push_back(new_point);
842 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmin,ymin,zmax );
843 [ + - ]: 33 : points.push_back(new_point);
844 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmin,ymax,zmin );
845 [ + - ]: 33 : points.push_back(new_point);
846 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmax,ymax,zmin );
847 [ + - ]: 33 : points.push_back(new_point);
848 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmax,ymax,zmax );
849 [ + - ]: 33 : points.push_back(new_point);
850 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmin,ymax,zmax );
851 [ + - ]: 33 : points.push_back(new_point);
852 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( 0.5*(xmin+xmax),0.5*(ymin+ymax),zmin );
853 [ + - ]: 33 : points.push_back(new_point);
854 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmax,0.5*(ymin+ymax),0.5*(zmin+zmax) );
855 [ + - ]: 33 : points.push_back(new_point);
856 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( 0.5*(xmin+xmax),0.5*(ymin+ymax),zmax );
857 [ + - ]: 33 : points.push_back(new_point);
858 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( xmin,0.5*(ymin+ymax),0.5*(zmin+zmax) );
859 [ + - ]: 33 : points.push_back(new_point);
860 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( 0.5*(xmin+xmax),ymin,0.5*(zmin+zmax) );
861 [ + - ]: 33 : points.push_back(new_point);
862 [ + - ][ + - ]: 33 : new_point = (CubitPoint *) new CubitPointData( 0.5*(xmin+xmax),ymax,0.5*(zmin+zmax) );
863 [ + - ]: 33 : points.push_back(new_point);
864 : :
865 [ + + ]: 495 : for ( i = 0; i < numpoints; i++ ) {
866 [ + - ][ + - ]: 462 : point_list.append(points[i]);
867 : : }
868 : :
869 : : // bottom face
870 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[0],points[1], points[12] );
[ + - ][ + - ]
[ + - ]
871 [ + - ]: 33 : facet_list.append( facet_ptr );
872 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[1],points[2], points[12] );
[ + - ][ + - ]
[ + - ]
873 [ + - ]: 33 : facet_list.append( facet_ptr );
874 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[2],points[3], points[12] );
[ + - ][ + - ]
[ + - ]
875 [ + - ]: 33 : facet_list.append( facet_ptr );
876 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[3],points[0], points[12] );
[ + - ][ + - ]
[ + - ]
877 : : // back face
878 [ + - ]: 33 : facet_list.append( facet_ptr );
879 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[1],points[0], points[8] );
[ + - ][ + - ]
[ + - ]
880 [ + - ]: 33 : facet_list.append( facet_ptr );
881 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[5],points[1], points[8] );
[ + - ][ + - ]
[ + - ]
882 [ + - ]: 33 : facet_list.append( facet_ptr );
883 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[4],points[5], points[8] );
[ + - ][ + - ]
[ + - ]
884 [ + - ]: 33 : facet_list.append( facet_ptr );
885 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[0],points[4], points[8] );
[ + - ][ + - ]
[ + - ]
886 [ + - ]: 33 : facet_list.append( facet_ptr );
887 : : // left face
888 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[0],points[3], points[11] );
[ + - ][ + - ]
[ + - ]
889 [ + - ]: 33 : facet_list.append( facet_ptr );
890 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[3],points[7], points[11] );
[ + - ][ + - ]
[ + - ]
891 [ + - ]: 33 : facet_list.append( facet_ptr );
892 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[7],points[4], points[11] );
[ + - ][ + - ]
[ + - ]
893 [ + - ]: 33 : facet_list.append( facet_ptr );
894 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[4],points[0], points[11] );
[ + - ][ + - ]
[ + - ]
895 [ + - ]: 33 : facet_list.append( facet_ptr );
896 : : // top face
897 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[7],points[6], points[13] );
[ + - ][ + - ]
[ + - ]
898 [ + - ]: 33 : facet_list.append( facet_ptr );
899 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[6],points[5], points[13] );
[ + - ][ + - ]
[ + - ]
900 [ + - ]: 33 : facet_list.append( facet_ptr );
901 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[5],points[4], points[13] );
[ + - ][ + - ]
[ + - ]
902 [ + - ]: 33 : facet_list.append( facet_ptr );
903 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[4],points[7], points[13] );
[ + - ][ + - ]
[ + - ]
904 [ + - ]: 33 : facet_list.append( facet_ptr );
905 : : // right face
906 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[1],points[5], points[9] );
[ + - ][ + - ]
[ + - ]
907 [ + - ]: 33 : facet_list.append( facet_ptr );
908 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[5],points[6], points[9] );
[ + - ][ + - ]
[ + - ]
909 [ + - ]: 33 : facet_list.append( facet_ptr );
910 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[6],points[2], points[9] );
[ + - ][ + - ]
[ + - ]
911 [ + - ]: 33 : facet_list.append( facet_ptr );
912 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[2],points[1], points[9] );
[ + - ][ + - ]
[ + - ]
913 [ + - ]: 33 : facet_list.append( facet_ptr );
914 : : // front face
915 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[3],points[2], points[10] );
[ + - ][ + - ]
[ + - ]
916 [ + - ]: 33 : facet_list.append( facet_ptr );
917 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[2],points[6], points[10] );
[ + - ][ + - ]
[ + - ]
918 [ + - ]: 33 : facet_list.append( facet_ptr );
919 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[6],points[7], points[10] );
[ + - ][ + - ]
[ + - ]
920 [ + - ]: 33 : facet_list.append( facet_ptr );
921 [ + - ][ + - ]: 33 : facet_ptr = new CubitFacetData( points[7],points[3], points[10] );
[ + - ][ + - ]
[ + - ]
922 [ + - ]: 33 : facet_list.append( facet_ptr );
923 : :
924 [ + - ]: 33 : points.clear(); // clear out the points vector since we are through with it.
925 : :
926 : 33 : feature_angle = 100.0;
927 : 33 : interp_order = 0;
928 : 33 : smooth_non_manifold = CUBIT_TRUE;
929 : 33 : split_surfaces = CUBIT_FALSE;
930 : :
931 : 33 : ChollaEngine *cholla_ptr = NULL;
932 : 33 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
933 : : rv = fme->build_cholla_surfaces( facet_list,
934 : : point_list,
935 : : feature_angle,
936 : : interp_order,
937 : : smooth_non_manifold,
938 : : split_surfaces,
939 [ + - ][ + - ]: 33 : cholla_ptr );
[ + - ][ + - ]
[ + - ]
940 [ + - ]: 33 : if ( rv == CUBIT_SUCCESS )
941 : : {
942 : : finish_facet_Body( cholla_ptr,
943 : : NULL,
944 : : feature_angle,
945 : : interp_order,
946 [ + - ]: 33 : body_ptr);
947 [ + - ]: 33 : if ( cholla_ptr )
948 : : {
949 [ + - ]: 33 : cholla_ptr->delete_me();
950 [ + - ][ + - ]: 33 : delete cholla_ptr;
951 : : }
952 : :
953 : : }
954 [ + - ]: 33 : return body_ptr;
955 : : }
956 : :
957 : : //===============================================================================
958 : : // Function : finish_facet_Body
959 : : // Member Type: PRIVATE
960 : : // Description: general function for creating a facet-based Body given a closed
961 : : // set of facets
962 : : // Author : John Fowler
963 : : // Date : 10/02
964 : : //===============================================================================
965 : 33 : CubitStatus FacetModifyEngine::finish_facet_Body( ChollaEngine *cholla_ptr,
966 : : const CubitEvaluatorData **eval_data,
967 : : double feature_angle,
968 : : int interp_order,
969 : : BodySM *&bodysm_ptr) const
970 : : {
971 : :
972 [ - + ][ # # ]: 33 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
973 : :
974 [ + - ]: 33 : DLIList<Surface *> surface_list;
975 : : ShellSM *shell_ptr;
976 [ + - ][ + - ]: 66 : DLIList<ShellSM*> shell_list;
977 : : Lump *lump_ptr;
978 [ + - ][ + - ]: 66 : DLIList<Lump*> lump_list;
979 : : CubitStatus rv;
980 [ + - ][ + - ]: 66 : DLIList<ChollaSurface *> cholla_surface_list;
981 [ + - ][ + - ]: 66 : DLIList<ChollaCurve *> cholla_curve_list;
982 [ + - ][ + - ]: 66 : DLIList<ChollaPoint *> cholla_point_list;
983 : :
984 [ + - ]: 33 : cholla_ptr->get_curves( cholla_curve_list );
985 [ + - ]: 33 : cholla_ptr->get_surfaces( cholla_surface_list );
986 [ + - ]: 33 : cholla_ptr->get_points( cholla_point_list );
987 : :
988 : : CubitBoolean use_feature_angle;
989 [ - + ]: 33 : if (feature_angle < 0.0)
990 : 0 : use_feature_angle = CUBIT_FALSE;
991 : : else
992 : 33 : use_feature_angle = CUBIT_TRUE;
993 : :
994 [ + - ]: 33 : GeometryQueryTool *gti = GeometryQueryTool::instance();
995 : :
996 : 33 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
997 : :
998 : : rv = fme->build_cholla_geometry( eval_data,
999 : : cholla_surface_list,
1000 : : cholla_curve_list,
1001 : : cholla_point_list,
1002 : : use_feature_angle,
1003 : : feature_angle,
1004 [ + - ]: 33 : interp_order, surface_list );
1005 : :
1006 [ + - ][ + - ]: 33 : if ( surface_list.size() == 0 || rv != CUBIT_SUCCESS )
[ - + ][ - + ]
1007 : : {
1008 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based surfaces.\n");
[ # # ][ # # ]
1009 : 0 : rv = CUBIT_FAILURE;
1010 : 0 : goto end_brick;
1011 : : }
1012 : :
1013 : : // make a body out of it
1014 [ + - ]: 33 : rv = fme->make_facet_shell(surface_list,shell_ptr);
1015 [ + - ][ - + ]: 33 : if ( shell_ptr == NULL || rv != CUBIT_SUCCESS )
1016 : : {
1017 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based shell entity.\n");
[ # # ][ # # ]
1018 : 0 : rv = CUBIT_FAILURE;
1019 : 0 : goto end_brick;
1020 : : }
1021 : : //Set the sense for the surfaces (will be cofaces) on this shell.
1022 : : //Assumption: The sense is always forward when creating geom from facets.
1023 : : // (This may not be correct -especially with multiple shells in a body)
1024 : : int ii;
1025 : : FacetShell* facet_shell;
1026 [ - + ]: 33 : facet_shell = CAST_TO( shell_ptr, FacetShell );
1027 [ + - ][ + + ]: 231 : for( ii = surface_list.size(); ii > 0; ii-- )
1028 : : {
1029 [ + - ]: 198 : Surface* surf = surface_list.get_and_step();
1030 [ - + ]: 198 : FacetSurface* facet_surf = CAST_TO( surf, FacetSurface );
1031 [ + - ]: 198 : facet_surf->set_shell_sense( facet_shell, CUBIT_FORWARD );
1032 : : }
1033 : :
1034 [ + - ]: 33 : shell_list.append(shell_ptr);
1035 [ + - ]: 33 : rv = fme->make_facet_lump(shell_list,lump_ptr);
1036 [ + - ][ - + ]: 33 : if ( lump_ptr == NULL || rv != CUBIT_SUCCESS )
1037 : : {
1038 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based lump entity.\n");
[ # # ][ # # ]
1039 : 0 : rv = CUBIT_FAILURE;
1040 : 0 : goto end_brick;
1041 : : }
1042 [ + - ]: 33 : lump_list.append(lump_ptr);
1043 [ + - ]: 33 : rv = fme->make_facet_body(lump_list,bodysm_ptr);
1044 : :
1045 [ - + ]: 33 : if ( rv != CUBIT_SUCCESS )
1046 : : {
1047 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based body entity.\n");
[ # # ][ # # ]
1048 : 0 : rv = CUBIT_FAILURE;
1049 : 0 : goto end_brick;
1050 : : }
1051 : :
1052 [ + - ][ + - ]: 33 : PRINT_INFO("Body successfully created.\n");
[ + - ][ + - ]
1053 [ + - ][ + - ]: 33 : PRINT_INFO(" Number of vertices = %d\n", gti->num_ref_vertices());
[ + - ][ + - ]
[ + - ]
1054 [ + - ][ + - ]: 33 : PRINT_INFO(" Number of edges = %d\n", gti->num_ref_edges());
[ + - ][ + - ]
[ + - ]
1055 [ + - ][ + - ]: 33 : PRINT_INFO(" Number of faces = %d\n", gti->num_ref_faces());
[ + - ][ + - ]
[ + - ]
1056 [ + - ][ + - ]: 33 : PRINT_INFO(" Number of volumes = %d\n", gti->num_ref_volumes());
[ + - ][ + - ]
[ + - ]
1057 [ + - ][ + - ]: 33 : PRINT_INFO(" Number of bodies = %d\n", gti->num_bodies());
[ + - ][ + - ]
[ + - ]
1058 : :
1059 : 33 : return rv;
1060 : :
1061 : : end_brick:
1062 : 0 : bodysm_ptr = (BodySM *)NULL;
1063 [ + - ]: 33 : return rv;
1064 : :
1065 : : }
1066 : :
1067 : 0 : CubitStatus FacetModifyEngine::finish_facet_Body( DLIList<Surface*>& surface_list, DLIList<CubitSense>& surface_sense,
1068 : : BodySM *&bodysm_ptr) const
1069 : : {
1070 : : ShellSM *shell_ptr;
1071 [ # # ]: 0 : DLIList<ShellSM*> shell_list;
1072 : : Lump *lump_ptr;
1073 [ # # ][ # # ]: 0 : DLIList<Lump*> lump_list;
1074 : : CubitStatus rv;
1075 : :
1076 : 0 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
1077 : :
1078 [ # # ][ # # ]: 0 : if ( surface_list.size() == 0 )
1079 : : {
1080 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based surfaces.\n");
[ # # ][ # # ]
1081 : 0 : rv = CUBIT_FAILURE;
1082 : 0 : goto end_brick;
1083 : : }
1084 : :
1085 : : // make a body out of it
1086 [ # # ]: 0 : rv = fme->make_facet_shell(surface_list,shell_ptr);
1087 [ # # ][ # # ]: 0 : if ( shell_ptr == NULL || rv != CUBIT_SUCCESS )
1088 : : {
1089 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based shell entity.\n");
[ # # ][ # # ]
1090 : 0 : rv = CUBIT_FAILURE;
1091 : 0 : goto end_brick;
1092 : : }
1093 : :
1094 : : int ii;
1095 : : FacetShell* facet_shell;
1096 [ # # ]: 0 : facet_shell = CAST_TO( shell_ptr, FacetShell );
1097 [ # # ][ # # ]: 0 : for( ii = 0; ii< surface_list.size(); ii++)
1098 : : {
1099 [ # # ]: 0 : Surface* surf = surface_list[ii];
1100 [ # # ]: 0 : FacetSurface* facet_surf = CAST_TO( surf, FacetSurface );
1101 [ # # ][ # # ]: 0 : facet_surf->set_shell_sense( facet_shell, surface_sense[ii] );
1102 : : }
1103 : :
1104 [ # # ]: 0 : shell_list.append(shell_ptr);
1105 [ # # ]: 0 : rv = fme->make_facet_lump(shell_list,lump_ptr);
1106 [ # # ][ # # ]: 0 : if ( lump_ptr == NULL || rv != CUBIT_SUCCESS )
1107 : : {
1108 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based lump entity.\n");
[ # # ][ # # ]
1109 : 0 : rv = CUBIT_FAILURE;
1110 : 0 : goto end_brick;
1111 : : }
1112 [ # # ]: 0 : lump_list.append(lump_ptr);
1113 [ # # ]: 0 : rv = fme->make_facet_body(lump_list,bodysm_ptr);
1114 : :
1115 [ # # ]: 0 : if ( rv != CUBIT_SUCCESS )
1116 : : {
1117 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building facet based body entity.\n");
[ # # ][ # # ]
1118 : 0 : rv = CUBIT_FAILURE;
1119 : 0 : goto end_brick;
1120 : : }
1121 : :
1122 : 0 : return rv;
1123 : :
1124 : : end_brick:
1125 : 0 : bodysm_ptr = (BodySM *)NULL;
1126 [ # # ]: 0 : return rv;
1127 : :
1128 : : }
1129 : :
1130 : : //===============================================================================
1131 : : // Function : brick
1132 : : // Member Type: PUBLIC
1133 : : // Description: create a brick with facets given center axes and extension
1134 : : // Author : Steve Owen
1135 : : // Date : 1/09
1136 : : //===============================================================================
1137 : 0 : BodySM* FacetModifyEngine::brick( const CubitVector ¢er,
1138 : : const CubitVector axes[3],
1139 : : const CubitVector &extension) const
1140 : : {
1141 : :
1142 : :
1143 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1144 : 0 : CubitStatus rv = CUBIT_SUCCESS;
1145 [ # # ][ # # ]: 0 : CubitVector uvec, vvec, wvec, corner, mid;
[ # # ][ # # ]
[ # # ]
1146 [ # # ]: 0 : DLIList <CubitFacet *>facet_list;
1147 [ # # ][ # # ]: 0 : DLIList <CubitPoint *>point_list;
1148 : : CubitPoint *new_point;
1149 : : CubitFacet *facet_ptr;
1150 : : int i, numpoints;
1151 : : double feature_angle;
1152 : : int interp_order;
1153 : : CubitBoolean smooth_non_manifold, split_surfaces;
1154 : 0 : BodySM *body_ptr = NULL;
1155 [ # # ][ # # ]: 0 : std::vector<CubitPoint *> points;
1156 : :
1157 : 0 : numpoints = 14;
1158 : :
1159 [ # # ][ # # ]: 0 : uvec = extension.x() * axes[0];
[ # # ]
1160 [ # # ][ # # ]: 0 : vvec = extension.y() * axes[1];
[ # # ]
1161 [ # # ][ # # ]: 0 : wvec = extension.z() * axes[2];
[ # # ]
1162 : :
1163 [ # # ][ # # ]: 0 : corner = center - uvec - vvec - wvec;
[ # # ][ # # ]
1164 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1165 [ # # ]: 0 : points.push_back(new_point);
1166 : :
1167 [ # # ][ # # ]: 0 : corner = center + uvec - vvec - wvec;
[ # # ][ # # ]
1168 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1169 [ # # ]: 0 : points.push_back(new_point);
1170 : :
1171 [ # # ][ # # ]: 0 : corner = center + uvec - vvec + wvec;
[ # # ][ # # ]
1172 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1173 [ # # ]: 0 : points.push_back(new_point);
1174 : :
1175 [ # # ][ # # ]: 0 : corner = center - uvec - vvec + wvec;
[ # # ][ # # ]
1176 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1177 [ # # ]: 0 : points.push_back(new_point);
1178 : :
1179 [ # # ][ # # ]: 0 : corner = center - uvec + vvec - wvec;
[ # # ][ # # ]
1180 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1181 [ # # ]: 0 : points.push_back(new_point);
1182 : :
1183 [ # # ][ # # ]: 0 : corner = center + uvec + vvec - wvec;
[ # # ][ # # ]
1184 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1185 [ # # ]: 0 : points.push_back(new_point);
1186 : :
1187 [ # # ][ # # ]: 0 : corner = center + uvec + vvec + wvec;
[ # # ][ # # ]
1188 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1189 [ # # ]: 0 : points.push_back(new_point);
1190 : :
1191 [ # # ][ # # ]: 0 : corner = center - uvec + vvec + wvec;
[ # # ][ # # ]
1192 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( corner.x(),corner.y(),corner.z() );
[ # # ][ # # ]
[ # # ]
1193 [ # # ]: 0 : points.push_back(new_point);
1194 : :
1195 [ # # ][ # # ]: 0 : mid = center - wvec;
1196 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1197 [ # # ]: 0 : points.push_back(new_point);
1198 : :
1199 [ # # ][ # # ]: 0 : mid = center + uvec;
1200 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1201 [ # # ]: 0 : points.push_back(new_point);
1202 : :
1203 [ # # ][ # # ]: 0 : mid = center + wvec;
1204 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1205 [ # # ]: 0 : points.push_back(new_point);
1206 : :
1207 [ # # ][ # # ]: 0 : mid = center - uvec;
1208 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1209 [ # # ]: 0 : points.push_back(new_point);
1210 : :
1211 [ # # ][ # # ]: 0 : mid = center - vvec;
1212 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1213 [ # # ]: 0 : points.push_back(new_point);
1214 : :
1215 [ # # ][ # # ]: 0 : mid = center + vvec;
1216 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( mid.x(), mid.y(), mid.z() );
[ # # ][ # # ]
[ # # ]
1217 [ # # ]: 0 : points.push_back(new_point);
1218 : :
1219 [ # # ]: 0 : for ( i = 0; i < numpoints; i++ ) {
1220 [ # # ][ # # ]: 0 : point_list.append(points[i]);
1221 : : }
1222 : :
1223 : : // bottom face
1224 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[0],points[1], points[12] );
[ # # ][ # # ]
[ # # ]
1225 [ # # ]: 0 : facet_list.append( facet_ptr );
1226 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[1],points[2], points[12] );
[ # # ][ # # ]
[ # # ]
1227 [ # # ]: 0 : facet_list.append( facet_ptr );
1228 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[2],points[3], points[12] );
[ # # ][ # # ]
[ # # ]
1229 [ # # ]: 0 : facet_list.append( facet_ptr );
1230 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[3],points[0], points[12] );
[ # # ][ # # ]
[ # # ]
1231 : : // back face
1232 [ # # ]: 0 : facet_list.append( facet_ptr );
1233 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[1],points[0], points[8] );
[ # # ][ # # ]
[ # # ]
1234 [ # # ]: 0 : facet_list.append( facet_ptr );
1235 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[5],points[1], points[8] );
[ # # ][ # # ]
[ # # ]
1236 [ # # ]: 0 : facet_list.append( facet_ptr );
1237 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[4],points[5], points[8] );
[ # # ][ # # ]
[ # # ]
1238 [ # # ]: 0 : facet_list.append( facet_ptr );
1239 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[0],points[4], points[8] );
[ # # ][ # # ]
[ # # ]
1240 [ # # ]: 0 : facet_list.append( facet_ptr );
1241 : : // left face
1242 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[0],points[3], points[11] );
[ # # ][ # # ]
[ # # ]
1243 [ # # ]: 0 : facet_list.append( facet_ptr );
1244 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[3],points[7], points[11] );
[ # # ][ # # ]
[ # # ]
1245 [ # # ]: 0 : facet_list.append( facet_ptr );
1246 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[7],points[4], points[11] );
[ # # ][ # # ]
[ # # ]
1247 [ # # ]: 0 : facet_list.append( facet_ptr );
1248 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[4],points[0], points[11] );
[ # # ][ # # ]
[ # # ]
1249 [ # # ]: 0 : facet_list.append( facet_ptr );
1250 : : // top face
1251 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[7],points[6], points[13] );
[ # # ][ # # ]
[ # # ]
1252 [ # # ]: 0 : facet_list.append( facet_ptr );
1253 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[6],points[5], points[13] );
[ # # ][ # # ]
[ # # ]
1254 [ # # ]: 0 : facet_list.append( facet_ptr );
1255 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[5],points[4], points[13] );
[ # # ][ # # ]
[ # # ]
1256 [ # # ]: 0 : facet_list.append( facet_ptr );
1257 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[4],points[7], points[13] );
[ # # ][ # # ]
[ # # ]
1258 [ # # ]: 0 : facet_list.append( facet_ptr );
1259 : : // right face
1260 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[1],points[5], points[9] );
[ # # ][ # # ]
[ # # ]
1261 [ # # ]: 0 : facet_list.append( facet_ptr );
1262 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[5],points[6], points[9] );
[ # # ][ # # ]
[ # # ]
1263 [ # # ]: 0 : facet_list.append( facet_ptr );
1264 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[6],points[2], points[9] );
[ # # ][ # # ]
[ # # ]
1265 [ # # ]: 0 : facet_list.append( facet_ptr );
1266 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[2],points[1], points[9] );
[ # # ][ # # ]
[ # # ]
1267 [ # # ]: 0 : facet_list.append( facet_ptr );
1268 : : // front face
1269 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[3],points[2], points[10] );
[ # # ][ # # ]
[ # # ]
1270 [ # # ]: 0 : facet_list.append( facet_ptr );
1271 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[2],points[6], points[10] );
[ # # ][ # # ]
[ # # ]
1272 [ # # ]: 0 : facet_list.append( facet_ptr );
1273 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[6],points[7], points[10] );
[ # # ][ # # ]
[ # # ]
1274 [ # # ]: 0 : facet_list.append( facet_ptr );
1275 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[7],points[3], points[10] );
[ # # ][ # # ]
[ # # ]
1276 [ # # ]: 0 : facet_list.append( facet_ptr );
1277 : :
1278 [ # # ]: 0 : points.clear(); // clear out the points vector since we are through with it.
1279 : :
1280 : 0 : feature_angle = 100.0;
1281 : 0 : interp_order = 0;
1282 : 0 : smooth_non_manifold = CUBIT_TRUE;
1283 : 0 : split_surfaces = CUBIT_FALSE;
1284 : :
1285 : 0 : ChollaEngine *cholla_ptr = NULL;
1286 : 0 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
1287 : : rv = fme->build_cholla_surfaces( facet_list,
1288 : : point_list,
1289 : : feature_angle,
1290 : : interp_order,
1291 : : smooth_non_manifold,
1292 : : split_surfaces,
1293 [ # # ][ # # ]: 0 : cholla_ptr );
[ # # ][ # # ]
[ # # ]
1294 [ # # ]: 0 : if ( rv == CUBIT_SUCCESS )
1295 : : {
1296 : : finish_facet_Body( cholla_ptr,
1297 : : NULL,
1298 : : feature_angle,
1299 : : interp_order,
1300 [ # # ]: 0 : body_ptr);
1301 [ # # ]: 0 : if ( cholla_ptr )
1302 : : {
1303 [ # # ]: 0 : cholla_ptr->delete_me();
1304 [ # # ][ # # ]: 0 : delete cholla_ptr;
1305 : : }
1306 : :
1307 : : }
1308 [ # # ]: 0 : return body_ptr;
1309 : : }
1310 : :
1311 : : //===============================================================================
1312 : : // Function : prism
1313 : : // Member Type: PUBLIC
1314 : : // Description: create a prism with facets
1315 : : // Author : John Fowler
1316 : : // Date : 10/02
1317 : : //===============================================================================
1318 : 0 : BodySM* FacetModifyEngine::prism( double /*height*/, int /*sides*/, double /*major*/,
1319 : : double /*minor*/) const
1320 : : {
1321 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1322 : 0 : return (BodySM*) NULL;
1323 : : }
1324 : :
1325 : : //===============================================================================
1326 : : // Function : pyramid
1327 : : // Member Type: PUBLIC
1328 : : // Description: create a pyramid with facets
1329 : : // Author : John Fowler
1330 : : // Date : 10/02
1331 : : //===============================================================================
1332 : 0 : BodySM* FacetModifyEngine::pyramid( double /*height*/, int /*sides*/, double /*major*/,
1333 : : double /*minor*/, double /*top*/) const
1334 : : {
1335 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1336 : 0 : return (BodySM*) NULL;
1337 : : }
1338 : :
1339 : : //===============================================================================
1340 : : // Function : cylinder
1341 : : // Member Type: PUBLIC
1342 : : // Description: create a cylinder with facets
1343 : : // Author : John Fowler
1344 : : // Date : 10/02
1345 : : //===============================================================================
1346 : 0 : BodySM* FacetModifyEngine::cylinder( double hi, double r1, double r2, double r3 ) const
1347 : : {
1348 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1349 : :
1350 : 0 : CubitStatus rv = CUBIT_SUCCESS;
1351 [ # # ]: 0 : DLIList <CubitFacet *>facet_list;
1352 [ # # ][ # # ]: 0 : DLIList <CubitPoint *>point_list;
1353 : : CubitPoint *new_point;
1354 : : CubitFacet *facet_ptr;
1355 : : int i, j, numpoints;
1356 : : double feature_angle;
1357 : : int interp_order;
1358 : : CubitBoolean smooth_non_manifold, split_surfaces;
1359 : 0 : BodySM *body_ptr = NULL;
1360 [ # # ][ # # ]: 0 : std::vector<CubitPoint *> points;
1361 : : int reslevel; // relative level of resolution
1362 : : int nl; // number of axial divisions
1363 : : int nr; // number of radil divisions
1364 : : double cfac, rinc, linc;
1365 : : double x, y, z;
1366 : : int istart, iend, V3, pend;
1367 : : double zoffset, lpos, rpos, xrad, yrad;
1368 : 0 : double rad_ratio = 1.0;
1369 : :
1370 : 0 : reslevel = 4;
1371 : 0 : nl = reslevel;
1372 : 0 : nr = 8*reslevel;
1373 : :
1374 : 0 : rinc = 360.0/(double)nr;
1375 : 0 : linc = hi/(double)nl;
1376 : 0 : cfac = CUBIT_PI/180.;
1377 : :
1378 [ # # ]: 0 : if ( r3 > 0.0 ) {
1379 : : // Cylinder:
1380 : 0 : numpoints = (nl + 1)*nr + 2;
1381 : 0 : istart = 0; iend = nl+1;
1382 : 0 : V3 = (nl+1)*nr;
1383 : 0 : pend = nl;
1384 : 0 : rad_ratio = r2/r1;
1385 : : } else {
1386 : : // Cone:
1387 : 0 : numpoints = nl*nr + 2;
1388 : 0 : istart = 0; iend = nl;
1389 : 0 : V3 = nl*nr;
1390 : 0 : pend = nl-1;
1391 : : }
1392 : :
1393 : : // Make the points.
1394 : :
1395 : 0 : zoffset = 0.0;
1396 : 0 : lpos = -0.5*hi;
1397 : 0 : xrad = r1;
1398 : 0 : yrad = r2;
1399 [ # # ]: 0 : for ( i = istart; i < iend; i++ ) {
1400 : 0 : rpos = 10.0;
1401 : 0 : xrad = zoffset*r3/hi + (hi - zoffset)*r1/hi;
1402 : 0 : yrad = zoffset*r3*rad_ratio/hi + (hi - zoffset)*r2/hi;
1403 [ # # ]: 0 : for ( j = 0; j < nr; j++ ) {
1404 : 0 : x = xrad*cos(cfac*rpos);
1405 : 0 : y = yrad*sin(cfac*rpos);
1406 : 0 : z = lpos;
1407 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( x,y,z );
1408 [ # # ]: 0 : points.push_back(new_point);
1409 : 0 : rpos += rinc;
1410 : : }
1411 : 0 : lpos += linc;
1412 : 0 : zoffset += linc;
1413 : : }
1414 : : // Add the two apoint on the axis at the ends.
1415 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( 0.,0.,-0.5*hi );
1416 [ # # ]: 0 : points.push_back(new_point);
1417 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( 0.,0.,0.5*hi );
1418 [ # # ]: 0 : points.push_back(new_point);
1419 : :
1420 [ # # ]: 0 : for ( i = 0; i < numpoints; i++ ) {
1421 [ # # ][ # # ]: 0 : point_list.append(points[i]);
1422 : : }
1423 : :
1424 : : // Make the triangles.
1425 : : int vertnum;
1426 : 0 : vertnum = 0;
1427 [ # # ]: 0 : for ( i = 0; i < pend; i++ ) {
1428 [ # # ]: 0 : for ( j = 0; j < nr-1; j++ ) {
1429 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnum+j],points[vertnum+j+1], points[vertnum+j+nr] );
[ # # ][ # # ]
[ # # ]
1430 [ # # ]: 0 : facet_list.append( facet_ptr );
1431 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnum+j+1],points[vertnum+j+1+nr], points[vertnum+j+nr] );
[ # # ][ # # ]
[ # # ]
1432 [ # # ]: 0 : facet_list.append( facet_ptr );
1433 : : }
1434 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnum],points[vertnum+nr], points[vertnum+2*nr-1] );
[ # # ][ # # ]
[ # # ]
1435 [ # # ]: 0 : facet_list.append( facet_ptr );
1436 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnum+nr-1],points[vertnum], points[vertnum+2*nr-1] );
[ # # ][ # # ]
[ # # ]
1437 [ # # ]: 0 : facet_list.append( facet_ptr );
1438 : 0 : vertnum += nr;
1439 : : }
1440 : :
1441 : : // Endcap(s)
1442 [ # # ]: 0 : for ( i = 0; i < nr-1; i++ ) { // top cap
1443 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[vertnum+i],points[vertnum+i+1], points[V3+1] );
[ # # ][ # # ]
[ # # ]
1444 [ # # ]: 0 : facet_list.append( facet_ptr );
1445 : : }
1446 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[nr-1+vertnum],points[vertnum], points[V3+1] );
[ # # ][ # # ]
[ # # ]
1447 [ # # ]: 0 : facet_list.append( facet_ptr );
1448 : :
1449 [ # # ]: 0 : for ( i = 0; i < nr-1; i++ ) { // bottom cap
1450 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[i+1],points[i], points[V3] );
[ # # ][ # # ]
[ # # ]
1451 [ # # ]: 0 : facet_list.append( facet_ptr );
1452 : : }
1453 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[0],points[nr-1], points[V3] );
[ # # ][ # # ]
[ # # ]
1454 [ # # ]: 0 : facet_list.append( facet_ptr );
1455 : :
1456 [ # # ]: 0 : points.clear(); // clear out the points vector since we are through with it.
1457 : :
1458 : 0 : feature_angle = 135.0;
1459 : 0 : interp_order = 0;
1460 : 0 : smooth_non_manifold = CUBIT_TRUE;
1461 : 0 : split_surfaces = CUBIT_FALSE;
1462 : :
1463 : 0 : ChollaEngine *cholla_ptr = NULL;
1464 : 0 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
1465 : : rv = fme->build_cholla_surfaces( facet_list,
1466 : : point_list,
1467 : : feature_angle,
1468 : : interp_order,
1469 : : smooth_non_manifold,
1470 : : split_surfaces,
1471 [ # # ][ # # ]: 0 : cholla_ptr );
[ # # ][ # # ]
[ # # ]
1472 : :
1473 [ # # ]: 0 : if ( rv == CUBIT_SUCCESS )
1474 : : {
1475 : 0 : CubitEvaluatorData **cyl_data = NULL;
1476 : :
1477 [ # # ]: 0 : set_cylinder_eval_data( cholla_ptr, hi, r1, r2, r3, cyl_data );
1478 : : finish_facet_Body( cholla_ptr,
1479 : : (const CubitEvaluatorData**)cyl_data,
1480 : : feature_angle,
1481 : : interp_order,
1482 [ # # ]: 0 : body_ptr);
1483 [ # # ]: 0 : if ( cholla_ptr )
1484 : : {
1485 [ # # ]: 0 : cholla_ptr->delete_me();
1486 [ # # ][ # # ]: 0 : delete cholla_ptr;
1487 : : }
1488 [ # # ]: 0 : if ( cyl_data )
1489 : : {
1490 [ # # ][ # # ]: 0 : if ( cyl_data[0] ) delete cyl_data[0];
[ # # ]
1491 [ # # ][ # # ]: 0 : if ( cyl_data[1] ) delete cyl_data[1];
[ # # ]
1492 [ # # ][ # # ]: 0 : if ( cyl_data[2] ) delete cyl_data[2];
[ # # ]
1493 [ # # ]: 0 : delete []cyl_data;
1494 : : }
1495 : : }
1496 [ # # ]: 0 : return body_ptr;
1497 : : }
1498 : :
1499 : 0 : void FacetModifyEngine::set_cylinder_eval_data
1500 : : (
1501 : : ChollaEngine *cholla_ptr,
1502 : : double height,
1503 : : double base_radius_xdir,
1504 : : double base_radius_ydir,
1505 : : double top_radius,
1506 : : CubitEvaluatorData **&eval_data ) const
1507 : : {
1508 : :
1509 : : // MODIFY_CHECK_RETURN_VOID;
1510 [ # # ]: 0 : DLIList<ChollaSurface *> cholla_surface_list;
1511 [ # # ]: 0 : cholla_ptr->get_surfaces( cholla_surface_list );
1512 [ # # ]: 0 : cholla_surface_list.reset();
1513 : :
1514 : 0 : eval_data = NULL;
1515 : :
1516 [ # # ][ # # ]: 0 : if ( cholla_surface_list.size() != 3 )
1517 : : {
1518 : : // This cylinder/cone is shaped quite unusually such that the cholla engine
1519 : : // found more than 3 faces on it. This is likely because it is quite smashed
1520 : : // in the minor radius direction. As such, there is not a cylindrical
1521 : : // surface so exit.
1522 : :
1523 : 0 : return;
1524 : : }
1525 : :
1526 [ # # ]: 0 : eval_data = new CubitEvaluatorData* [3];
1527 : 0 : eval_data[0] =
1528 : 0 : eval_data[1] =
1529 : 0 : eval_data[2] = NULL;
1530 : :
1531 : : int isurf;
1532 [ # # ][ # # ]: 0 : for ( isurf = 0; isurf < cholla_surface_list.size(); isurf++ )
[ # # ][ # # ]
1533 : : {
1534 : 0 : eval_data[isurf] = NULL;
1535 [ # # ]: 0 : DLIList<ChollaCurve*> cholla_curve_list;
1536 [ # # ]: 0 : ChollaSurface *csurf = cholla_surface_list.get_and_step();
1537 [ # # ]: 0 : csurf->get_curves( cholla_curve_list );
1538 [ # # ][ # # ]: 0 : if ( cholla_curve_list.size() == 2 )
1539 : : {
1540 : : // this is the cylindrical face around the cylinder.
1541 [ # # ]: 0 : CylinderEvaluatorData *data = new CylinderEvaluatorData;
1542 : 0 : data->height = height;
1543 : 0 : data->height = height;
1544 : 0 : data->base_radius_x = base_radius_xdir;
1545 : 0 : data->base_radius_y = base_radius_ydir;
1546 : 0 : data->top_radius = top_radius;
1547 : :
1548 : 0 : eval_data[isurf] = data;
1549 : : }
1550 [ # # ]: 0 : }
1551 : : }
1552 : :
1553 : : //===============================================================================
1554 : : // Function : torus
1555 : : // Member Type: PUBLIC
1556 : : // Description: create a torus with facets
1557 : : // Author : John Fowler
1558 : : // Date : 10/02
1559 : : //===============================================================================
1560 : 0 : BodySM* FacetModifyEngine::torus( double r1, double r2 ) const
1561 : : {
1562 : :
1563 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1564 : 0 : CubitStatus rv = CUBIT_SUCCESS;
1565 [ # # ]: 0 : DLIList <CubitFacet *>facet_list;
1566 [ # # ][ # # ]: 0 : DLIList <CubitPoint *>point_list;
1567 : : CubitPoint *new_point;
1568 : : CubitFacet *facet_ptr;
1569 : : int numpoints;
1570 : : double feature_angle;
1571 : : int interp_order;
1572 : : CubitBoolean smooth_non_manifold, split_surfaces;
1573 : 0 : BodySM *body_ptr = NULL;
1574 [ # # ][ # # ]: 0 : std::vector<CubitPoint *> points;
1575 : : int reslevel; // relative level of resolution
1576 : : double theta, thetainc, phi, phiinc, x, z, xp, yp, zp, rmajor, rminor;
1577 : : int numtheta, numphi, i, j;
1578 : :
1579 : 0 : reslevel = 4;
1580 : 0 : numtheta = 8*reslevel;
1581 : 0 : numphi = 8*reslevel;
1582 : 0 : numpoints = numtheta*numphi;
1583 : 0 : rmajor = r1;
1584 : 0 : rminor = r2;
1585 : 0 : thetainc = 2.*CUBIT_PI/(double)numtheta;
1586 : 0 : phiinc = 2.*CUBIT_PI/(double)numphi;
1587 : 0 : phi = 0.;
1588 : :
1589 : : // Make the points in the y=0 plane
1590 [ # # ]: 0 : for ( j = 0; j < numphi; j++ ) {
1591 : 0 : theta = 0.;
1592 [ # # ]: 0 : for ( i = 0; i < numtheta; i++ ) {
1593 : 0 : x = rmajor + rminor*cos(theta);
1594 : 0 : z = rminor*sin(theta);
1595 : : // Rotate around the z axis
1596 : 0 : xp = x*cos(phi);
1597 : 0 : zp = z;
1598 : 0 : yp = x*sin(phi);
1599 [ # # ][ # # ]: 0 : new_point = (CubitPoint *) new CubitPointData( xp,yp,zp );
1600 [ # # ]: 0 : points.push_back(new_point);
1601 : 0 : theta += thetainc;
1602 : : }
1603 : 0 : phi += phiinc;
1604 : : }
1605 : :
1606 [ # # ]: 0 : for ( i = 0; i < numpoints; i++ ) {
1607 [ # # ][ # # ]: 0 : point_list.append(points[i]);
1608 : : }
1609 : : // Make the triangles
1610 : : int m, k, m2, numtris;
1611 : 0 : m = numtheta;
1612 : 0 : numtris = 0;
1613 [ # # ]: 0 : for ( j = 0; j < numphi; j++ ) {
1614 [ # # ]: 0 : if ( j == numphi-1 ) m2 = 0;
1615 : 0 : else m2 = m;
1616 [ # # ]: 0 : for ( i = 0; i < numtheta; i++ ) {
1617 : 0 : k = (i+1)%numtheta;
1618 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[i+m-numtheta], points[m2+i], points[m2+k] );
[ # # ][ # # ]
[ # # ]
1619 [ # # ]: 0 : facet_list.append( facet_ptr );
1620 [ # # ][ # # ]: 0 : facet_ptr = new CubitFacetData( points[i+m-numtheta], points[m2+k], points[m-numtheta+k] );
[ # # ][ # # ]
[ # # ]
1621 [ # # ]: 0 : facet_list.append( facet_ptr );
1622 : 0 : numtris += 2;
1623 : : }
1624 : 0 : m += numtheta;
1625 : : }
1626 : :
1627 [ # # ]: 0 : points.clear(); // clear out the points vector since we are through with it.
1628 : :
1629 : 0 : feature_angle = 135.0;
1630 : 0 : interp_order = 0;
1631 : 0 : smooth_non_manifold = CUBIT_TRUE;
1632 : 0 : split_surfaces = CUBIT_FALSE;
1633 : :
1634 : 0 : ChollaEngine *cholla_ptr = NULL;
1635 : 0 : FacetModifyEngine *fme = const_cast<FacetModifyEngine *> (this);
1636 : : rv = fme->build_cholla_surfaces( facet_list,
1637 : : point_list,
1638 : : feature_angle,
1639 : : interp_order,
1640 : : smooth_non_manifold,
1641 : : split_surfaces,
1642 [ # # ][ # # ]: 0 : cholla_ptr );
[ # # ][ # # ]
[ # # ]
1643 : :
1644 : :
1645 [ # # ]: 0 : if ( rv == CUBIT_SUCCESS )
1646 : : {
1647 : : finish_facet_Body( cholla_ptr,
1648 : : NULL,
1649 : : feature_angle,
1650 : : interp_order,
1651 [ # # ]: 0 : body_ptr);
1652 [ # # ]: 0 : if ( cholla_ptr )
1653 : : {
1654 [ # # ]: 0 : cholla_ptr->delete_me();
1655 [ # # ][ # # ]: 0 : delete cholla_ptr;
1656 : : }
1657 : : }
1658 [ # # ]: 0 : return body_ptr;
1659 : : }
1660 : :
1661 : : //===============================================================================
1662 : : // Function : planar_sheet
1663 : : // Member Type: PUBLIC
1664 : : // Description: create a planar_sheet with facets
1665 : : // Author : John Fowler
1666 : : // Date : 10/02
1667 : : //===============================================================================
1668 : 0 : BodySM* FacetModifyEngine::planar_sheet ( const CubitVector& /*p1*/,
1669 : : const CubitVector& /*p2*/,
1670 : : const CubitVector& /*p3*/,
1671 : : const CubitVector& /*p4*/ ) const
1672 : : {
1673 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1674 : 0 : return (BodySM*) NULL;
1675 : : }
1676 : :
1677 : : //===============================================================================
1678 : : // Function : copy_body
1679 : : // Member Type: PUBLIC
1680 : : // Description: copy a facet-based body
1681 : : // Author : John Fowler
1682 : : // Date : 10/02
1683 : : //===============================================================================
1684 : 0 : BodySM* FacetModifyEngine::copy_body( BodySM* /*body_sm*/,
1685 : : std::map<TopologyBridge*, TopologyBridge*> * /*old_tb_to_new_tb */) const
1686 : : {
1687 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1688 : 0 : return (BodySM*) NULL;
1689 : : }
1690 : :
1691 : : /*
1692 : : CubitStatus FacetModifyEngine::stitch_surfs(
1693 : : DLIList<BodySM*>& surf_bodies,
1694 : : BodySM*& stitched_body) const
1695 : : {
1696 : : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1697 : : return CUBIT_SUCCESS;
1698 : : }
1699 : : */
1700 : : //===============================================================================
1701 : : // Function : subtract
1702 : : // Member Type: PUBLIC
1703 : : // Description: subtract boolean operation on facet-based bodies
1704 : : // Author : John Fowler
1705 : : // Date : 10/02
1706 : : //===============================================================================
1707 : 0 : CubitStatus FacetModifyEngine::subtract(DLIList<BodySM*> &tool_body_list,
1708 : : DLIList<BodySM*> &from_bodies,
1709 : : DLIList<BodySM*> &new_bodies,
1710 : : bool /*imprint*/,
1711 : : bool keep_old) const
1712 : : {
1713 : :
1714 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1715 : 0 : CubitStatus status = CUBIT_FAILURE;
1716 : : int i;
1717 : : BodySM *tool_body, *from_body;
1718 : : FacetboolInterface *fbint;
1719 : : CubitFacetboolOp op;
1720 : :
1721 [ # # ][ # # ]: 0 : bool *to_be_deleted = new bool[from_bodies.size()];
1722 : :
1723 : 0 : op = CUBIT_FB_SUBTRACTION;
1724 : :
1725 [ # # ]: 0 : from_bodies.reset();
1726 [ # # ]: 0 : tool_body_list.reset();
1727 : :
1728 [ # # ][ # # ]: 0 : for ( i = 0; i < from_bodies.size(); i++ ) to_be_deleted[i] = false;
1729 : :
1730 [ # # ][ # # ]: 0 : for ( i = tool_body_list.size(); i > 0; i-- ) {
1731 [ # # ]: 0 : tool_body = tool_body_list.get_and_step();
1732 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
1733 : : status = fbint->dofacetboolean_subtract(tool_body,from_bodies,new_bodies,
1734 [ # # ]: 0 : keep_old,to_be_deleted,op);
1735 [ # # ][ # # ]: 0 : delete fbint;
1736 [ # # ]: 0 : if( keep_old == false )
1737 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(tool_body);
1738 : : }
1739 : :
1740 [ # # ][ # # ]: 0 : for ( i = 0; i < from_bodies.size(); i++ ) {
1741 [ # # ]: 0 : from_body = from_bodies.get_and_step();
1742 [ # # ]: 0 : if ( to_be_deleted[i] == true )
1743 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(from_body);
1744 : : }
1745 : :
1746 [ # # ]: 0 : delete [] to_be_deleted;
1747 : :
1748 : 0 : return status;
1749 : :
1750 : : }
1751 : :
1752 : : //===============================================================================
1753 : : // Function : imprint
1754 : : // Member Type: PUBLIC
1755 : : // Description: imprint boolean operation on facet-based bodies
1756 : : // Author : John Fowler
1757 : : // Date : 10/02
1758 : : //===============================================================================
1759 : 0 : CubitStatus FacetModifyEngine::imprint(BodySM* /*BodyPtr1*/, BodySM* /*BodyPtr2*/,
1760 : : BodySM*& /*newBody1*/, BodySM*& /*newBody2*/,
1761 : : bool /*keep_old*/) const
1762 : : {
1763 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1764 : 0 : return CUBIT_FAILURE;
1765 : : }
1766 : :
1767 : : //===============================================================================
1768 : : // Function : imprint
1769 : : // Member Type: PUBLIC
1770 : : // Description: imprint boolean operation on facet-based bodies
1771 : : // Author : John Fowler
1772 : : // Date : 10/02
1773 : : //===============================================================================
1774 : 0 : CubitStatus FacetModifyEngine::imprint(DLIList<BodySM*> &from_body_list ,
1775 : : DLIList<BodySM*> &new_from_body_list,
1776 : : bool keep_old,
1777 : : DLIList<TopologyBridge*> *new_tbs,
1778 : : DLIList<TopologyBridge*> *att_tbs) const
1779 : : {
1780 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1781 : :
1782 : 0 : CubitStatus success = CUBIT_SUCCESS;
1783 : :
1784 : : // total number of imprints to be done
1785 [ # # ]: 0 : const int num_bodies = from_body_list.size();
1786 : : // int total_imprints = (num_bodies *(num_bodies-1))/2;
1787 : : int i, j;
1788 [ # # ][ # # ]: 0 : CubitBox bbox1, bbox2;
[ # # ]
1789 [ # # ][ # # ]: 0 : std::vector<BodySM*> bodies_vector;
1790 [ # # ][ # # ]: 0 : for ( i = 0; i < from_body_list.size(); i++ )
1791 [ # # ][ # # ]: 0 : bodies_vector.push_back(from_body_list.get_and_step());
1792 : :
1793 : : // pass in keep_old to the delete_owner_attrib flag; if we're not keeping
1794 : : // old bodies, we want to keep the owner attrib, so we can pick up entities
1795 : : // that didn't change
1796 : : // bool delete_attribs =
1797 [ # # ][ # # ]: 0 : (GeometryModifyTool::instance()->get_new_ids() || keep_old);
[ # # ][ # # ]
1798 : :
1799 [ # # ]: 0 : from_body_list.reset();
1800 [ # # ][ # # ]: 0 : for (i = 0; success && i < num_bodies - 1; i++) {
1801 [ # # ]: 0 : for (j = i + 1; j < num_bodies; j++) {
1802 [ # # ]: 0 : BodySM *Body_Ptr1 = bodies_vector[i];
1803 : : success = FacetQueryEngine::instance()->create_facet_bounding_box(
1804 : : Body_Ptr1,
1805 [ # # ][ # # ]: 0 : bbox1);
1806 : :
1807 [ # # ][ # # ]: 0 : if (AppUtil::instance()->interrupt())
[ # # ]
1808 : : {
1809 : 0 : success = CUBIT_FAILURE;
1810 : 0 : break;
1811 : : }
1812 [ # # ]: 0 : BodySM *Body_Ptr2 = bodies_vector[j];
1813 : : success = FacetQueryEngine::instance()->create_facet_bounding_box(
1814 : : Body_Ptr2,
1815 [ # # ][ # # ]: 0 : bbox2);
1816 [ # # ][ # # ]: 0 : if (bbox1.overlap(GEOMETRY_RESABS, bbox2)) {
1817 [ # # ][ # # ]: 0 : FacetboolInterface *FBInt = new FacetboolInterface;
1818 : : BodySM *out_Body_Ptr1, *out_Body_Ptr2;
1819 : : FBInt->dofacetboolean_2bodies_imprint(Body_Ptr1,Body_Ptr2,
1820 : : out_Body_Ptr1,out_Body_Ptr2,
1821 [ # # ]: 0 : keep_old);
1822 [ # # ][ # # ]: 0 : delete FBInt;
1823 [ # # ][ # # ]: 0 : instance()->get_gqe()->delete_solid_model_entities(bodies_vector[i]);
[ # # ][ # # ]
1824 [ # # ][ # # ]: 0 : instance()->get_gqe()->delete_solid_model_entities(bodies_vector[j]);
[ # # ][ # # ]
1825 [ # # ]: 0 : bodies_vector[i] = out_Body_Ptr1;
1826 [ # # ]: 0 : bodies_vector[j] = out_Body_Ptr2;
1827 : : }
1828 : :
1829 : : }
1830 : : }
1831 : :
1832 [ # # ]: 0 : from_body_list.reset();
1833 [ # # ][ # # ]: 0 : for ( i = 0; i < from_body_list.size(); i++ ) {
1834 [ # # ][ # # ]: 0 : new_from_body_list.append(bodies_vector[i]);
1835 : : }
1836 : :
1837 [ # # ]: 0 : return success;
1838 : : }
1839 : :
1840 : : //===============================================================================
1841 : : // Function : imprint
1842 : : // Member Type: PUBLIC
1843 : : // Description: imprint boolean operation on facet-based bodies
1844 : : // Author : John Fowler
1845 : : // Date : 10/02
1846 : : //===============================================================================
1847 : 0 : CubitStatus FacetModifyEngine::imprint( DLIList<BodySM*> &body_list,
1848 : : DLIList<Curve*> &ref_edge_list,
1849 : : DLIList<BodySM*>& new_body_list,
1850 : : DLIList<TopologyBridge*> &temporary_bridges,
1851 : : bool keep_old,
1852 : : bool show_messages) const
1853 : : {
1854 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1855 : :
1856 : 0 : CubitStatus success = CUBIT_SUCCESS;
1857 : : // bool delete_attribs =
1858 [ # # ][ # # ]: 0 : (GeometryModifyTool::instance()->get_new_ids() || keep_old);
[ # # ][ # # ]
1859 : : int i;
1860 [ # # ][ # # ]: 0 : CubitBox edge_list_bbox, bbox2;
[ # # ]
1861 [ # # ]: 0 : const int num_bodies = body_list.size();
1862 : :
1863 [ # # ][ # # ]: 0 : FacetboolInterface *FBInt = new FacetboolInterface;
1864 : :
1865 [ # # ]: 0 : FBInt->make_FB_edge_list(ref_edge_list);
1866 [ # # ]: 0 : FBInt->get_edge_list_bbox(edge_list_bbox);
1867 : :
1868 [ # # ][ # # ]: 0 : for (i = 0; success && i < num_bodies; i++) {
1869 [ # # ]: 0 : BodySM *Body_Ptr = body_list.next(i);
1870 : : success = FacetQueryEngine::instance()->create_facet_bounding_box(
1871 : : Body_Ptr,
1872 [ # # ][ # # ]: 0 : bbox2);
1873 [ # # ][ # # ]: 0 : if (edge_list_bbox.overlap(GEOMETRY_RESABS, bbox2)) {
1874 : : BodySM *new_body;
1875 [ # # ]: 0 : FBInt->FB_imprint_with_curves(Body_Ptr,new_body,keep_old);
1876 [ # # ]: 0 : new_body_list.append(new_body);
1877 : : }
1878 : : }
1879 : :
1880 [ # # ][ # # ]: 0 : delete FBInt;
1881 : :
1882 [ # # ]: 0 : body_list.reset();
1883 [ # # ][ # # ]: 0 : for ( i = 0; i < body_list.size(); i++ ) {
1884 [ # # ][ # # ]: 0 : instance()->get_gqe()->delete_solid_model_entities(body_list.get_and_step());
[ # # ][ # # ]
1885 : : }
1886 : :
1887 [ # # ]: 0 : return success;
1888 : : }
1889 : :
1890 : : //===============================================================================
1891 : : // Function : imprint
1892 : : // Member Type: PUBLIC
1893 : : // Description: imprint boolean operation on facet-based bodies
1894 : : // Author : John Fowler
1895 : : // Date : 10/02
1896 : : //===============================================================================
1897 : 0 : CubitStatus FacetModifyEngine::imprint( DLIList<Surface*> &/*ref_face_list*/,
1898 : : DLIList<Curve*> &/*ref_edge_list*/,
1899 : : DLIList<TopologyBridge*> &temporary_bridges,
1900 : : DLIList<BodySM*>& /*new_body_list*/,
1901 : : bool /*keep_old_body*/ ) const
1902 : : {
1903 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1904 : 0 : return CUBIT_FAILURE;
1905 : : }
1906 : :
1907 : : //===============================================================================
1908 : : // Function : imprint
1909 : : // Member Type: PUBLIC
1910 : : // Description: imprint boolean operation on facet-based bodies
1911 : : // Author : John Fowler
1912 : : // Date : 10/02
1913 : : //===============================================================================
1914 : 0 : CubitStatus FacetModifyEngine::imprint( DLIList<Surface*> &/*surface_list*/,
1915 : : DLIList<DLIList<Curve*>*> &/*curve_lists_list*/,
1916 : : BodySM*& /*new_body*/,
1917 : : bool /*keep_old_body*/,
1918 : : bool /*expand*/,
1919 : : DLIList<TopologyBridge*> *new_tbs,
1920 : : DLIList<TopologyBridge*> *att_tbs ) const
1921 : : {
1922 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1923 : 0 : return CUBIT_FAILURE;
1924 : : }
1925 : :
1926 : : //===============================================================================
1927 : : // Function : imprint
1928 : : // Member Type: PUBLIC
1929 : : // Description: imprint boolean operation on facet-based bodies
1930 : : // Author : John Fowler
1931 : : // Date : 10/02
1932 : : //===============================================================================
1933 : 0 : CubitStatus FacetModifyEngine::imprint(DLIList<BodySM*> &/*body_list*/,
1934 : : DLIList<CubitVector> &/*vector_list*/,
1935 : : DLIList<BodySM*>& /*new_body_list*/,
1936 : : bool keep_old, /* keep old body */
1937 : : DLIList<TopologyBridge*> *new_tbs,
1938 : : DLIList<TopologyBridge*> *att_tbs,
1939 : : double *tol_in,
1940 : : bool clean_up_slivers) const
1941 : : {
1942 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1943 : 0 : return CUBIT_FAILURE;
1944 : : }
1945 : :
1946 : : //===============================================================================
1947 : : // Function : imprint_projected_edges
1948 : : // Member Type: PUBLIC
1949 : : // Description:
1950 : : // Author : John Fowler
1951 : : // Date : 10/02
1952 : : //===============================================================================
1953 : 0 : CubitStatus FacetModifyEngine::imprint_projected_edges( DLIList<Surface*> &/*ref_face_list*/,
1954 : : DLIList<Curve*> &/*ref_edge_list*/,
1955 : : DLIList<BodySM*>& /*new_body_list*/,
1956 : : DLIList<Curve*> & /*kept_curve_list*/,
1957 : : bool /*keep_old_body*/,
1958 : : bool /*keep_free_edges*/) const
1959 : : {
1960 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1961 : 0 : return CUBIT_FAILURE;
1962 : : }
1963 : :
1964 : : //===============================================================================
1965 : : // Function : imprint_projected_edges
1966 : : // Member Type: PUBLIC
1967 : : // Description:
1968 : : // Author : John Fowler
1969 : : // Date : 10/02
1970 : : //===============================================================================
1971 : 0 : CubitStatus FacetModifyEngine::imprint_projected_edges(DLIList<Surface*> &/*ref_face_list*/,
1972 : : DLIList<BodySM*> &/*body_list*/,
1973 : : DLIList<Curve*> &/*ref_edge_list*/,
1974 : : DLIList<BodySM*>& /*new_body_list*/,
1975 : : bool /*keep_old_body*/,
1976 : : bool /*keep_free_edges*/) const
1977 : : {
1978 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1979 : 0 : return CUBIT_FAILURE;
1980 : : }
1981 : :
1982 : : //===============================================================================
1983 : : // Function : project_edges
1984 : : // Member Type: PUBLIC
1985 : : // Description:
1986 : : // Author : John Fowler
1987 : : // Date : 10/02
1988 : : //===============================================================================
1989 : 0 : CubitStatus FacetModifyEngine::project_edges( DLIList<Surface*> &/*ref_face_list*/,
1990 : : DLIList<Curve*> &/*ref_edge_list_in*/,
1991 : : DLIList<Curve*> &/*ref_edge_list_new*/,
1992 : : bool /*print_error*/ ) const
1993 : : {
1994 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
1995 : 0 : return CUBIT_FAILURE;
1996 : : }
1997 : :
1998 : : //===============================================================================
1999 : : // Function : intersect
2000 : : // Member Type: PUBLIC
2001 : : // Description: intersect boolean operation between facet-based bodies
2002 : : // Author : John Fowler
2003 : : // Date : 10/02
2004 : : //===============================================================================
2005 : 0 : CubitStatus FacetModifyEngine::intersect(BodySM* tool_body_ptr,
2006 : : DLIList<BodySM*> &from_bodies,
2007 : : DLIList<BodySM*> &new_bodies,
2008 : : bool keep_old,
2009 : : bool preview ) const
2010 : : {
2011 [ # # ]: 0 : if (preview)
2012 : : {
2013 [ # # ][ # # ]: 0 : PRINT_ERROR("Intersect preview not implemented for Facet geometry\n");
[ # # ][ # # ]
2014 : 0 : return CUBIT_FAILURE;
2015 : : }
2016 : :
2017 : :
2018 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2019 : :
2020 : 0 : CubitStatus status = CUBIT_FAILURE;
2021 : : int i;
2022 : : BodySM *from_body, *newBody;
2023 : : // FacetboolInterface *fbint;
2024 : : CubitFacetboolOp op;
2025 [ # # ]: 0 : DLIList<BodySM*> bodies;
2026 : :
2027 : 0 : op = CUBIT_FB_INTERSECTION;
2028 : :
2029 [ # # ]: 0 : from_bodies.reset();
2030 [ # # ][ # # ]: 0 : for ( i = from_bodies.size(); i > 0; i-- ) {
2031 [ # # ]: 0 : bodies.clean_out();
2032 [ # # ]: 0 : bodies.append(tool_body_ptr);
2033 [ # # ]: 0 : from_body = from_bodies.get_and_step();
2034 [ # # ]: 0 : bodies.append(from_body);
2035 [ # # ]: 0 : FacetboolInterface fbint;
2036 [ # # ]: 0 : status = fbint.dofacetboolean(bodies,newBody,keep_old,op);
2037 [ # # ][ # # ]: 0 : if ( status == CUBIT_SUCCESS && newBody) new_bodies.append(newBody);
[ # # ]
2038 [ # # ]: 0 : }
2039 : :
2040 [ # # ]: 0 : return status;
2041 : :
2042 : : /*
2043 : : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2044 : : return CUBIT_FAILURE;
2045 : : */
2046 : : }
2047 : :
2048 : : //===============================================================================
2049 : : // Function : chop
2050 : : // Member Type: PUBLIC
2051 : : // Description: chop boolean operation between facet-based bodies
2052 : : // Author : John Fowler
2053 : : // Date : 10/02
2054 : : //===============================================================================
2055 : 0 : CubitStatus FacetModifyEngine::chop(DLIList<BodySM*>& bodies,
2056 : : DLIList<BodySM*> &intersectBodies,
2057 : : DLIList<BodySM*> &outsideBodies,
2058 : : BodySM*& leftoversBody,
2059 : : bool keep_old ,
2060 : : bool nonreg) const
2061 : : {
2062 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2063 : :
2064 : : //Note: there is never any leftover body.
2065 : : FacetboolInterface *fbint;
2066 : : CubitFacetboolOp op;
2067 : 0 : bool keep_old_this = keep_old;
2068 : : CubitStatus status;
2069 : : BodySM *body_1, *body_2;
2070 : : bool intersection_found;
2071 : 0 : BodySM* intersectBody = NULL;
2072 : 0 : BodySM* outsideBody = NULL;
2073 : :
2074 [ # # ][ # # ]: 0 : if ( bodies.size() > 2 ) {
2075 [ # # ][ # # ]: 0 : PRINT_ERROR("Chop not yet supported for more than two bodies.\n");
[ # # ][ # # ]
2076 : 0 : return CUBIT_FAILURE;
2077 : : }
2078 [ # # ]: 0 : body_1 = bodies.get_and_step();
2079 [ # # ]: 0 : body_2 = bodies.get();
2080 : 0 : op = CUBIT_FB_INTERSECTION;
2081 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
2082 : : status = fbint->dofacetboolean_2bodies(body_2,body_1,intersectBody,
2083 [ # # ]: 0 : keep_old_this,intersection_found,op);
2084 [ # # ]: 0 : if(!status){
2085 [ # # ][ # # ]: 0 : delete fbint;
2086 : 0 : return status;
2087 : : }
2088 : :
2089 : :
2090 [ # # ][ # # ]: 0 : delete fbint;
2091 [ # # ]: 0 : if(intersection_found){
2092 [ # # ]: 0 : intersectBodies.append( intersectBody );
2093 : : }
2094 : : else{
2095 : 0 : return CUBIT_FAILURE;
2096 : : }
2097 : 0 : op = CUBIT_FB_SUBTRACTION;
2098 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
2099 : : status = fbint->dofacetboolean_2bodies(body_1,body_2,outsideBody,
2100 [ # # ]: 0 : keep_old_this,intersection_found,op);
2101 [ # # ]: 0 : if(!status){
2102 [ # # ][ # # ]: 0 : delete fbint;
2103 : 0 : return status;
2104 : : }
2105 [ # # ][ # # ]: 0 : delete fbint;
2106 [ # # ]: 0 : if(intersection_found){
2107 [ # # ]: 0 : outsideBodies.append( outsideBody );
2108 : : }
2109 : : else{
2110 : 0 : return CUBIT_FAILURE;
2111 : : }
2112 : :
2113 [ # # ]: 0 : if ( keep_old == false ) {
2114 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(body_1);
2115 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(body_2);
2116 : : }
2117 : :
2118 : 0 : return status;
2119 : :
2120 : : }
2121 : :
2122 : 0 : void FacetModifyEngine::get_possible_invalid_tbs(DLIList<TopologyBridge*> &bridges_in,
2123 : : DLIList<TopologyBridge*> &bridges_out)
2124 : : {
2125 : 0 : }
2126 : :
2127 : : //===============================================================================
2128 : : // Function : unite
2129 : : // Member Type: PUBLIC
2130 : : // Description: unite boolean operation between facet-based bodies
2131 : : // Author : John Fowler
2132 : : // Date : 10/02
2133 : : //===============================================================================
2134 : 0 : CubitStatus FacetModifyEngine::unite(DLIList<BodySM*> &bodies,
2135 : : DLIList<BodySM*> &newBodies,
2136 : : bool keep_old) const
2137 : : {
2138 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2139 : :
2140 : :
2141 : : CubitStatus status;
2142 : : FacetboolInterface *fbint;
2143 : : CubitFacetboolOp op;
2144 : :
2145 : 0 : op = CUBIT_FB_UNION;
2146 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
2147 : :
2148 : 0 : BodySM *newBody = NULL;
2149 [ # # ]: 0 : status = fbint->dofacetboolean(bodies,newBody,keep_old,op);
2150 : :
2151 [ # # ]: 0 : newBodies.append( newBody );
2152 [ # # ][ # # ]: 0 : delete fbint;
2153 : 0 : return status;
2154 : : /*
2155 : : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2156 : : return CUBIT_FAILURE;
2157 : : */
2158 : :
2159 : : }
2160 : :
2161 : :
2162 : 0 : CubitStatus FacetModifyEngine::hollow( DLIList<BodySM*>& /*bodies*/,
2163 : : DLIList<Surface*> & /*surfs*/,
2164 : : DLIList<BodySM*>& /*new_bodies*/,
2165 : : double /*depth*/) const
2166 : : {
2167 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2168 : 0 : return CUBIT_FAILURE;
2169 : : }
2170 : :
2171 : : //===============================================================================
2172 : : // Function : thicken
2173 : : // Member Type: PUBLIC
2174 : : // Description:
2175 : : // Author : John Fowler
2176 : : // Date : 10/02
2177 : : //===============================================================================
2178 : 0 : CubitStatus FacetModifyEngine::thicken(DLIList<BodySM*>& /*bodies*/,
2179 : : DLIList<BodySM*>& /*new_bodies*/,
2180 : : double /*depth*/,
2181 : : bool /*both*/) const
2182 : : {
2183 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2184 : 0 : return CUBIT_FAILURE;
2185 : : }
2186 : :
2187 : :
2188 : : //===============================================================================
2189 : : // Function : flip_normals
2190 : : // Member Type: PUBLIC
2191 : : // Description:
2192 : : // Author : John Fowler
2193 : : // Date : 10/02
2194 : : //===============================================================================
2195 : 0 : CubitStatus FacetModifyEngine :: flip_normals( DLIList<Surface*>& face_list ) const
2196 : : {
2197 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2198 : 0 : return CUBIT_FAILURE;
2199 : : }
2200 : :
2201 : :
2202 : : //===============================================================================
2203 : : // Function : sweep_translational
2204 : : // Member Type: PUBLIC
2205 : : // Description:
2206 : : // Author : John Fowler
2207 : : // Date : 10/02
2208 : : //===============================================================================
2209 : 0 : CubitStatus FacetModifyEngine:: sweep_translational(
2210 : : DLIList<GeometryEntity*>& /*ref_ent_list*/,
2211 : : DLIList<BodySM*>& /*result_body_list*/,
2212 : : const CubitVector& /*sweep_vector*/,
2213 : : double /*draft_angle*/,
2214 : : int /*draft_type*/,
2215 : : bool /*switchside*/,
2216 : : bool /*rigid*/,
2217 : : bool /*anchor_entity*/,
2218 : : bool /*keep_old*/ ) const
2219 : : {
2220 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2221 : 0 : return CUBIT_FAILURE;
2222 : : }
2223 : :
2224 : : //===============================================================================
2225 : : // Function : sweep_perpendicular
2226 : : // Member Type: PUBLIC
2227 : : // Description:
2228 : : // Author : John Fowler
2229 : : // Date : 10/02
2230 : : //===============================================================================
2231 : 0 : CubitStatus FacetModifyEngine:: sweep_perpendicular(
2232 : : DLIList<GeometryEntity*>& /*ref_ent_list*/,
2233 : : DLIList<BodySM*>& /*result_body_list*/,
2234 : : double /*distance*/,
2235 : : double /*draft_angle*/,
2236 : : int /*draft_type*/,
2237 : : bool /*switchside*/,
2238 : : bool /*rigid*/,
2239 : : bool /*anchor_entity*/,
2240 : : bool /*keep_old*/ ) const
2241 : : {
2242 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2243 : 0 : return CUBIT_FAILURE;
2244 : : }
2245 : :
2246 : : //===============================================================================
2247 : : // Function : sweep_rotational
2248 : : // Member Type: PUBLIC
2249 : : // Description:
2250 : : // Author : John Fowler
2251 : : // Date : 10/02
2252 : : //===============================================================================
2253 : 0 : CubitStatus FacetModifyEngine:: sweep_rotational(
2254 : : DLIList<GeometryEntity*>& /*ref_ent_list*/,
2255 : : DLIList<BodySM*>& /*result_body_list*/,
2256 : : const CubitVector& /*point*/,
2257 : : const CubitVector& /*direction*/,
2258 : : double /*angle*/,
2259 : : int /*steps*/,
2260 : : double /*draft_angle*/,
2261 : : int /*draft_type*/,
2262 : : bool /*switchside*/,
2263 : : bool /*make_solid*/,
2264 : : bool /*rigid*/,
2265 : : bool /*anchor_entity*/,
2266 : : bool /*keep_old*/ ) const
2267 : : {
2268 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2269 : 0 : return CUBIT_FAILURE;
2270 : : }
2271 : :
2272 : : //===============================================================================
2273 : : // Function : sweep_along_curve
2274 : : // Member Type: PUBLIC
2275 : : // Description:
2276 : : // Author : John Fowler
2277 : : // Date : 10/02
2278 : : //===============================================================================
2279 : 0 : CubitStatus FacetModifyEngine::sweep_along_curve(
2280 : : DLIList<GeometryEntity*>& /*ref_ent_list*/,
2281 : : DLIList<BodySM*>& /*result_body_list*/,
2282 : : DLIList<Curve*>& /*ref_edge_list*/,
2283 : : double /*draft_angle*/,
2284 : : int /*draft_type*/,
2285 : : bool /*rigid*/,
2286 : : bool /*anchor_entity*/,
2287 : : bool /*keep_old*/ ) const
2288 : : {
2289 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2290 : 0 : return CUBIT_FAILURE;
2291 : : }
2292 : :
2293 : 0 : CubitStatus FacetModifyEngine::sweep_to_body( DLIList<Curve*> curve_list,
2294 : : BodySM *target_body,
2295 : : CubitVector distance,
2296 : : DLIList<BodySM*> &new_bodies,
2297 : : bool unite ) const
2298 : : {
2299 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2300 : 0 : return CUBIT_FAILURE;
2301 : : }
2302 : :
2303 : 0 : CubitStatus FacetModifyEngine::sweep_to_body( Surface *source_surface,
2304 : : BodySM *target_body,
2305 : : CubitVector distance,
2306 : : DLIList<BodySM*> &new_bodies ) const
2307 : : {
2308 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2309 : 0 : return CUBIT_FAILURE;
2310 : : }
2311 : :
2312 : : //HEADER- Webcut-related functions
2313 : :
2314 : : //===============================================================================
2315 : : // Function : webcut
2316 : : // Member Type: PUBLIC
2317 : : // Description:
2318 : : // Author : John Fowler
2319 : : // Date : 10/02
2320 : : //===============================================================================
2321 : 0 : CubitStatus FacetModifyEngine::webcut(DLIList<BodySM*>& webcut_body_list,
2322 : : const CubitVector &v1,
2323 : : const CubitVector &v2,
2324 : : const CubitVector &v3,
2325 : : DLIList<BodySM*>& neighbor_imprint_list,
2326 : : DLIList<BodySM*>& results_list,
2327 : : ImprintType imprint_type,
2328 : : bool /*preview*/) const
2329 : : {
2330 : :
2331 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2332 : :
2333 [ # # ]: 0 : CubitBox super_bbox;
2334 : : CubitStatus status;
2335 : : int i;
2336 : :
2337 [ # # ][ # # ]: 0 : CubitBoolean delete_bodies = (GeometryModifyTool::instance()->get_new_ids() ?
2338 [ # # ]: 0 : CUBIT_FALSE : CUBIT_TRUE);
2339 : :
2340 : : // Find the bounding box of all of the bodies. This will be used to make
2341 : : // the cutting plane.
2342 : :
2343 : :
2344 : : status = FacetQueryEngine::instance()->create_super_facet_bounding_box(webcut_body_list,
2345 [ # # ][ # # ]: 0 : super_bbox);
2346 : :
2347 : : // Find the size of the cutting plane (x,y) in terms of super_bbox.
2348 [ # # ][ # # ]: 0 : DLIList<CubitVector> intersection_points;
2349 : : FBDataUtil::intersect_plane_with_boundingbox(super_bbox,
2350 [ # # ]: 0 : v1,v2,v3,intersection_points);
2351 [ # # ]: 0 : int numpts = intersection_points.size();;
2352 [ # # ]: 0 : if ( numpts < 3 ) {
2353 [ # # ][ # # ]: 0 : PRINT_INFO("INFO: Cutting Tool overlaps the original volume,\n"
[ # # ]
2354 : : " Or cutting plane does not pass through volume.\n"
2355 [ # # ]: 0 : " The original volume is unaffected.\n" );
2356 : :
2357 : 0 : return CUBIT_FAILURE;
2358 : : }
2359 : : double xsize, ysize, xcen, ycen, zcen;
2360 : : double xmin, ymin, zmin, xmax, ymax, zmax, xx, yy, zz;
2361 : 0 : xmin = ymin = zmin = CUBIT_DBL_MAX;
2362 : 0 : xmax = ymax = zmax = -xmin + 1;
2363 : 0 : xcen = ycen = zcen = 0.0;
2364 [ # # ]: 0 : for ( i = 0; i < numpts; i++ ) {
2365 [ # # ][ # # ]: 0 : xx = intersection_points[i].x();
2366 [ # # ][ # # ]: 0 : yy = intersection_points[i].y();
2367 [ # # ][ # # ]: 0 : zz = intersection_points[i].z();
2368 : :
2369 : 0 : xcen += xx;
2370 : 0 : ycen += yy;
2371 : 0 : zcen += zz;
2372 : :
2373 [ # # ]: 0 : xmin = (xmin < xx ) ? xmin : xx;
2374 [ # # ]: 0 : ymin = (ymin < yy ) ? ymin : yy;
2375 [ # # ]: 0 : zmin = (zmin < zz ) ? zmin : zz;
2376 [ # # ]: 0 : xmax = (xmax > xx ) ? xmax : xx;
2377 [ # # ]: 0 : ymax = (ymax > yy ) ? ymax : yy;
2378 [ # # ]: 0 : zmax = (zmax > zz ) ? zmax : zz;
2379 : : }
2380 : 0 : xcen /= numpts; ycen /= numpts; zcen /= numpts;
2381 : :
2382 : : // Could do this better by rotating the intersection points into the
2383 : : // x-y plane and then getting xsize and ysize. Factor of 1.3 is just
2384 : : // to make sure that the plane extends beyond the bodies.
2385 : 0 : xsize = ysize = 1.3*sqrt( (xmax-xmin)*(xmax-xmin) +
2386 : 0 : (ymax-ymin)*(ymax-ymin) +
2387 : 0 : (zmax-zmin)*(zmax-zmin) );
2388 [ # # ][ # # ]: 0 : std::vector<double> cutter_verts;
2389 [ # # ][ # # ]: 0 : std::vector<int> cutter_connections;
2390 : : int numx, numy;
2391 : 0 : numx = 20;
2392 : 0 : numy = 20;
2393 : : // Make the cutter surface.
2394 : : status = FBDataUtil::FBmake_xy_plane(cutter_verts, cutter_connections,
2395 [ # # ]: 0 : xsize, ysize, numx, numy);
2396 [ # # ][ # # ]: 0 : CubitVector va, vb;
2397 [ # # ][ # # ]: 0 : va = v1 - v2;
2398 [ # # ][ # # ]: 0 : vb = v3 - v2;
2399 [ # # ]: 0 : CubitVector rotate_to;
2400 : :
2401 [ # # ][ # # ]: 0 : rotate_to = vb*va;
2402 [ # # ]: 0 : rotate_to.normalize();
2403 [ # # ]: 0 : CubitVector center_pt(xcen,ycen,zcen);
2404 [ # # ]: 0 : status = FBDataUtil::rotate_FB_object(cutter_verts,rotate_to,center_pt);
2405 : : FacetboolInterface *fbint;
2406 : 0 : bool cutter_is_plane = true;
2407 : : // Now make the facetbool objects for the bodies.
2408 [ # # ]: 0 : webcut_body_list.reset();
2409 : : BodySM *body_sm;
2410 : :
2411 [ # # ][ # # ]: 0 : for ( i = webcut_body_list.size(); i > 0; i-- ) {
2412 : : CubitBoolean intersects;
2413 [ # # ]: 0 : body_sm = webcut_body_list.get_and_step();
2414 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
2415 : : status = fbint->webcut_FB(body_sm,cutter_verts,cutter_connections,
2416 : : cutter_is_plane,delete_bodies,
2417 [ # # ]: 0 : intersects,results_list);
2418 [ # # ][ # # ]: 0 : delete fbint;
2419 [ # # ]: 0 : if ( status == CUBIT_FAILURE )
2420 : : {
2421 [ # # ][ # # ]: 0 : PRINT_ERROR(" Unable to perform webcut.\n" );
[ # # ][ # # ]
2422 : 0 : return CUBIT_FAILURE;
2423 : : }
2424 : :
2425 [ # # ][ # # ]: 0 : if ( status == CUBIT_SUCCESS && intersects )
2426 : : {
2427 [ # # ][ # # ]: 0 : instance()->get_gqe()->delete_solid_model_entities(body_sm);
[ # # ]
2428 : : }
2429 : : else
2430 : : {
2431 [ # # ][ # # ]: 0 : PRINT_INFO("INFO: Cutting Tool overlaps the original volume,\n"
[ # # ]
2432 : : " Or cutting plane does not pass through volume.\n"
2433 [ # # ]: 0 : " The original volume is unaffected.\n" );
2434 : : }
2435 : : }
2436 : :
2437 [ # # ]: 0 : return status;
2438 : :
2439 : : }
2440 : :
2441 : : //===============================================================================
2442 : : // Function : webcut
2443 : : // Member Type: PUBLIC
2444 : : // Description:
2445 : : // Author : John Fowler
2446 : : // Date : 10/02
2447 : : //===============================================================================
2448 : 0 : CubitStatus FacetModifyEngine::webcut(DLIList<BodySM*>& /*webcut_body_list*/,
2449 : : BodySM const* /*tool_body*/,
2450 : : DLIList<BodySM*>& /*neighbor_imprint_list*/,
2451 : : DLIList<BodySM*>& /*results_list*/,
2452 : : ImprintType imprint_type,
2453 : : bool /*preview*/) const
2454 : : {
2455 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2456 : 0 : return CUBIT_FAILURE;
2457 : : }
2458 : :
2459 : : //===============================================================================
2460 : : // Function : webcut_across_translate
2461 : : // Member Type: PUBLIC
2462 : : // Description:
2463 : : // Author : John Fowler
2464 : : // Date : 10/02
2465 : : //===============================================================================
2466 : 0 : CubitStatus FacetModifyEngine::webcut_across_translate( DLIList<BodySM*>& /*body_list*/,
2467 : : Surface* /*plane_surf1*/,
2468 : : Surface* /*plane_surf2*/,
2469 : : DLIList<BodySM*>& /*neighbor_imprint_list*/,
2470 : : DLIList<BodySM*>& /*results_list*/,
2471 : : ImprintType imprint_type,
2472 : : bool /*preview*/) const
2473 : : {
2474 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2475 : 0 : return CUBIT_FAILURE;
2476 : : }
2477 : :
2478 : : //===============================================================================
2479 : : // Function : webcut_with_sheet
2480 : : // Member Type: PUBLIC
2481 : : // Description:
2482 : : // Author : John Fowler
2483 : : // Date : 10/02
2484 : : //===============================================================================
2485 : 0 : CubitStatus FacetModifyEngine::webcut_with_sheet(DLIList<BodySM*> & /*webcut_body_list*/,
2486 : : BodySM * /*sheet_body*/,
2487 : : DLIList<BodySM*>& /*neighbor_imprint_list*/,
2488 : : DLIList<BodySM*> & /*new_bodies*/,
2489 : : ImprintType imprint_type,
2490 : : bool /*preview*/)
2491 : : {
2492 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2493 : 0 : return CUBIT_FAILURE;
2494 : : }
2495 : :
2496 : : //===============================================================================
2497 : : // Function : webcut_with_extended_surf
2498 : : // Member Type: PUBLIC
2499 : : // Description:
2500 : : // Author : John Fowler
2501 : : // Date : 10/02
2502 : : //===============================================================================
2503 : 0 : CubitStatus FacetModifyEngine::webcut_with_extended_sheet(DLIList<BodySM*> & /*webcut_body_list*/,
2504 : : DLIList<Surface*> & /*surface_list*/,
2505 : : DLIList<BodySM*>& /*neighbor_imprint_list*/,
2506 : : DLIList<BodySM*> & /*new_bodies*/,
2507 : : int & /*num_cut*/,
2508 : : ImprintType imprint_type,
2509 : : bool /*preview*/)
2510 : : {
2511 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2512 : 0 : return CUBIT_FAILURE;
2513 : : }
2514 : :
2515 : : //===============================================================================
2516 : : // Function : webcut_with_cylinder
2517 : : // Member Type: PUBLIC
2518 : : // Description:
2519 : : // Author : John Fowler
2520 : : // Date : 10/02
2521 : : //===============================================================================
2522 : 0 : CubitStatus FacetModifyEngine::webcut_with_cylinder(DLIList<BodySM*> &webcut_body_list,
2523 : : double radius,
2524 : : const CubitVector &axis,
2525 : : const CubitVector ¢er,
2526 : : DLIList<BodySM*>& neighbor_imprint_list,
2527 : : DLIList<BodySM*>& results_list,
2528 : : ImprintType imprint_type,
2529 : : bool /*preview*/ )
2530 : : {
2531 : :
2532 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2533 : :
2534 [ # # ]: 0 : CubitBox super_bbox;
2535 : : CubitStatus status;
2536 : : int i;
2537 [ # # ][ # # ]: 0 : CubitVector bodies_center, my_center, diagonal, my_axis;
[ # # ][ # # ]
2538 : :
2539 [ # # ][ # # ]: 0 : CubitBoolean delete_bodies = (GeometryModifyTool::instance()->get_new_ids() ?
2540 [ # # ]: 0 : CUBIT_FALSE : CUBIT_TRUE);
2541 : :
2542 : : status = FacetQueryEngine::instance()->create_super_facet_bounding_box(
2543 [ # # ][ # # ]: 0 : webcut_body_list,super_bbox);
2544 [ # # ][ # # ]: 0 : std::vector<double> cutter_verts;
2545 [ # # ][ # # ]: 0 : std::vector<int> cutter_connections;
2546 : : int nr, nz;
2547 : : double length;
2548 : :
2549 [ # # ][ # # ]: 0 : diagonal = super_bbox.diagonal();
2550 : : // length = 2.3*diagonal.length() + 2.0*center.length();
2551 [ # # ][ # # ]: 0 : bodies_center = super_bbox.center();
2552 [ # # ][ # # ]: 0 : length = 3.*sqrt((bodies_center.x() - center.x())*(bodies_center.x() - center.x()) +
[ # # ][ # # ]
2553 [ # # ][ # # ]: 0 : (bodies_center.y() - center.y())*(bodies_center.y() - center.y()) +
[ # # ][ # # ]
2554 [ # # ][ # # ]: 0 : (bodies_center.z() - center.z())*(bodies_center.z() - center.z()) );
[ # # ][ # # ]
2555 [ # # ]: 0 : length += 3.*diagonal.length();
2556 : : //length = sqrt(length*length + radius*radius);
2557 : : // bodies_center += center;
2558 : :
2559 : 0 : nr = 30;
2560 : 0 : nz = 5;
2561 : :
2562 : : // Make the cutter surface.
2563 : : status = FBDataUtil::FBmake_cylinder(cutter_verts, cutter_connections,
2564 [ # # ]: 0 : radius, length, nr, nz);
2565 [ # # ]: 0 : my_center = center;
2566 [ # # ]: 0 : my_axis = axis;
2567 [ # # ]: 0 : status = FBDataUtil::rotate_FB_object(cutter_verts,my_axis,my_center);
2568 : :
2569 : : FacetboolInterface *fbint;
2570 : 0 : bool cutter_is_plane = false;
2571 : : // Now make the facetbool objects for the bodies.
2572 [ # # ]: 0 : webcut_body_list.reset();
2573 : : BodySM* body_sm;
2574 [ # # ][ # # ]: 0 : for ( i = webcut_body_list.size(); i > 0; i-- ) {
2575 : : CubitBoolean intersects;
2576 [ # # ]: 0 : body_sm = webcut_body_list.get_and_step();
2577 [ # # ][ # # ]: 0 : fbint = new FacetboolInterface;
2578 : : status = fbint->webcut_FB(body_sm,cutter_verts,cutter_connections,
2579 : : cutter_is_plane,delete_bodies,
2580 [ # # ]: 0 : intersects,results_list);
2581 [ # # ][ # # ]: 0 : delete fbint;
2582 [ # # ]: 0 : if ( status == CUBIT_FAILURE )
2583 : : {
2584 [ # # ][ # # ]: 0 : PRINT_ERROR(" Unable to perform webcut.\n" );
[ # # ][ # # ]
2585 : 0 : return CUBIT_FAILURE;
2586 : : }
2587 : :
2588 [ # # ][ # # ]: 0 : if ( status == CUBIT_SUCCESS && intersects )
2589 : : {
2590 [ # # ][ # # ]: 0 : instance()->get_gqe()->delete_solid_model_entities(body_sm);
[ # # ]
2591 : : }
2592 : : else
2593 : : {
2594 [ # # ][ # # ]: 0 : PRINT_INFO("INFO: Cutting Tool overlaps the original volume,\n"
[ # # ]
2595 : : " Or cutting plane does not pass through volume.\n"
2596 [ # # ]: 0 : " The original volume is unaffected.\n" );
2597 : : }
2598 : : }
2599 : :
2600 [ # # ]: 0 : return status;
2601 : :
2602 : : }
2603 : :
2604 : : //===============================================================================
2605 : : // Function : webcut_with_brick
2606 : : // Member Type: PUBLIC
2607 : : // Description:
2608 : : // Author : John Fowler
2609 : : // Date : 10/02
2610 : : //===============================================================================
2611 : 0 : CubitStatus FacetModifyEngine::webcut_with_brick(
2612 : : DLIList<BodySM*>& /*webcut_body_list*/,
2613 : : const CubitVector &/*center*/,
2614 : : const CubitVector* /*axes[3]*/,
2615 : : const CubitVector &/*extension*/,
2616 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
2617 : : DLIList<BodySM*> &/*results_list*/,
2618 : : ImprintType imprint_type,
2619 : : bool /*preview*/)
2620 : : {
2621 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2622 : 0 : return CUBIT_FAILURE;
2623 : : }
2624 : :
2625 : : //===============================================================================
2626 : : // Function : webcut_with_planar_sheet
2627 : : // Member Type: PUBLIC
2628 : : // Description:
2629 : : // Author : John Fowler
2630 : : // Date : 10/02
2631 : : //===============================================================================
2632 : 0 : CubitStatus FacetModifyEngine::webcut_with_planar_sheet(
2633 : : DLIList<BodySM*>& /*webcut_body_list*/,
2634 : : const CubitVector &/*center*/,
2635 : : const CubitVector* /*axes[2]*/,
2636 : : double /*width*/,
2637 : : double /*height*/,
2638 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
2639 : : DLIList<BodySM*> &/*results_list*/,
2640 : : ImprintType imprint_type,
2641 : : bool /*preview*/)
2642 : : {
2643 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2644 : 0 : return CUBIT_FAILURE;
2645 : : }
2646 : :
2647 : : //===============================================================================
2648 : : // Function : webcut_with_curve_loop
2649 : : // Member Type: PUBLIC
2650 : : // Description:
2651 : : // Author : John Fowler
2652 : : // Date : 10/02
2653 : : //===============================================================================
2654 : 0 : CubitStatus FacetModifyEngine::webcut_with_curve_loop(
2655 : : DLIList<BodySM*> &/*webcut_body_list*/,
2656 : : DLIList<Curve*> &/*ref_edge_list*/,
2657 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
2658 : : DLIList<BodySM*>& /*results_list*/,
2659 : : ImprintType imprint_type,
2660 : : bool /*preview*/)
2661 : : {
2662 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2663 : 0 : return CUBIT_FAILURE;
2664 : : }
2665 : :
2666 : : //===============================================================================
2667 : : // Function : section
2668 : : // Member Type: PUBLIC
2669 : : // Description:
2670 : : // Author : John Fowler
2671 : : // Date : 10/02
2672 : : //===============================================================================
2673 : 0 : CubitStatus FacetModifyEngine::section( DLIList<BodySM*> &/*section_body_list*/,
2674 : : const CubitVector &/*point_1*/,
2675 : : const CubitVector &/*point_2*/,
2676 : : const CubitVector &/*point_3*/,
2677 : : DLIList<BodySM*>& /*new_body_list*/,
2678 : : bool /*keep_normal_side*/,
2679 : : bool /*keep_old*/,
2680 : : bool /*keep_both_sides*/)
2681 : : {
2682 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2683 : 0 : return CUBIT_FAILURE;
2684 : : }
2685 : :
2686 : : //===============================================================================
2687 : : // Function : split_body
2688 : : // Member Type: PUBLIC
2689 : : // Description: Splits multiple lumps in one body into separate bodies
2690 : : // Author : Corey Ernst
2691 : : // Date : 08/04
2692 : : //===============================================================================
2693 : 0 : CubitStatus FacetModifyEngine::split_body( BodySM *body_ptr,
2694 : : DLIList<BodySM*> &new_bodies )
2695 : : {
2696 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2697 : :
2698 : : //get the all lumps of input body
2699 [ # # ]: 0 : DLIList<Lump*> lumps;
2700 [ # # ]: 0 : body_ptr->lumps( lumps );
2701 : :
2702 [ # # ][ # # ]: 0 : if( lumps.size() == 1 )
2703 : : {
2704 [ # # ]: 0 : new_bodies.append( body_ptr );
2705 : 0 : return CUBIT_SUCCESS;
2706 : : }
2707 : :
2708 : : //for each lump except one first one, create a new body
2709 [ # # ][ # # ]: 0 : DLIList<Lump*> single_lump;
2710 [ # # ]: 0 : lumps.reset();
2711 [ # # ]: 0 : lumps.step();
2712 : : int i;
2713 : 0 : FacetBody *tmp_facet_body = static_cast<FacetBody*>( body_ptr );
2714 [ # # ][ # # ]: 0 : for( i=lumps.size()-1; i--; )
2715 : : {
2716 : : BodySM *bodysm_ptr;
2717 [ # # ]: 0 : single_lump.clean_out();
2718 [ # # ][ # # ]: 0 : tmp_facet_body->remove_lump( static_cast<FacetLump*>(lumps.get()));
2719 [ # # ][ # # ]: 0 : single_lump.append( lumps.get_and_step() );
2720 [ # # ]: 0 : make_facet_body(single_lump, bodysm_ptr);
2721 [ # # ]: 0 : if( bodysm_ptr )
2722 [ # # ]: 0 : new_bodies.append(bodysm_ptr);
2723 : : }
2724 : :
2725 [ # # ]: 0 : new_bodies.append( body_ptr );
2726 : :
2727 [ # # ]: 0 : return CUBIT_SUCCESS;
2728 : : }
2729 : :
2730 : : //===============================================================================
2731 : : // Function : separate_surfaces
2732 : : // Member Type: PUBLIC
2733 : : // Description: Separates surfaces from sheet bodies into separate bodies.
2734 : : // Connected surfaces will remain connected but be placed in a new
2735 : : // body. NOT IMPLEMENTED
2736 : : // Author :
2737 : : // Date :
2738 : : //===============================================================================
2739 : 0 : CubitStatus FacetModifyEngine::separate_surfaces( DLIList<Surface*> &surf_list,
2740 : : DLIList<BodySM*> &new_bodies )
2741 : : {
2742 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2743 : 0 : return CUBIT_FAILURE;
2744 : : }
2745 : :
2746 : : //===============================================================================
2747 : : // Function : reverse_body
2748 : : // Member Type: PUBLIC
2749 : : // Description: Turn body inside-out
2750 : : // Author : Jason Kraftcheck
2751 : : // Date : 05/25/04
2752 : : //===============================================================================
2753 : 0 : CubitStatus FacetModifyEngine::reverse_body( BodySM* body_ptr )
2754 : : {
2755 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_FAILURE;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2756 : :
2757 [ # # ]: 0 : FacetBody* body = dynamic_cast<FacetBody*>(body_ptr);
2758 [ # # ]: 0 : if (0 == body)
2759 : : {
2760 [ # # ][ # # ]: 0 : PRINT_ERROR("Non-facet body in FME::reverse.\n");
[ # # ][ # # ]
2761 : 0 : return CUBIT_FAILURE;
2762 : : }
2763 : :
2764 : : // Flip CoFace senses
2765 [ # # ]: 0 : DLIList<FacetShell*> shells;
2766 [ # # ]: 0 : body->get_shells( shells );
2767 [ # # ][ # # ]: 0 : while (shells.size())
2768 [ # # ][ # # ]: 0 : shells.pop()->reverse();
2769 : :
2770 [ # # ]: 0 : return CUBIT_SUCCESS;
2771 : : }
2772 : :
2773 : :
2774 : :
2775 : : //===============================================================================
2776 : : // Function : split_periodic
2777 : : // Member Type: PUBLIC
2778 : : // Description:
2779 : : // Author : John Fowler
2780 : : // Date : 10/02
2781 : : //===============================================================================
2782 : 0 : CubitStatus FacetModifyEngine::split_periodic( BodySM * /*body_ptr*/,
2783 : : BodySM *& /*new_body*/ )
2784 : : {
2785 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2786 : 0 : return CUBIT_FAILURE;
2787 : : }
2788 : :
2789 : : //===============================================================================
2790 : : // Function : regularize_body
2791 : : // Member Type: PUBLIC
2792 : : // Description:
2793 : : // Author : John Fowler
2794 : : // Date : 10/02
2795 : : //===============================================================================
2796 : 0 : CubitStatus FacetModifyEngine::regularize_body( BodySM * /*body_ptr*/,
2797 : : BodySM *& /*new_body_ptr*/ )
2798 : : {
2799 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2800 : 0 : return CUBIT_FAILURE;
2801 : : }
2802 : :
2803 : : //===============================================================================
2804 : : // Function : regularize_refentity
2805 : : // Member Type: PUBLIC
2806 : : // Description:
2807 : : // Author : John Fowler
2808 : : // Date : 10/02
2809 : : //===============================================================================
2810 : 0 : CubitStatus FacetModifyEngine::regularize_entity( GeometryEntity * /*old_entity_ptr*/,
2811 : : BodySM *& /*new_body_ptr*/)
2812 : : {
2813 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2814 : 0 : return CUBIT_FAILURE;
2815 : : }
2816 : :
2817 : 0 : CubitStatus FacetModifyEngine::test_regularize_entity( GeometryEntity *)
2818 : : {
2819 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2820 : 0 : return CUBIT_FAILURE;
2821 : : }
2822 : :
2823 : : //===============================================================================
2824 : : // Function : offset_curves
2825 : : // Member Type: PUBLIC
2826 : : // Description:
2827 : : // Author : John Fowler
2828 : : // Date : 10/02
2829 : : //===============================================================================
2830 : 0 : CubitStatus FacetModifyEngine::offset_curves( DLIList<Curve*>& /*ref_edge_list*/,
2831 : : DLIList<Curve*>&,
2832 : : double /*offset_distance*/,
2833 : : const CubitVector& /*offset_direction*/,
2834 : : int /*gap_type*/ )
2835 : : {
2836 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2837 : 0 : return CUBIT_FAILURE;
2838 : : }
2839 : :
2840 : : //===============================================================================
2841 : : // Function : split_curve
2842 : : // Member Type: PUBLIC
2843 : : // Description:
2844 : : // Author : Alex Hays
2845 : : // Date : 9/08
2846 : : //===============================================================================
2847 : 0 : CubitStatus FacetModifyEngine::split_curve( Curve* curve_to_split,
2848 : : const CubitVector& split_location,
2849 : : DLIList<Curve*>& created_curves )
2850 : : {
2851 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2852 : 0 : return CUBIT_FAILURE;
2853 : : }
2854 : :
2855 : : //===============================================================================
2856 : : // Function : trim_curve
2857 : : // Member Type: PUBLIC
2858 : : // Description:
2859 : : // Author : John Fowler
2860 : : // Date : 10/02
2861 : : //===============================================================================
2862 : 0 : Curve* FacetModifyEngine::trim_curve( Curve* /*trim_curve*/,
2863 : : const CubitVector& /*trim_vector*/,
2864 : : const CubitVector& /*keep_vector*/,
2865 : : bool )
2866 : : {
2867 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
2868 : 0 : return 0;
2869 : : }
2870 : :
2871 : : //===============================================================================
2872 : : // Function : create_solid_bodies_from_surfs
2873 : : // Member Type: PUBLIC
2874 : : // Description:
2875 : : // Author : Steve Owen
2876 : : // Date : 9/11/03
2877 : : //===============================================================================
2878 : 0 : CubitStatus FacetModifyEngine::create_solid_bodies_from_surfs(DLIList<Surface*> & ref_face_list,
2879 : : DLIList<BodySM*> &new_bodies,
2880 : : bool keep_old,
2881 : : bool heal,
2882 : : bool sheet ) const
2883 : : {
2884 : : //MODIFY_CHECK_RETURN_FAILURE;
2885 : :
2886 : : // get the facets from the faces
2887 : :
2888 : : int ii;
2889 : : Surface *surf_ptr;
2890 : : FacetSurface *fsurf_ptr;
2891 [ # # ]: 0 : DLIList<CubitFacet *> facet_list;
2892 [ # # ][ # # ]: 0 : DLIList<CubitPoint *> point_list;
2893 : :
2894 [ # # ]: 0 : if (heal)
2895 : : {
2896 [ # # ][ # # ]: 0 : PRINT_WARNING("\"heal\" option for facet-based geometry is not supported.\n");
[ # # ][ # # ]
2897 : : }
2898 : :
2899 [ # # ]: 0 : ref_face_list.reset();
2900 [ # # ][ # # ]: 0 : for(ii=0; ii<ref_face_list.size(); ii++)
2901 : : {
2902 [ # # ]: 0 : surf_ptr = ref_face_list.get_and_step();
2903 [ # # ]: 0 : fsurf_ptr = dynamic_cast<FacetSurface *>(surf_ptr);
2904 [ # # ]: 0 : assert(fsurf_ptr != NULL);
2905 [ # # ]: 0 : if (fsurf_ptr == NULL)
2906 : 0 : return CUBIT_FAILURE;
2907 [ # # ]: 0 : point_list.clean_out();
2908 [ # # ]: 0 : fsurf_ptr->get_my_facets( facet_list, point_list );
2909 : : }
2910 : :
2911 : : // copy the facets
2912 : :
2913 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> new_facet_list;
2914 [ # # ][ # # ]: 0 : DLIList<CubitPoint *> new_point_list;
2915 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge *> new_edge_list;
2916 [ # # ]: 0 : FacetDataUtil::copy_facets( facet_list, new_facet_list, new_point_list, new_edge_list );
2917 : :
2918 : : // generate new geometry
2919 : :
2920 : 0 : const char *file_name = NULL;
2921 : 0 : CubitBoolean use_feature_angle = CUBIT_FALSE;
2922 : 0 : double feature_angle = 0.0;
2923 : 0 : int interp_order = 0;
2924 : 0 : double tol=0.0;
2925 : 0 : CubitBoolean smooth_non_manifold = CUBIT_FALSE;
2926 : 0 : CubitBoolean split_surfaces = CUBIT_FALSE;
2927 : 0 : CubitBoolean stitch = CUBIT_TRUE;
2928 : 0 : CubitBoolean improve = CUBIT_TRUE;
2929 [ # # ][ # # ]: 0 : DLIList <CubitQuadFacet *> quad_facet_list;
2930 [ # # ][ # # ]: 0 : DLIList<Surface *> surface_list;
2931 : 0 : FacetFileFormat file_format = FROM_FACET_LIST;
2932 : : CubitStatus rv =
2933 : : FacetQueryEngine::instance()->import_facets( file_name,
2934 : : use_feature_angle,
2935 : : feature_angle,
2936 : : tol,
2937 : : interp_order,
2938 : : smooth_non_manifold,
2939 : : split_surfaces,
2940 : : stitch,
2941 : : improve,
2942 : : quad_facet_list,
2943 : : new_facet_list,
2944 : : surface_list,
2945 [ # # ][ # # ]: 0 : file_format );
2946 : :
2947 : 0 : BodySM *new_body = NULL;
2948 [ # # ]: 0 : if (rv == CUBIT_SUCCESS)
2949 : : {
2950 [ # # ]: 0 : surf_ptr = surface_list.get();
2951 [ # # ]: 0 : new_body = surf_ptr->bodysm();
2952 : :
2953 [ # # ]: 0 : if( sheet == false )
2954 : : {
2955 [ # # ]: 0 : CubitVector centroid;
2956 : 0 : double volume = 0.0;
2957 [ # # ]: 0 : new_body->mass_properties( centroid, volume);
2958 [ # # ]: 0 : if( volume <= 0.0 )
2959 : : {
2960 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(new_body);
2961 [ # # ][ # # ]: 0 : PRINT_INFO("Failing...Resulting body has no volume.\n");
[ # # ][ # # ]
2962 : 0 : return CUBIT_FAILURE;
2963 : : }
2964 : : }
2965 : :
2966 : : // delete the old model
2967 : :
2968 [ # # ]: 0 : if (!keep_old)
2969 : : {
2970 [ # # ]: 0 : DLIList<BodySM*> mybody_list;
2971 [ # # ][ # # ]: 0 : DLIList<BodySM*> body_list;
2972 [ # # ][ # # ]: 0 : for(ii=0; ii<ref_face_list.size(); ii++)
2973 : : {
2974 [ # # ]: 0 : mybody_list.clean_out();
2975 [ # # ]: 0 : surf_ptr = ref_face_list.get_and_step();
2976 [ # # ]: 0 : surf_ptr->bodysms(mybody_list);
2977 [ # # ][ # # ]: 0 : if (mybody_list.size() == 1)
2978 : : {
2979 [ # # ][ # # ]: 0 : body_list.append_unique( mybody_list.get() );
2980 : : }
2981 : : }
2982 [ # # ][ # # ]: 0 : if (body_list.size() > 0)
2983 : : {
2984 [ # # ][ # # ]: 0 : FacetQueryEngine::instance()->delete_solid_model_entities(body_list);
2985 : : //GeometryQueryTool::instance()->delete_Body( body_list );
2986 [ # # ]: 0 : }
2987 : : }
2988 : : }
2989 : : else
2990 : : {
2991 : 0 : new_body = NULL;
2992 : : }
2993 : :
2994 [ # # ]: 0 : if( new_body )
2995 [ # # ]: 0 : new_bodies.append( new_body );
2996 : :
2997 [ # # ]: 0 : return CUBIT_SUCCESS;
2998 : : }
2999 : :
3000 : :
3001 : : //===============================================================================
3002 : : // Function : create_circle
3003 : : // Member Type: PUBLIC
3004 : : // Description:
3005 : : // Author : Corey McBride
3006 : : // Date : 1/11
3007 : : //===============================================================================
3008 : 0 : Curve* FacetModifyEngine::create_arc(const CubitVector& position,
3009 : : double radius,
3010 : : double start_angle,
3011 : : double end_angle,
3012 : : CubitVector plane,
3013 : : bool preview )
3014 : : {
3015 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3016 : :
3017 : 0 : return NULL;
3018 : :
3019 : : }
3020 : : //===============================================================================
3021 : : // Function : create_circle
3022 : : // Member Type: PUBLIC
3023 : : // Description:
3024 : : // Author : Corey McBride
3025 : : // Date : 4/11
3026 : : //===============================================================================
3027 : 0 : Curve* FacetModifyEngine::create_arc_radius(const CubitVector ¢er,
3028 : : TBPoint* ref_vertex_start,
3029 : : TBPoint* ref_vertex_end,
3030 : : const CubitVector &normal,
3031 : : double radius,
3032 : : bool full,
3033 : : bool preview)
3034 : : {
3035 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3036 : :
3037 : 0 : return NULL;
3038 : :
3039 : : }
3040 : :
3041 : : //===============================================================================
3042 : : // Function : create_arc_three
3043 : : // Member Type: PUBLIC
3044 : : // Description:
3045 : : // Author : John Fowler
3046 : : // Date : 10/02
3047 : : //===============================================================================
3048 : 0 : Curve* FacetModifyEngine::create_arc_three( TBPoint* /*ref_vertex1*/,
3049 : : TBPoint* /*ref_vertex2*/,
3050 : : TBPoint* /*ref_vertex3*/,
3051 : : bool /*full*/,
3052 : : bool /*preview*/ )
3053 : : {
3054 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3055 : :
3056 : 0 : return NULL;
3057 : :
3058 : : }
3059 : :
3060 : : //===============================================================================
3061 : : // Function : create_arc_three
3062 : : // Member Type: PUBLIC
3063 : : // Description:
3064 : : // Author : John Fowler
3065 : : // Date : 10/02
3066 : : //===============================================================================
3067 : 0 : Curve* FacetModifyEngine::create_arc_three( Curve* /*ref_edge1*/,
3068 : : Curve* /*ref_edge2*/,
3069 : : Curve* /*ref_edge3*/,
3070 : : bool /*full*/,
3071 : : bool /*preview*/ )
3072 : : {
3073 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3074 : :
3075 : 0 : return NULL;
3076 : : }
3077 : :
3078 : : //===============================================================================
3079 : : // Function : create_arc_center_edge
3080 : : // Member Type: PUBLIC
3081 : : // Description:
3082 : : // Author : John Fowler
3083 : : // Date : 10/02
3084 : : //===============================================================================
3085 : 0 : Curve* FacetModifyEngine::create_arc_center_edge( TBPoint* /*ref_vertex1*/,
3086 : : TBPoint* /*ref_vertex2*/,
3087 : : TBPoint* /*ref_vertex3*/,
3088 : : const CubitVector& /*normal*/,
3089 : : double /*radius*/,
3090 : : bool /*full*/,
3091 : : bool /*preview*/ )
3092 : : {
3093 [ # # ][ # # ]: 0 : MODIFY_CHECK_RETURN_NULL;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3094 : :
3095 : 0 : return NULL;
3096 : : }
3097 : :
3098 : : CubitStatus
3099 : 0 : FacetModifyEngine::create_curve_combine( DLIList<Curve*>& curve_list,
3100 : : Curve *&new_curve_ptr )
3101 : : {
3102 [ # # ][ # # ]: 0 : PRINT_ERROR("Curve combine is not implemented for facet based models\n");
3103 : 0 : return CUBIT_FAILURE;
3104 : : }
3105 : :
3106 : : //===============================================================================
3107 : : // Function : get_gqe
3108 : : // Member Type: PUBLIC
3109 : : // Description: get the facet geometry query engince instance pointer
3110 : : // Author : John Fowler
3111 : : // Date : 10/02
3112 : : //===============================================================================
3113 : 22 : GeometryQueryEngine *FacetModifyEngine::get_gqe()
3114 : : {
3115 : 22 : return FacetQueryEngine::instance();
3116 : : }
3117 : :
3118 : : //===============================================================================
3119 : : // Function : is_modify_engine
3120 : : // Member Type: PUBLIC
3121 : : // Description: return CUBIT_TRUE if the tb_ptr belongs to this modify engine
3122 : : // Author : John Fowler
3123 : : // Date : 10/02
3124 : : //===============================================================================
3125 : 0 : CubitBoolean FacetModifyEngine::is_modify_engine(const TopologyBridge *tb_ptr) const
3126 : : {
3127 : 0 : return tb_ptr->get_geometry_query_engine() == FacetQueryEngine::instance();
3128 : : }
3129 : :
3130 : : //===============================================================================
3131 : : // Function : get_offset_intersections
3132 : : // Member Type: PUBLIC
3133 : : // Description:
3134 : : // Author : John Fowler
3135 : : // Date : 10/02
3136 : : //===============================================================================
3137 : 0 : CubitStatus FacetModifyEngine::get_offset_intersections( Curve* /*ref_edge1*/,
3138 : : Curve* /*ref_edge2*/,
3139 : : DLIList<CubitVector>& /*intersection_list*/,
3140 : : double /*offset*/,
3141 : : CubitBoolean /*ext_first*/ )
3142 : : {
3143 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3144 : 0 : return CUBIT_FAILURE;
3145 : : }
3146 : :
3147 : : //===============================================================================
3148 : : // Function : get_offset_intersections
3149 : : // Member Type: PUBLIC
3150 : : // Description:
3151 : : // Author : John Fowler
3152 : : // Date : 10/02
3153 : : //===============================================================================
3154 : 0 : CubitStatus FacetModifyEngine::get_offset_intersections( Curve* /*ref_edge_ptr*/,
3155 : : Surface* /*ref_face_ptr*/,
3156 : : DLIList<CubitVector> & /*intersection_list*/,
3157 : : double /*offset*/,
3158 : : CubitBoolean /*ext_surf*/ )
3159 : : {
3160 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3161 : 0 : return CUBIT_FAILURE;
3162 : : }
3163 : :
3164 : : //===============================================================================
3165 : : // Function : surface_intersection
3166 : : // Member Type: PUBLIC
3167 : : // Description:
3168 : : // Author : John Fowler
3169 : : // Date : 10/02
3170 : : //===============================================================================
3171 : 0 : CubitStatus FacetModifyEngine::surface_intersection( Surface * /*surface1_ptr*/,
3172 : : Surface * /*surface2_ptr*/,
3173 : : DLIList<Curve*> &/*inter_graph*/,
3174 : : const double /*tol*/) const
3175 : : {
3176 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3177 : 0 : return CUBIT_FAILURE;
3178 : : }
3179 : :
3180 : : //===============================================================================
3181 : : // Function : get_mid_plane
3182 : : // Member Type: PUBLIC
3183 : : // Description:
3184 : : // Author : John Fowler
3185 : : // Date : 10/02
3186 : : //===============================================================================
3187 : 0 : CubitStatus FacetModifyEngine::get_mid_plane( const CubitVector & /*point_1*/,
3188 : : const CubitVector & /*point_2*/,
3189 : : const CubitVector & /*point_3*/,
3190 : : BodySM * /*body_to_trim_to*/,
3191 : : BodySM *& /*midplane_body*/ ) const
3192 : : {
3193 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3194 : 0 : return CUBIT_FAILURE;
3195 : : }
3196 : :
3197 : : //===============================================================================
3198 : : // Function : get_quadric_mid_surface
3199 : : // Member Type: PUBLIC
3200 : : // Description:
3201 : : // Author : Philippe Pebay
3202 : : // Date : 03/06
3203 : : //===============================================================================
3204 : 0 : CubitStatus FacetModifyEngine::get_spheric_mid_surface( Surface* surface_ptr1,
3205 : : Surface* surface_ptr2,
3206 : : BodySM* body_to_trim_to,
3207 : : BodySM*& midsurface_body ) const
3208 : : {
3209 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3210 : 0 : return CUBIT_FAILURE;
3211 : : }
3212 : :
3213 : : //===============================================================================
3214 : : // Function : get_quadric_mid_surface
3215 : : // Member Type: PUBLIC
3216 : : // Description:
3217 : : // Author : Philippe Pebay
3218 : : // Date : 03/06
3219 : : //===============================================================================
3220 : 0 : CubitStatus FacetModifyEngine::get_conic_mid_surface( Surface* surface_ptr1,
3221 : : Surface* surface_ptr2,
3222 : : BodySM* body_to_trim_to,
3223 : : BodySM*& midsurface_body ) const
3224 : : {
3225 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3226 : 0 : return CUBIT_FAILURE;
3227 : : }
3228 : :
3229 : : //===============================================================================
3230 : : // Function : get_quadric_mid_surface
3231 : : // Member Type: PUBLIC
3232 : : // Description:
3233 : : // Author : Philippe Pebay
3234 : : // Date : 03/06
3235 : : //===============================================================================
3236 : 0 : CubitStatus FacetModifyEngine::get_toric_mid_surface( Surface* surface_ptr1,
3237 : : Surface* surface_ptr2,
3238 : : BodySM* body_to_trim_to,
3239 : : BodySM*& midsurface_body ) const
3240 : : {
3241 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3242 : 0 : return CUBIT_FAILURE;
3243 : : }
3244 : :
3245 : : //=============================================================================
3246 : : // Function : tweak_bend
3247 : : // Member Type: PUBLIC
3248 : : // Description: Bend solid bodies based on a bend radius and angle
3249 : : // Author :
3250 : : // Date :
3251 : : //=============================================================================
3252 : 0 : CubitStatus FacetModifyEngine::tweak_bend(DLIList<BodySM*>& bend_bodies,
3253 : : DLIList<BodySM*>& new_bodysm_list,
3254 : : CubitVector& neutral_root,
3255 : : CubitVector& bend_axis,
3256 : : CubitVector& bend_direction,
3257 : : double radius,
3258 : : double angle,
3259 : : DLIList<CubitVector> &bend_regions,
3260 : : double width,
3261 : : CubitBoolean center_bend,
3262 : : int num_points,
3263 : : CubitBoolean keep_old_body,
3264 : : CubitBoolean preview ) const
3265 : : {
3266 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3267 : 0 : return CUBIT_FAILURE;
3268 : : }
3269 : :
3270 : : //=============================================================================
3271 : : // Function : tweak_chamfer
3272 : : // Member Type: PUBLIC
3273 : : // Description: Chamfer curves on solid bodies. The left and right offsets are
3274 : : // with respect to the curve direction. If the given right offset
3275 : : // is negative, the left offset is used. Users can preview to
3276 : : // clarify the meaning of left and right.
3277 : : // Author :
3278 : : // Date :
3279 : : //=============================================================================
3280 : 0 : CubitStatus FacetModifyEngine::tweak_chamfer( DLIList<Curve*> & /*curve_list*/,
3281 : : double /*left_offset*/,
3282 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3283 : : double /*right_offset*/,
3284 : : CubitBoolean /*keep_old_body*/,
3285 : : CubitBoolean /*preview*/ ) const
3286 : : {
3287 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3288 : 0 : return CUBIT_FAILURE;
3289 : : }
3290 : :
3291 : : //=============================================================================
3292 : : // Function : tweak_chamfer
3293 : : // Member Type: PUBLIC
3294 : : // Description: Chamfer vertices on solid or sheet bodies. On a solid body
3295 : : // there can be up to 3 offsets; on a sheet body up to 2 offsets.
3296 : : // The offsets are in the direction of the supplied edges. If
3297 : : // multiple vertices are supplied, only one offset value is
3298 : : // allowed and the edges are not used.
3299 : : // Author :
3300 : : // Date :
3301 : : //=============================================================================
3302 : : CubitStatus
3303 : 0 : FacetModifyEngine::tweak_chamfer( DLIList<TBPoint*> & /*point_list*/,
3304 : : double /*offset1*/,
3305 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3306 : : Curve * /*edge1*/,
3307 : : double /*offset2*/,
3308 : : Curve * /*edge2*/,
3309 : : double /*offset3*/,
3310 : : Curve * /*edge3*/,
3311 : : CubitBoolean /*keep_old_body*/,
3312 : : CubitBoolean /*preview*/ ) const
3313 : : {
3314 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3315 : 0 : return CUBIT_FAILURE;
3316 : : }
3317 : :
3318 : : //=============================================================================
3319 : : // Function : tweak_fillet
3320 : : // Member Type: PUBLIC
3321 : : // Description: Create a round fillet (or blend) at the given curves on solid
3322 : : // bodies.
3323 : : // Author :
3324 : : // Date :
3325 : : //=============================================================================
3326 : 0 : CubitStatus FacetModifyEngine::tweak_fillet( DLIList<Curve*> & /*curve_list*/,
3327 : : double /*radius*/,
3328 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3329 : : CubitBoolean /*keep_old_body*/,
3330 : : CubitBoolean /*preview*/ ) const
3331 : : {
3332 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3333 : 0 : return CUBIT_FAILURE;
3334 : : }
3335 : :
3336 : : //=============================================================================
3337 : : // Function : tweak_fillet
3338 : : // Member Type: PUBLIC
3339 : : // Description: Create a round fillet (or blend) at the given curves on a solid
3340 : : // body. The fillet has a variable radius from the start to the
3341 : : // end of the curve.
3342 : : // Author :
3343 : : // Date :
3344 : : //=============================================================================
3345 : 0 : CubitStatus FacetModifyEngine::tweak_fillet( Curve * /*curve_ptr*/,
3346 : : double /*start_radius*/,
3347 : : double /*end_radius*/,
3348 : : BodySM *& /*new_bodysm_ptr*/,
3349 : : CubitBoolean /*keep_old_body*/,
3350 : : CubitBoolean /*preview*/ ) const
3351 : : {
3352 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3353 : 0 : return CUBIT_FAILURE;
3354 : : }
3355 : :
3356 : : //=============================================================================
3357 : : // Function : tweak_fillet
3358 : : // Member Type: PUBLIC
3359 : : // Description: Create a round fillet (or blend) at the given vertices on sheet
3360 : : // bodies.
3361 : : // Author :
3362 : : // Date :
3363 : : //=============================================================================
3364 : : CubitStatus
3365 : 0 : FacetModifyEngine::tweak_fillet( DLIList<TBPoint*> & /*ref_vertex_list*/,
3366 : : double /*radius*/,
3367 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3368 : : CubitBoolean /*keep_old_body*/,
3369 : : CubitBoolean /*preview*/ ) const
3370 : : {
3371 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3372 : 0 : return CUBIT_FAILURE;
3373 : : }
3374 : :
3375 : : //=============================================================================
3376 : : // Function : tweak_move
3377 : : // Member Type: PUBLIC
3378 : : // Description: Tweak specified faces of a volume or volumes along a vector.
3379 : : // Author :
3380 : : // Date :
3381 : : //=============================================================================
3382 : 0 : CubitStatus FacetModifyEngine::tweak_move( DLIList<Surface*> & /*surface_list*/,
3383 : : const CubitVector & /*delta*/,
3384 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3385 : : CubitBoolean /*keep_old_body*/,
3386 : : CubitBoolean /*preview*/ ) const
3387 : : {
3388 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3389 : 0 : return CUBIT_FAILURE;
3390 : : }
3391 : :
3392 : : //=============================================================================
3393 : : // Function : tweak_move
3394 : : // Member Type: PUBLIC
3395 : : // Description: Tweak specified curves of a sheet body along a vector.
3396 : : // Author :
3397 : : // Date :
3398 : : //=============================================================================
3399 : 0 : CubitStatus FacetModifyEngine::tweak_move( DLIList<Curve*> & /*curve_list*/,
3400 : : const CubitVector & /*delta*/,
3401 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3402 : : CubitBoolean /*keep_old_body*/,
3403 : : CubitBoolean /*preview*/ ) const
3404 : : {
3405 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3406 : 0 : return CUBIT_FAILURE;
3407 : : }
3408 : :
3409 : : //=============================================================================
3410 : : // Function : tweak_offset
3411 : : // Member Type: PUBLIC
3412 : : // Description: Tweak specified faces of a volume or volumes by offsetting
3413 : : // those faces by the offset distance.
3414 : : // Author :
3415 : : // Date :
3416 : : //=============================================================================
3417 : 0 : CubitStatus FacetModifyEngine::tweak_offset( DLIList<Surface*> & /*surface_list*/,
3418 : : double /*offset_distance*/,
3419 : : DLIList<Surface*> * /*add_surface_list_ptr*/,
3420 : : DLIList<double> * /*add_offset_list_ptr*/,
3421 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3422 : : CubitBoolean /*keep_old_body*/,
3423 : : CubitBoolean /*preview*/ ) const
3424 : : {
3425 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3426 : 0 : return CUBIT_FAILURE;
3427 : : }
3428 : :
3429 : : //=============================================================================
3430 : : // Function : tweak_offset
3431 : : // Member Type: PUBLIC
3432 : : // Description: Tweak specified curves of a sheet body or bodies by offsetting
3433 : : // those curves by the offset distance.
3434 : : // Author :
3435 : : // Date :
3436 : : //=============================================================================
3437 : 0 : CubitStatus FacetModifyEngine::tweak_offset( DLIList<Curve*> & /*curve_list*/,
3438 : : double /*offset_distance*/,
3439 : : DLIList<Curve*> * /*add_curve_list_ptr*/,
3440 : : DLIList<double> * /*add_offset_list_ptr*/,
3441 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3442 : : CubitBoolean /*keep_old_body*/,
3443 : : CubitBoolean /*preview*/ ) const
3444 : : {
3445 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3446 : 0 : return CUBIT_FAILURE;
3447 : : }
3448 : :
3449 : : //=============================================================================
3450 : : // Function : tweak_remove
3451 : : // Member Type: PUBLIC
3452 : : // Description: Function to remove surfaces from a body and then extend the
3453 : : // remaining surfaces to fill the gap or hole.
3454 : : // Author :
3455 : : // Date :
3456 : : //=============================================================================
3457 : 0 : CubitStatus FacetModifyEngine::tweak_remove( DLIList<Surface*> & /*surface_list*/,
3458 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3459 : : CubitBoolean /*extend_adjoining*/,
3460 : : CubitBoolean /*keep_old_body*/,
3461 : : CubitBoolean /*preview*/ ) const
3462 : : {
3463 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3464 : 0 : return CUBIT_FAILURE;
3465 : : }
3466 : :
3467 : : //=============================================================================
3468 : : // Function : tweak_remove
3469 : : // Member Type: PUBLIC
3470 : : // Description: Function to remove curves from a sheet body and then extend the
3471 : : // remaining curves or fill the gap or hole.
3472 : : // Author :
3473 : : // Date :
3474 : : //=============================================================================
3475 : 0 : CubitStatus FacetModifyEngine::tweak_remove( DLIList<Curve*> & /*curve_list*/,
3476 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3477 : : CubitBoolean /*keep_old_body*/,
3478 : : CubitBoolean /*preview*/ ) const
3479 : : {
3480 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3481 : 0 : return CUBIT_FAILURE;
3482 : : }
3483 : :
3484 : : //=============================================================================
3485 : : // Function : tweak_target
3486 : : // Member Type: PUBLIC
3487 : : // Description: Tweak specified faces of a volume or volumes up to a set of
3488 : : // target surfaces.
3489 : : // Author :
3490 : : // Date :
3491 : : //=============================================================================
3492 : 0 : CubitStatus FacetModifyEngine::tweak_target( DLIList<Surface*> & /*surface_list*/,
3493 : : DLIList<Surface*> & /*target_surf_list*/,
3494 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3495 : : CubitBoolean /*extend_flg*/,
3496 : : CubitPlane * /*limit_plane*/,
3497 : : CubitBoolean /*reverse_flg*/,
3498 : : CubitBoolean /*keep_old_body*/,
3499 : : CubitBoolean /*preview*/ ) const
3500 : : {
3501 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3502 : 0 : return CUBIT_FAILURE;
3503 : : }
3504 : :
3505 : : //=============================================================================
3506 : : // Function : tweak_target
3507 : : // Member Type: PUBLIC
3508 : : // Description: Tweak specified edges of a surface or set of surfaces (in sheet
3509 : : // bodies) up to a set of target surfaces.
3510 : : // Author :
3511 : : // Date :
3512 : : //=============================================================================
3513 : 0 : CubitStatus FacetModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/,
3514 : : DLIList<Surface*> & /*target_surf_list*/,
3515 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3516 : : CubitBoolean /*extend_flg*/,
3517 : : CubitPlane * /*limit_plane*/,
3518 : : CubitBoolean /*reverse_flg*/,
3519 : : CubitBoolean /*keep_old_body*/,
3520 : : CubitBoolean /*preview*/,
3521 : : double /*max_area_increase = 0*/ ) const
3522 : : {
3523 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3524 : 0 : return CUBIT_FAILURE;
3525 : : }
3526 : :
3527 : : //=============================================================================
3528 : : // Function : tweak_target
3529 : : // Member Type: PUBLIC
3530 : : // Description: Tweak specified edges of a sheet body or bodies up to a set of
3531 : : // target curves that is part of a sheet body. The target is a
3532 : : // set of surfaces created by thickening the owning surfaces of
3533 : : // the target curves.
3534 : : // Author :
3535 : : // Date :
3536 : : //=============================================================================
3537 : 0 : CubitStatus FacetModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/,
3538 : : DLIList<Curve*> & /*target_curve_list*/,
3539 : : DLIList<BodySM*> & /*new_bodysm_list*/,
3540 : : CubitBoolean /*extend_flg*/,
3541 : : CubitPlane * /*limit_plane*/,
3542 : : CubitBoolean /*reverse_flg*/,
3543 : : CubitBoolean /*keep_old_body*/,
3544 : : CubitBoolean /*preview*/,
3545 : : double /*max_area_increase = 0*/ ) const
3546 : : {
3547 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3548 : 0 : return CUBIT_FAILURE;
3549 : : }
3550 : :
3551 : : //=============================================================================
3552 : : // Function : tweak_target
3553 : : // Member Type: PUBLIC
3554 : : // Description: Tweak specified point of a sheet body to a given location. The
3555 : : // given point must be part of a planar surface or surfaces
3556 : : // attached to linear curves only. The user specified which of
3557 : : // those surfaces to actually modify. The given location will be
3558 : : // projected to be on the given planar surface(s) before being
3559 : : // used - this projected location must be the same on all surfaces.
3560 : : // Author :
3561 : : // Date :
3562 : : //=============================================================================
3563 : 0 : CubitStatus FacetModifyEngine::tweak_target( TBPoint * /*point_ptr*/,
3564 : : DLIList<Surface*> & /*modify_surface_list*/,
3565 : : CubitVector & /*target_loc*/,
3566 : : BodySM *& /*new_bodysm_ptr*/,
3567 : : CubitBoolean /*keep_old_body*/,
3568 : : CubitBoolean /*preview*/ ) const
3569 : : {
3570 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3571 : 0 : return CUBIT_FAILURE;
3572 : : }
3573 : :
3574 : 0 : CubitStatus FacetModifyEngine::remove_curve_slivers( BodySM* /*body*/,
3575 : : double /*lengthlimit*/ ) const
3576 : : {
3577 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
3578 : 0 : return CUBIT_FAILURE;
3579 : : }
3580 : :
3581 : : //================================================================================
3582 : : // Description: Creates a net surface.
3583 : : // Author : Tyronne Lim
3584 : : // Date : 08/18/03
3585 : : //================================================================================
3586 : 0 : CubitStatus FacetModifyEngine::create_net_surface( DLIList<Surface*>& /*ref_face_list*/,
3587 : : BodySM *& /*new_body*/,
3588 : : DLIList<DLIList<CubitVector*>*> & /*vec_lists_u*/,
3589 : : DLIList<DLIList<CubitVector*>*> & /*vec_lists_v*/,
3590 : : double /*net_tol*/,
3591 : : CubitBoolean /*heal*/ ) const
3592 : : {
3593 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3594 : 0 : return CUBIT_FAILURE;
3595 : : }
3596 : :
3597 : : //================================================================================
3598 : : // Description: Creates a net surface.
3599 : : // Author : Tyronne Lim
3600 : : // Date : 08/18/03
3601 : : //================================================================================
3602 : 0 : CubitStatus FacetModifyEngine::create_net_surface( DLIList<Curve*>& /*u_curves*/,
3603 : : DLIList<Curve*>& /*v_curves*/,
3604 : : BodySM *& /*new_body*/,
3605 : : double /*net_tol*/,
3606 : : CubitBoolean /*heal*/ ) const
3607 : : {
3608 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3609 : 0 : return CUBIT_FAILURE;
3610 : : }
3611 : :
3612 : : //================================================================================
3613 : : // Description: Creates an offset surface.
3614 : : // Author : Tyronne Lim
3615 : : // Date : 08/18/03
3616 : : //================================================================================
3617 : 0 : CubitStatus FacetModifyEngine::create_offset_surface( Surface* /*ref_face_ptr*/,
3618 : : BodySM*& /*new_body*/,
3619 : : double /*offset_distance*/ ) const
3620 : : {
3621 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in Facet engine.\n");
3622 : 0 : return CUBIT_FAILURE;
3623 : : }
3624 : :
3625 : : //================================================================================
3626 : : // Description: Creates an offset sheet.
3627 : : // Author :
3628 : : // Date :
3629 : : //================================================================================
3630 : : CubitStatus
3631 : 0 : FacetModifyEngine::create_offset_sheet( DLIList<Surface*> & /*surface_list*/,
3632 : : double /*offset_distance*/,
3633 : : DLIList<Surface*> * /*add_surface_list_ptr*/,
3634 : : DLIList<double> * /*add_offset_list_ptr*/,
3635 : : DLIList<BodySM*> & /*new_body_list*/,
3636 : : CubitBoolean /*preview*/ ) const
3637 : : {
3638 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in Facet engine.\n");
3639 : 0 : return CUBIT_FAILURE;
3640 : : }
3641 : :
3642 : : //================================================================================
3643 : : // Description: Creates an offset body.
3644 : : // Author : Tyronne Lim
3645 : : // Date : 08/18/03
3646 : : //================================================================================
3647 : 0 : CubitStatus FacetModifyEngine::create_offset_body( BodySM* body_ptr,
3648 : : BodySM*& new_bodysm,
3649 : : double offset_distance ) const
3650 : : {
3651 : : return FacetModifyEngine::instance()->
3652 : 0 : create_shell_offset( body_ptr, new_bodysm, offset_distance );
3653 : : }
3654 : :
3655 : : //================================================================================
3656 : : // Description: Creates a skin surface.
3657 : : // Author : Tyronne Lim
3658 : : // Date : 08/18/03
3659 : : //================================================================================
3660 : 0 : CubitStatus FacetModifyEngine::create_skin_surface( DLIList<Curve*>& /*curves*/,
3661 : : BodySM*& /*new_body*/,
3662 : : DLIList<Curve*>& /*guides*/) const
3663 : : {
3664 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3665 : 0 : return CUBIT_FAILURE;
3666 : : }
3667 : :
3668 : : //
3669 : : ////================================================================================
3670 : : //// Description: Creates a body from lofting surfaces.
3671 : : //// Author : Corey McBride
3672 : : //// Date : 02/7/11
3673 : : ////================================================================================
3674 : 0 : CubitStatus FacetModifyEngine::loft_surfaces_to_body( DLIList<Surface*> &surfaces,
3675 : : DLIList<double> &takeoff_factor_list,
3676 : : DLIList<Surface*> &takeoff_vector_surface_list,
3677 : : DLIList<CubitVector> &surface_takeoff_vector_list,
3678 : : DLIList<Curve*> &takeoff_vector_curve_list,
3679 : : DLIList<CubitVector> &curve_takeoff_vector_list,
3680 : : DLIList<Curve*> &guides,
3681 : : DLIList<TBPoint*> &match_vertices_list,
3682 : : BodySM*& new_body,
3683 : : CubitBoolean global_guides,
3684 : : CubitBoolean closed,
3685 : : CubitBoolean show_matching_curves,
3686 : : CubitBoolean preview
3687 : : )const
3688 : : {
3689 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3690 : 0 : return CUBIT_FAILURE;
3691 : : }
3692 : :
3693 : :
3694 : : //================================================================================
3695 : : // Description: Creates a surface.
3696 : : // Author : Tyronne Lim
3697 : : // Date : 08/18/03
3698 : : //================================================================================
3699 : 0 : CubitStatus FacetModifyEngine::create_surface( DLIList<CubitVector*>& /*vec_list*/,
3700 : : BodySM *& /*new_body*/,
3701 : : Surface * /*ref_face_ptr*/,
3702 : : CubitBoolean /*project_points*/ ) const
3703 : : {
3704 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3705 : 0 : return CUBIT_FAILURE;
3706 : : }
3707 : :
3708 : 0 : CubitStatus FacetModifyEngine::create_surface( DLIList<TBPoint*> & /*points*/,
3709 : : BodySM *& /*new_body*/,
3710 : : Surface * /*on_surface*/) const
3711 : : {
3712 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3713 : 0 : return CUBIT_FAILURE;
3714 : : }
3715 : :
3716 : : //================================================================================
3717 : : // Description: Creates a weld surface.
3718 : : // Author : Tyronne Lim
3719 : : // Date : 08/18/03
3720 : : //================================================================================
3721 : 0 : CubitStatus FacetModifyEngine::create_weld_surface( CubitVector & /*root*/,
3722 : : Surface * /*ref_face1*/,
3723 : : double /*leg1*/,
3724 : : Surface * /*ref_face2*/,
3725 : : double /*leg2*/,
3726 : : BodySM *& /*new_body*/ ) const
3727 : : {
3728 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3729 : 0 : return CUBIT_FAILURE;
3730 : : }
3731 : :
3732 : :
3733 : 0 : CubitStatus FacetModifyEngine::stitch( DLIList<BodySM*> &bodies_to_stitch,
3734 : : DLIList<BodySM*> &new_bodies,
3735 : : bool tighten_gaps,
3736 : : double tolerance )const
3737 : : {
3738 [ # # ][ # # ]: 0 : PRINT_ERROR("Function not implemented in this engine.\n");
3739 : 0 : return CUBIT_FAILURE;
3740 : : }
3741 : :
3742 : :
3743 : : //================================================================================
3744 : : // Facet-based geometry entities
3745 : : // Methods for building specific facet-based geometry entities
3746 : : //================================================================================
3747 : :
3748 : : //================================================================================
3749 : : // Function : make_facet_point
3750 : : // Member Type: PUBLIC
3751 : : // Description: create a new facet point given a pointer to the
3752 : : // associated CubitPoint
3753 : : // Author : sjowen
3754 : : // Date : 12/28/00
3755 : : //================================================================================
3756 : 418 : CubitStatus FacetModifyEngine::make_facet_point( CubitPoint *thePoint,
3757 : : TBPoint *&new_point_ptr )
3758 : : {
3759 : : //MODIFY_CHECK_RETURN_FAILURE;
3760 : :
3761 : : //We don't know in this function what to attach it to, so do that later.
3762 [ + - ]: 418 : DLIList<Curve*> curves;
3763 : :
3764 [ + - ][ + - ]: 418 : FacetPoint *new_facet_point = new FacetPoint( thePoint, curves );
3765 : :
3766 : 418 : new_point_ptr = (TBPoint*) new_facet_point;
3767 : :
3768 [ + - ]: 418 : return CUBIT_SUCCESS;
3769 : : }
3770 : :
3771 : : //================================================================================
3772 : : // Function : make_facet_point
3773 : : // Member Type: PUBLIC
3774 : : // Description: create a new facet point given its location
3775 : : // Author : sjowen
3776 : : // Date : 12/6/00
3777 : : //================================================================================
3778 : 0 : CubitStatus FacetModifyEngine::make_facet_point( const CubitVector &location,
3779 : : TBPoint *&new_point_ptr )
3780 : : {
3781 : : // MODIFY_CHECK_RETURN_FAILURE;
3782 : :
3783 : : //We don't know in this function what to attach it to, so do that later.
3784 [ # # ]: 0 : DLIList<Curve*> curves;
3785 : :
3786 [ # # ][ # # ]: 0 : FacetPoint *new_facet_point = new FacetPoint( location, curves );
3787 : :
3788 : 0 : new_point_ptr = (TBPoint*) new_facet_point;
3789 : :
3790 [ # # ]: 0 : return CUBIT_SUCCESS;
3791 : : }
3792 : :
3793 : : //================================================================================
3794 : : // Function : make_facet_curve
3795 : : // Member Type: PUBLIC
3796 : : // Description: create a new facet curve
3797 : : // (Assumes the curve will have an associated parent surface.
3798 : : // Evaluations will be done on the surface -- uses the same
3799 : : // order evaluations as the surface)
3800 : : // Author : sjowen
3801 : : // Date : 12/6/00
3802 : : //================================================================================
3803 : 594 : CubitStatus FacetModifyEngine::make_facet_curve( TBPoint *start_ptr,
3804 : : TBPoint *end_ptr,
3805 : : Curve *&new_curve_ptr,
3806 : : CurveFacetEvalTool *eval_tool_ptr)
3807 : : {
3808 : : //MODIFY_CHECK_RETURN_FAILURE;
3809 : :
3810 : :
3811 : : //We don't know in this function what to attach it to, so do that later.
3812 [ + - ]: 594 : DLIList<CoEdgeSM*> coedgesms;
3813 : :
3814 : : FacetCurve *new_facet_curv = new FacetCurve( eval_tool_ptr, start_ptr,
3815 [ + - ][ + - ]: 594 : end_ptr, coedgesms );
3816 : 594 : new_curve_ptr = (Curve*) new_facet_curv;
3817 : :
3818 [ - + ]: 594 : FacetPoint *facet_start_point = CAST_TO( start_ptr, FacetPoint );
3819 [ - + ]: 594 : FacetPoint *facet_end_point = CAST_TO( end_ptr, FacetPoint );
3820 [ + - ]: 594 : facet_start_point->add_curve( new_curve_ptr );
3821 [ + - ]: 594 : facet_end_point->add_curve( new_curve_ptr );
3822 : :
3823 [ + - ]: 594 : return CUBIT_SUCCESS;
3824 : : }
3825 : :
3826 : : //================================================================================
3827 : : // Function : make_facet_curve
3828 : : // Member Type: PUBLIC
3829 : : // Description: create a new facet curve given its edge facets
3830 : : // (this can be used for generating a facet curve representation
3831 : : // that does not have a parent surface associated -- currently
3832 : : // only linear evaluations are possible)
3833 : : // Author : sjowen
3834 : : // Date : 2/17/01
3835 : : //================================================================================
3836 : 0 : CubitStatus FacetModifyEngine::make_facet_curve(
3837 : : TBPoint *start_ptr, // endpoints on the curve
3838 : : TBPoint *end_ptr,
3839 : : DLIList<CubitFacetEdge*> &edge_list, // the ordered facet edges on this curve
3840 : : DLIList<CubitPoint*> &point_list, // the ordered points on this curve
3841 : : Curve *&new_curve_ptr, // return the new curve pointer
3842 : : CurveFacetEvalTool *curve_facet_tool )
3843 : : {
3844 : : //MODIFY_CHECK_RETURN_FAILURE;
3845 : :
3846 [ # # ]: 0 : if ( curve_facet_tool == NULL )
3847 : : {
3848 [ # # ][ # # ]: 0 : curve_facet_tool = new CurveFacetEvalTool;
3849 [ # # ]: 0 : CubitStatus status = curve_facet_tool->initialize( edge_list, point_list );
3850 [ # # ]: 0 : if ( status != CUBIT_SUCCESS )
3851 : : {
3852 : 0 : return status;
3853 : : }
3854 : : }
3855 [ # # ]: 0 : if (!curve_facet_tool)
3856 : 0 : return CUBIT_FAILURE;
3857 : :
3858 : : //We don't know in this function what to attach it to, so do that later.
3859 [ # # ]: 0 : DLIList<CoEdgeSM*> coedgesms;
3860 : :
3861 : : FacetCurve *new_facet_curv = new FacetCurve( curve_facet_tool, start_ptr,
3862 [ # # ][ # # ]: 0 : end_ptr, coedgesms );
3863 : 0 : new_curve_ptr = (Curve*) new_facet_curv;
3864 : :
3865 [ # # ]: 0 : FacetPoint *facet_start_point = CAST_TO( start_ptr, FacetPoint );
3866 [ # # ]: 0 : FacetPoint *facet_end_point = CAST_TO( end_ptr, FacetPoint );
3867 [ # # ]: 0 : facet_start_point->add_curve( new_curve_ptr );
3868 [ # # ]: 0 : facet_end_point->add_curve( new_curve_ptr );
3869 : :
3870 [ # # ]: 0 : return CUBIT_SUCCESS;
3871 : : }
3872 : :
3873 : : //================================================================================
3874 : : // Function : make_facet_coedge
3875 : : // Member Type: PUBLIC
3876 : : // Description: create a new facet coedge
3877 : : // Author : sjowen
3878 : : // Date : 12/6/00
3879 : : //================================================================================
3880 : 1122 : CubitStatus FacetModifyEngine::make_facet_coedge( Curve *curv_ptr,
3881 : : CubitSense sense,
3882 : : CoEdgeSM *&new_coedge_ptr )
3883 : : {
3884 : : // MODIFY_CHECK_RETURN_FAILURE;
3885 : :
3886 : : //We don't know in this function what to attach it to, so do that later.
3887 : 1122 : LoopSM *loop_ptr = NULL;
3888 : :
3889 : : //Now create a new loop.
3890 : :
3891 [ + - ]: 1122 : FacetCoEdge *new_facet_coedge = new FacetCoEdge(curv_ptr, loop_ptr, sense);
3892 : :
3893 : 1122 : new_coedge_ptr = (CoEdgeSM*) new_facet_coedge;
3894 : :
3895 [ - + ]: 1122 : FacetCurve *facet_curve = CAST_TO( curv_ptr, FacetCurve );
3896 : 1122 : facet_curve->add_coedge( new_coedge_ptr );
3897 : :
3898 : 1122 : return CUBIT_SUCCESS;
3899 : : }
3900 : :
3901 : : //================================================================================
3902 : : // Function : make_facet_loop
3903 : : // Member Type: PUBLIC
3904 : : // Description: create a new facet loop
3905 : : // Author : sjowen
3906 : : // Date : 12/6/00
3907 : : //================================================================================
3908 : 330 : CubitStatus FacetModifyEngine::make_facet_loop( DLIList<CoEdgeSM*> &coedge_list,
3909 : : LoopSM *&new_loop_ptr )
3910 : : {
3911 : : //MODIFY_CHECK_RETURN_FAILURE;
3912 : :
3913 : : //We don't know in this function what to attach it to, so do that later.
3914 : 330 : Surface *surf_ptr = NULL;
3915 : :
3916 : : //Now create a new loop.
3917 : :
3918 [ + - ]: 330 : FacetLoop *new_facet_loop = new FacetLoop(surf_ptr, coedge_list );
3919 : :
3920 : 330 : new_loop_ptr = (LoopSM*) new_facet_loop;
3921 : : int ii;
3922 [ + + ]: 1452 : for ( ii = coedge_list.size(); ii > 0; ii-- )
3923 : : {
3924 : 1122 : CoEdgeSM* coedge_ptr = coedge_list.get_and_step();
3925 [ - + ]: 1122 : FacetCoEdge *facet_coedge = CAST_TO(coedge_ptr, FacetCoEdge);
3926 : 1122 : facet_coedge->add_loop(new_loop_ptr);
3927 : : }
3928 : 330 : return CUBIT_SUCCESS;
3929 : : }
3930 : :
3931 : : //================================================================================
3932 : : // Function : make_facet_surface
3933 : : // Member Type: PUBLIC
3934 : : // Description: create a new facet surface from Quad facets
3935 : : // Author : sjowen
3936 : : // Date : 12/6/00
3937 : : //================================================================================
3938 : 0 : CubitStatus FacetModifyEngine::make_facet_surface(
3939 : : DLIList<CubitQuadFacet*> &quad_facet_list,
3940 : : DLIList<CubitPoint*> &point_list,
3941 : : DLIList<LoopSM*> &my_loops,
3942 : : int interp_order,
3943 : : double min_dot,
3944 : : Surface *&new_surface_ptr)
3945 : : {
3946 : : // MODIFY_CHECK_RETURN_FAILURE;
3947 : :
3948 : : CubitQuadFacet *qfacet;
3949 [ # # ]: 0 : DLIList<CubitFacet*> facet_list;
3950 : : int ii;
3951 : :
3952 [ # # ]: 0 : quad_facet_list.reset();
3953 [ # # ][ # # ]: 0 : for (ii=0; ii<quad_facet_list.size(); ii++)
3954 : : {
3955 [ # # ]: 0 : qfacet = quad_facet_list.get_and_step();
3956 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 0 ) );
3957 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 1 ) );
3958 : : }
3959 : : return make_facet_surface( NULL, facet_list, point_list, my_loops,
3960 [ # # ][ # # ]: 0 : interp_order, min_dot, new_surface_ptr );
3961 : : }
3962 : :
3963 : : //================================================================================
3964 : : // Function : make_facet_surface
3965 : : // Member Type: PUBLIC
3966 : : // Description: create a new facet surface
3967 : : // Author : sjowen
3968 : : // Date : 12/6/00
3969 : : //================================================================================
3970 : 341 : CubitStatus FacetModifyEngine::make_facet_surface( const CubitEvaluatorData *eval_data,
3971 : : DLIList<CubitFacet*> &facet_list,
3972 : : DLIList<CubitPoint*> &point_list,
3973 : : DLIList<LoopSM*> &my_loops,
3974 : : int interp_order,
3975 : : double min_dot,
3976 : : Surface *&new_surface_ptr,
3977 : : CubitBoolean use_point_addresses,
3978 : : FacetEvalTool *facet_eval_tool,
3979 : : std::map<FacetCurve*, FacetCurve*> *hard_line_curve_map)
3980 : : {
3981 : : //MODIFY_CHECK_RETURN_FAILURE;
3982 : :
3983 : : //Create a new surface given the facets and point list.
3984 [ - + ]: 341 : if (facet_eval_tool == NULL)
3985 : : {
3986 [ # # ][ # # ]: 0 : facet_eval_tool = new FacetEvalTool();
3987 [ # # ]: 0 : if (CUBIT_SUCCESS != facet_eval_tool->initialize(facet_list, point_list,
3988 [ # # ]: 0 : interp_order, min_dot ) )
3989 : : {
3990 : 0 : return CUBIT_FAILURE;
3991 : : }
3992 : : }
3993 : :
3994 : : //We don't know in this function what to attach it to, so do that later.
3995 [ + - ]: 341 : DLIList<ShellSM*> shellsms;
3996 : : FacetSurface *new_facet_surf;
3997 : :
3998 : : //Now create a new surface.
3999 [ - + ][ # # ]: 341 : if ( eval_data && eval_data->ask_type() == SPHERE_SURFACE_TYPE )
[ # # ][ - + ]
4000 : : {
4001 : : new_facet_surf = new FacetSurface( (const SphereEvaluatorData*)eval_data,
4002 : : facet_eval_tool,
4003 : : shellsms,
4004 [ # # ][ # # ]: 0 : my_loops );
4005 : : }
4006 [ - + ][ # # ]: 341 : else if ( eval_data && eval_data->ask_type() == CONE_SURFACE_TYPE )
[ # # ][ - + ]
4007 : : {
4008 : : new_facet_surf = new FacetSurface( (const CylinderEvaluatorData*)eval_data,
4009 : : facet_eval_tool,
4010 : : shellsms,
4011 [ # # ][ # # ]: 0 : my_loops );
4012 : : }
4013 : : else
4014 : : {
4015 : : new_facet_surf = new FacetSurface( facet_eval_tool,
4016 [ + - ][ + - ]: 341 : shellsms, my_loops );
4017 : : }
4018 : :
4019 : 341 : new_surface_ptr = (Surface*) new_facet_surf;
4020 : : int ii;
4021 [ + - ][ + + ]: 671 : for ( ii = my_loops.size(); ii > 0; ii-- )
4022 : : {
4023 [ + - ]: 330 : LoopSM* loop_ptr = my_loops.get_and_step();
4024 [ - + ]: 330 : FacetLoop *facet_loop = CAST_TO(loop_ptr, FacetLoop);
4025 [ + - ]: 330 : facet_loop->add_surface(new_surface_ptr);
4026 : : }
4027 : :
4028 : : // generate the curve facet evaluaion tools for each of the curves on this
4029 : : // surface - they are based on the surface evaluation tool
4030 : :
4031 [ + - ][ + - ]: 682 : DLIList<FacetCoEdge*> coedges;
4032 [ + - ]: 341 : new_facet_surf->get_coedges( coedges );
4033 [ + - ][ + + ]: 1463 : for (ii=0; ii<coedges.size(); ii++)
4034 : : {
4035 [ + - ]: 1122 : FacetCoEdge *coedgesm_ptr = coedges.get_and_step();
4036 [ + - ]: 1122 : DLIList<FacetCurve*> curve_list;
4037 [ + - ]: 1122 : coedgesm_ptr->get_curves( curve_list );
4038 [ + - ]: 1122 : FacetCurve *facet_curve =curve_list.get();
4039 [ + - ]: 1122 : CurveFacetEvalTool *eval_tool = facet_curve->get_eval_tool();
4040 [ - + ]: 1122 : if (eval_tool == NULL)
4041 : : {
4042 [ # # ]: 0 : TBPoint *start_point = facet_curve->start_point();
4043 [ # # ]: 0 : TBPoint *end_point = facet_curve->end_point();
4044 : 0 : FacetCoEdge *facet_coedge_ptr = CAST_TO( coedgesm_ptr, FacetCoEdge );
4045 [ # # ]: 0 : CubitSense sense = facet_coedge_ptr->get_sense();
4046 : :
4047 : 0 : CubitStatus status = CUBIT_SUCCESS;
4048 [ # # ][ # # ]: 0 : eval_tool = new CurveFacetEvalTool;
4049 [ # # ]: 0 : if (!use_point_addresses)
4050 : : {
4051 [ # # ]: 0 : CubitVector temp_vec1 = start_point->coordinates();
4052 [ # # ]: 0 : CubitVector temp_vec2 = end_point->coordinates();
4053 : :
4054 [ # # ]: 0 : std::vector<CubitVector> facet_point_positions;
4055 : :
4056 [ # # ]: 0 : if( hard_line_curve_map )
4057 : : {
4058 [ # # ]: 0 : std::map<FacetCurve*, FacetCurve*>::iterator map_iter;
4059 [ # # ]: 0 : map_iter = hard_line_curve_map->find( facet_curve );
4060 [ # # ][ # # ]: 0 : if( map_iter != hard_line_curve_map->end() )
[ # # ]
4061 : : {
4062 [ # # ]: 0 : DLIList<CubitPoint*> facet_curve_pts;
4063 [ # # ][ # # ]: 0 : map_iter->second->get_points( facet_curve_pts );
4064 [ # # ][ # # ]: 0 : for( int k=facet_curve_pts.size(); k--; )
4065 [ # # ][ # # ]: 0 : facet_point_positions.push_back( facet_curve_pts.get_and_step()->coordinates() );
[ # # ][ # # ]
4066 : : }
4067 : : }
4068 : :
4069 [ # # ][ # # ]: 0 : if( facet_point_positions.size() )
4070 : : {
4071 [ # # ]: 0 : CubitVector start = temp_vec1;
4072 [ # # ]: 0 : if( sense != CUBIT_FORWARD )
4073 : : {
4074 [ # # ][ # # ]: 0 : std::reverse( facet_point_positions.begin(), facet_point_positions.end() );
[ # # ]
4075 [ # # ]: 0 : start = temp_vec2;
4076 : : }
4077 : : status = eval_tool->initialize( facet_eval_tool,
4078 [ # # ]: 0 : start, facet_point_positions );
4079 : : }
4080 : : else
4081 : : status = eval_tool->initialize( facet_eval_tool,
4082 : : temp_vec1,
4083 : : temp_vec2,
4084 [ # # ]: 0 : sense );
4085 [ # # ]: 0 : if ( status != CUBIT_SUCCESS )
4086 : : {
4087 [ # # ][ # # ]: 0 : delete eval_tool;
4088 [ # # ][ # # ]: 0 : return status;
4089 : 0 : }
4090 : : }
4091 : : else
4092 : : {
4093 [ # # ]: 0 : FacetPoint *start_facet_pt_ptr = CAST_TO( start_point, FacetPoint );
4094 [ # # ]: 0 : FacetPoint *end_facet_pt_ptr = CAST_TO( end_point, FacetPoint );
4095 [ # # ]: 0 : CubitPoint *start_pt = start_facet_pt_ptr->get_cubit_point();
4096 [ # # ]: 0 : CubitPoint *end_pt = end_facet_pt_ptr->get_cubit_point();
4097 : : status = eval_tool->initialize( facet_eval_tool,
4098 : : start_pt,
4099 : : end_pt,
4100 [ # # ]: 0 : sense );
4101 [ # # ]: 0 : if ( status != CUBIT_SUCCESS )
4102 : : {
4103 [ # # ][ # # ]: 0 : delete eval_tool;
4104 : 0 : return status;
4105 : : }
4106 : : }
4107 [ # # ][ # # ]: 0 : if( !eval_tool->has_good_curve_data() )
4108 : : {
4109 [ # # ][ # # ]: 0 : if (facet_curve->get_eval_tool() == NULL)
4110 [ # # ][ # # ]: 0 : delete eval_tool;
4111 : 0 : return CUBIT_FAILURE;
4112 : : }
4113 [ # # ][ + - ]: 1122 : facet_curve->set_eval_tool( eval_tool );
[ + - ]
4114 : : }
4115 : 1122 : }
4116 [ + - ]: 682 : return CUBIT_SUCCESS;
4117 : : }
4118 : :
4119 : : //================================================================================
4120 : : // Function : make_facet_shell
4121 : : // Member Type: PUBLIC
4122 : : // Description: create a new facet shell
4123 : : // Author : sjowen
4124 : : // Date : 12/6/00
4125 : : //================================================================================
4126 : 77 : CubitStatus FacetModifyEngine::make_facet_shell(DLIList<Surface*> &surface_list,
4127 : : ShellSM *&new_shell_ptr)
4128 : : {
4129 : :
4130 : : //MODIFY_CHECK_RETURN_FAILURE;
4131 : :
4132 : 77 : Lump* my_lump = NULL;
4133 [ + - ]: 77 : FacetShell *new_facet_shell = new FacetShell(my_lump, surface_list);
4134 : 77 : new_shell_ptr = (ShellSM*) new_facet_shell;
4135 : : int ii;
4136 [ + + ]: 418 : for ( ii = surface_list.size(); ii > 0; ii-- )
4137 : : {
4138 : 341 : Surface* surface_ptr = surface_list.get_and_step();
4139 [ - + ]: 341 : FacetSurface *facet_surface = CAST_TO(surface_ptr, FacetSurface);
4140 : 341 : facet_surface->add_shell(new_shell_ptr);
4141 : : }
4142 : 77 : return CUBIT_SUCCESS;
4143 : : }
4144 : :
4145 : : //================================================================================
4146 : : // Function : make_facet_lump
4147 : : // Member Type: PUBLIC
4148 : : // Description: create a new facet lump
4149 : : // Author : sjowen
4150 : : // Date : 12/6/00
4151 : : //================================================================================
4152 : 77 : CubitStatus FacetModifyEngine::make_facet_lump(DLIList<ShellSM*> &shell_list,
4153 : : Lump *&new_lump_ptr)
4154 : : {
4155 : : //MODIFY_CHECK_RETURN_FAILURE;
4156 : :
4157 : :
4158 [ + - ]: 77 : FacetLump *new_facet_lump = new FacetLump(shell_list);
4159 : 77 : new_lump_ptr = (Lump*) new_facet_lump;
4160 : : int ii;
4161 [ + + ]: 154 : for ( ii = shell_list.size(); ii > 0; ii-- )
4162 : : {
4163 : 77 : ShellSM* shell_ptr = shell_list.get_and_step();
4164 [ - + ]: 77 : FacetShell *facet_shell = CAST_TO(shell_ptr, FacetShell);
4165 : 77 : facet_shell->add_lump(new_lump_ptr);
4166 : : }
4167 : 77 : return CUBIT_SUCCESS;
4168 : : }
4169 : :
4170 : : //================================================================================
4171 : : // Function : make_facet_body
4172 : : // Member Type: PUBLIC
4173 : : // Description: create a new facet body
4174 : : // Author : sjowen
4175 : : // Date : 12/6/00
4176 : : //================================================================================
4177 : 77 : CubitStatus FacetModifyEngine::make_facet_body(DLIList<Lump*> &lump_list,
4178 : : BodySM *&new_body_ptr)
4179 : : {
4180 : :
4181 : : // MODIFY_CHECK_RETURN_FAILURE;
4182 : :
4183 [ + - ]: 77 : FacetBody *new_facet_body = new FacetBody(lump_list);
4184 : 77 : new_body_ptr = (BodySM*) new_facet_body;
4185 : : //Now attach the lower entites.
4186 : :
4187 : : int ii;
4188 [ + + ]: 154 : for ( ii = lump_list.size(); ii > 0; ii-- )
4189 : : {
4190 : 77 : Lump* lump_ptr = lump_list.get_and_step();
4191 [ - + ]: 77 : FacetLump *facet_lump = CAST_TO(lump_ptr, FacetLump);
4192 : 77 : facet_lump->add_body(new_body_ptr);
4193 : : }
4194 : 77 : return CUBIT_SUCCESS;
4195 : : }
4196 : :
4197 : : //================================================================================
4198 : : // Function : build_facet_surface
4199 : : // Member Type: PUBLIC
4200 : : // Description: same as build_facet_surface below, but takes a list of quad facets
4201 : : // Author : sjowen
4202 : : // Date : 4/30/01
4203 : : //================================================================================
4204 : 0 : CubitStatus FacetModifyEngine::build_facet_surface(
4205 : : DLIList<CubitQuadFacet *> &quad_facet_list,
4206 : : DLIList<CubitPoint *>&point_list, // fills this in if not provided
4207 : : double feature_angle,
4208 : : int interp_order,
4209 : : CubitBoolean smooth_non_manifold,
4210 : : CubitBoolean split_surfaces,
4211 : : DLIList<Surface *> &surface_list)
4212 : : {
4213 : : //MODIFY_CHECK_RETURN_FAILURE;
4214 : :
4215 : : CubitQuadFacet *qfacet;
4216 [ # # ]: 0 : DLIList<CubitFacet*> facet_list;
4217 : : int ii;
4218 : :
4219 [ # # ]: 0 : quad_facet_list.reset();
4220 [ # # ][ # # ]: 0 : for (ii=0; ii<quad_facet_list.size(); ii++)
4221 : : {
4222 [ # # ]: 0 : qfacet = quad_facet_list.get_and_step();
4223 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 0 ) );
4224 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 1 ) );
4225 : : }
4226 : : return build_facet_surface( NULL, facet_list, point_list, feature_angle,
4227 : : interp_order, smooth_non_manifold,
4228 [ # # ][ # # ]: 0 : split_surfaces, surface_list );
4229 : : }
4230 : :
4231 : : //================================================================================
4232 : : // Function : build_facet_surface
4233 : : // Member Type: PUBLIC
4234 : : // Description: same as build_facet_surface below, both quad and triangle facets
4235 : : // Author : sjowen
4236 : : // Date : 4/30/01
4237 : : //================================================================================
4238 : 44 : CubitStatus FacetModifyEngine::build_facet_surface(
4239 : : DLIList<CubitQuadFacet *> &quad_facet_list,
4240 : : DLIList<CubitFacet *> &tri_facet_list,
4241 : : DLIList<CubitPoint *>&point_list, // fills this in if not provided
4242 : : double feature_angle,
4243 : : int interp_order,
4244 : : CubitBoolean smooth_non_manifold,
4245 : : CubitBoolean split_surfaces,
4246 : : DLIList<Surface *> &surface_list)
4247 : : {
4248 : : //MODIFY_CHECK_RETURN_FAILURE;
4249 : :
4250 : 44 : CubitStatus rv = CUBIT_SUCCESS;
4251 : : CubitQuadFacet *qfacet;
4252 [ + - ]: 44 : DLIList<CubitFacet*> facet_list;
4253 : : int ii;
4254 [ + - ]: 44 : quad_facet_list.reset();
4255 [ + - ][ - + ]: 44 : for (ii=0; ii<quad_facet_list.size(); ii++)
4256 : : {
4257 [ # # ]: 0 : qfacet = quad_facet_list.get_and_step();
4258 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 0 ) );
4259 [ # # ][ # # ]: 0 : facet_list.append( qfacet->get_tri_facet( 1 ) );
4260 : : }
4261 [ + - ]: 44 : facet_list += tri_facet_list;
4262 : :
4263 : : rv = build_facet_surface( NULL, facet_list, point_list, feature_angle,
4264 : : interp_order, smooth_non_manifold,
4265 [ + - ]: 44 : split_surfaces, surface_list );
4266 [ + - ]: 44 : return rv;
4267 : : }
4268 : :
4269 : : //================================================================================
4270 : : // Function : build_cholla_surfaces
4271 : : // Member Type: PUBLIC
4272 : : // Description: create one or more surfaces from the list of facets. Also creates
4273 : : // the lower order entities. Generate curves (split surfaces), based
4274 : : // on feature angle. If feature_angle < 0 then ignore feature_angle
4275 : : // Note : This function is the main interface for Cubit to the Cholla library
4276 : : // Author : sjowen
4277 : : // Date : 4/26/01
4278 : : //================================================================================
4279 : 33 : CubitStatus FacetModifyEngine::build_cholla_surfaces
4280 : : (
4281 : : DLIList<CubitFacet *> facet_list,
4282 : : DLIList<CubitPoint *> point_list, // fills this in if not provided
4283 : : double feature_angle,
4284 : : int interp_order,
4285 : : CubitBoolean smooth_non_manifold,
4286 : : CubitBoolean split_surfaces,
4287 : : ChollaEngine *&cholla_ptr
4288 : : )
4289 : : {
4290 : : //MODIFY_CHECK_RETURN_FAILURE;
4291 : :
4292 : 33 : CubitStatus rv = CUBIT_SUCCESS;
4293 : :
4294 : : // generate the edge and point lists from the facets
4295 : :
4296 [ + - ]: 33 : DLIList<CubitFacetEdge *> edge_list;
4297 [ + - ][ + - ]: 66 : DLIList<FacetEntity*> pe_list;
4298 [ + - ][ + - ]: 66 : DLIList<FacetEntity *> pf_list;
4299 [ + - ]: 33 : FacetDataUtil::get_edges( facet_list, edge_list );
4300 [ + - ][ + - ]: 33 : if (facet_list.size() > 0 && point_list.size() == 0)
[ + - ][ - + ]
[ - + ]
4301 [ # # ]: 0 : FacetDataUtil::get_points( facet_list, point_list );
4302 : :
4303 [ + - ][ + - ]: 495 : CAST_LIST( point_list, pf_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4304 [ + - ][ + - ]: 1221 : CAST_LIST( edge_list, pe_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4305 : :
4306 : : // create the surfaces
4307 : :
4308 [ + - ]: 33 : if (rv == CUBIT_SUCCESS)
4309 : : {
4310 [ + - ]: 33 : DLIList<FacetEntity*> facet_entity_list;
4311 [ + - ][ + - ]: 825 : CAST_LIST( facet_list, facet_entity_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4312 : : cholla_ptr = new ChollaEngine( facet_entity_list,
4313 [ + - ][ + - ]: 33 : pe_list, pf_list );
4314 : : CubitBoolean use_feature_angle;
4315 [ - + ]: 33 : if (feature_angle < 0.0)
4316 : 0 : use_feature_angle = CUBIT_FALSE;
4317 : : else
4318 : 33 : use_feature_angle = CUBIT_TRUE;
4319 : : rv = cholla_ptr->create_geometry( use_feature_angle, feature_angle,
4320 : : interp_order, smooth_non_manifold,
4321 [ + - ][ + - ]: 33 : split_surfaces );
4322 : :
4323 : : }
4324 [ + - ]: 33 : return rv;
4325 : : }
4326 : : //================================================================================
4327 : : // Function : build_facet_surface
4328 : : // Member Type: PUBLIC
4329 : : // Description: create one or more surfaces from the list of facets. Also creates
4330 : : // the lower order entities. Generate curves (split surfaces), based
4331 : : // on feature angle. If feature_angle < 0 then ignore feature_angle
4332 : : // Note : This function is the main interface for Cubit to the Cholla library
4333 : : // Author : sjowen
4334 : : // Date : 4/26/01
4335 : : //================================================================================
4336 : 55 : CubitStatus FacetModifyEngine::build_facet_surface(
4337 : : const CubitEvaluatorData **eval_data,
4338 : : DLIList<CubitFacet *> &facet_list,
4339 : : DLIList<CubitPoint *> &point_list, // fills this in if not provided
4340 : : double feature_angle,
4341 : : int interp_order,
4342 : : CubitBoolean smooth_non_manifold,
4343 : : CubitBoolean split_surfaces,
4344 : : DLIList<Surface *> &surface_list)
4345 : : {
4346 : : // MODIFY_CHECK_RETURN_FAILURE;
4347 : :
4348 : 55 : CubitStatus rv = CUBIT_SUCCESS;
4349 : :
4350 : : // generate the edge and point lists from the facets
4351 : :
4352 [ + - ]: 55 : DLIList<CubitFacetEdge *> edge_list;
4353 [ + - ][ + - ]: 110 : DLIList<FacetEntity*> pe_list;
4354 [ + - ][ + - ]: 110 : DLIList<FacetEntity *> pf_list;
4355 [ + - ]: 55 : FacetDataUtil::get_edges( facet_list, edge_list );
4356 [ + - ][ + + ]: 55 : if (point_list.size() == 0)
4357 [ + - ]: 33 : FacetDataUtil::get_points( facet_list, point_list );
4358 : :
4359 [ + - ][ + - ]: 407 : CAST_LIST( point_list, pf_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4360 [ + - ][ + - ]: 561 : CAST_LIST( edge_list, pe_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4361 : :
4362 : : // create the surfaces
4363 : :
4364 [ + - ]: 55 : if (rv == CUBIT_SUCCESS)
4365 : : {
4366 [ + - ]: 55 : DLIList<FacetEntity*> facet_entity_list;
4367 [ + - ][ + - ]: 319 : CAST_LIST( facet_list, facet_entity_list, FacetEntity );
[ + - ][ + - ]
[ + - ][ + + ]
4368 : : ChollaEngine *cholla_ptr = new ChollaEngine( facet_entity_list,
4369 [ + - ][ + - ]: 55 : pe_list, pf_list );
4370 [ + - ]: 55 : cholla_ptr->set_flip_flag(CUBIT_TRUE);
4371 : : CubitBoolean use_feature_angle;
4372 [ + + ]: 55 : if (feature_angle < 0.0)
4373 : 44 : use_feature_angle = CUBIT_FALSE;
4374 : : else
4375 : 11 : use_feature_angle = CUBIT_TRUE;
4376 : : rv = cholla_ptr->create_geometry( use_feature_angle, feature_angle,
4377 : : interp_order, smooth_non_manifold,
4378 [ + - ]: 55 : split_surfaces );
4379 : :
4380 : : // make CUBIT geometry out of the Cholla entities
4381 : :
4382 [ + - ]: 55 : if (rv == CUBIT_SUCCESS)
4383 : : {
4384 [ + - ]: 55 : DLIList<ChollaSurface *> cholla_surface_list;
4385 [ + - ]: 55 : cholla_ptr->get_surfaces( cholla_surface_list );
4386 [ + - ][ + - ]: 110 : DLIList<ChollaCurve *> cholla_curve_list;
4387 [ + - ]: 55 : cholla_ptr->get_curves( cholla_curve_list );
4388 [ + - ][ + - ]: 110 : DLIList<ChollaPoint *> cholla_point_list;
4389 [ + - ]: 55 : cholla_ptr->get_points( cholla_point_list );
4390 : : rv = build_cholla_geometry(eval_data, cholla_surface_list, cholla_curve_list,
4391 : : cholla_point_list, use_feature_angle,
4392 [ + - ][ + - ]: 110 : feature_angle, interp_order, surface_list);
4393 : : }
4394 [ + - ]: 55 : cholla_ptr->delete_me();
4395 [ + - ][ + - ]: 55 : delete cholla_ptr;
[ + - ]
4396 : : }
4397 [ + - ]: 55 : return rv;
4398 : : }
4399 : :
4400 : : //===============================================================================
4401 : : // Function : build_cholla_geometry
4402 : : // Member Type: PRIVATE
4403 : : // Description: build the CUBIT geometry based on the Facet entity class lists
4404 : : // Author : sjowen
4405 : : // Date : 10/02
4406 : : //===============================================================================
4407 : 88 : CubitStatus FacetModifyEngine::build_cholla_geometry(
4408 : : const CubitEvaluatorData **eval_data,
4409 : : DLIList<ChollaSurface*> &cholla_surface_list,
4410 : : DLIList<ChollaCurve*> &cholla_curve_list,
4411 : : DLIList<ChollaPoint*> &cholla_point_list,
4412 : : CubitBoolean use_feature_angle,
4413 : : double feature_angle,
4414 : : int interp_order,
4415 : : DLIList<Surface *> &surface_list)
4416 : : {
4417 : : // MODIFY_CHECK_RETURN_FAILURE;
4418 : :
4419 : 88 : CubitStatus stat = CUBIT_SUCCESS;
4420 : :
4421 : : //- convert feature angle to a dot product
4422 : :
4423 : 88 : double min_dot = 0.0;
4424 [ + + ]: 88 : if (use_feature_angle)
4425 : : {
4426 [ - + ]: 44 : if (feature_angle > 180.0) feature_angle = 180.0;
4427 [ - + ]: 44 : if (feature_angle < 0.0) feature_angle = 0.0;
4428 : 44 : double rad_angle = (180.0 - feature_angle) * CUBIT_PI / 180.0;
4429 : 44 : min_dot = cos( rad_angle );
4430 : : }
4431 : :
4432 : : // build the CUBIT geometry based on Cholla entities
4433 : :
4434 : 88 : stat = build_cholla_point_geometry( cholla_point_list );
4435 : :
4436 [ + - ]: 88 : if (stat == CUBIT_SUCCESS)
4437 : 88 : stat = build_cholla_curve_geometry( cholla_curve_list );
4438 : :
4439 [ + - ]: 88 : if (stat == CUBIT_SUCCESS)
4440 : : stat = build_cholla_surface_geometry( eval_data,
4441 : : cholla_surface_list,
4442 : : interp_order, min_dot,
4443 : 88 : surface_list);
4444 : :
4445 : 88 : return stat;
4446 : : }
4447 : :
4448 : : //===============================================================================
4449 : : // Function : build_cholla_point_geometry
4450 : : // Member Type: PRIVATE
4451 : : // Description: From the cholla point list, create geometric points for each
4452 : : // Author : sjowen
4453 : : // Date : 10/02
4454 : : //===============================================================================
4455 : 88 : CubitStatus FacetModifyEngine::build_cholla_point_geometry(
4456 : : DLIList<ChollaPoint*> &cholla_point_list )
4457 : : {
4458 : : // MODIFY_CHECK_RETURN_FAILURE;
4459 : :
4460 : 88 : CubitStatus stat = CUBIT_SUCCESS;
4461 : : int kk;
4462 : : //int mydebug = 0;
4463 [ + + ]: 506 : for ( kk = cholla_point_list.size(); kk > 0; kk-- )
4464 : : {
4465 : 418 : ChollaPoint *chpnt_ptr = cholla_point_list.get_and_step();
4466 : 418 : TBPoint *point_ptr = (TBPoint *)chpnt_ptr->get_geometric_point();
4467 [ + - ]: 418 : if (point_ptr == NULL)
4468 : : {
4469 [ + - ]: 418 : FacetEntity *facet_ptr = chpnt_ptr->get_facets();
4470 [ - + ]: 418 : CubitPoint *cp_ptr = CAST_TO( facet_ptr, CubitPoint );
4471 : 418 : TBPoint *point = NULL;
4472 [ + - ]: 418 : stat = make_facet_point( cp_ptr, point );
4473 [ + - ][ - + ]: 418 : if ( point == NULL || stat != CUBIT_SUCCESS )
4474 : : {
4475 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based points.\n");
[ # # ][ # # ]
4476 : 0 : return stat;
4477 : : }
4478 : 418 : point_ptr = (TBPoint *)point;
4479 [ + - ]: 418 : chpnt_ptr->assign_geometric_point((void *)point_ptr);
4480 : : }
4481 : : }
4482 : 88 : return stat;
4483 : : }
4484 : :
4485 : : //===============================================================================
4486 : : // Function : build_cholla_curve_geometry
4487 : : // Member Type: PRIVATE
4488 : : // Description: From the cholla curve list, create geometric curves for each
4489 : : // Author : sjowen
4490 : : // Date : 10/02
4491 : : //===============================================================================
4492 : 88 : CubitStatus FacetModifyEngine::build_cholla_curve_geometry(
4493 : : DLIList<ChollaCurve*> &cholla_curve_list )
4494 : : {
4495 : : // MODIFY_CHECK_RETURN_FAILURE;
4496 : :
4497 : 88 : CubitStatus stat = CUBIT_SUCCESS;
4498 : : int kk;
4499 [ + + ]: 682 : for ( kk = cholla_curve_list.size(); kk > 0; kk-- )
4500 : : {
4501 [ + - ]: 594 : ChollaCurve *chcurv_ptr = cholla_curve_list.get_and_step();
4502 [ + - ]: 594 : Curve *curv_ptr = (Curve *)chcurv_ptr->get_geometric_curve();
4503 [ + - ]: 594 : if (curv_ptr == NULL)
4504 : : {
4505 [ + - ][ + - ]: 594 : DLIList<ChollaPoint*> fpoint_list = chcurv_ptr->get_points( );
4506 [ + - ]: 594 : ChollaPoint *fpm0_ptr = fpoint_list.get_and_step();
4507 [ + - ]: 594 : ChollaPoint *fpm1_ptr = fpoint_list.get_and_step();
4508 : : CubitPoint *start_point, *end_point;
4509 [ + - ]: 594 : chcurv_ptr->get_ends( start_point, end_point );
4510 [ - + ]: 594 : assert(start_point != NULL);
4511 [ - + ]: 594 : assert(end_point != NULL);
4512 [ + - ][ - + ]: 594 : if (fpm0_ptr->get_facets() != start_point)
4513 : : {
4514 : : ChollaPoint *temp_ptr;
4515 : 0 : temp_ptr = fpm0_ptr;
4516 : 0 : fpm0_ptr = fpm1_ptr;
4517 : 0 : fpm1_ptr = temp_ptr;
4518 : : }
4519 [ + - ]: 594 : TBPoint *start_ptr = (TBPoint *) fpm0_ptr->get_geometric_point();
4520 [ + - ]: 594 : TBPoint *end_ptr = (TBPoint *) fpm1_ptr->get_geometric_point();
4521 : :
4522 : : // if this is a curve without a parent surface then handle it
4523 : : // differently. (Curves with parents use the surface to evaluate to
4524 : : // With only a curve, it must evaluate to the curve)
4525 : :
4526 [ + - ][ + - ]: 1188 : DLIList<ChollaSurface*> fsm_list = chcurv_ptr->get_surfaces();
[ + - ][ + - ]
4527 [ + - ][ - + ]: 594 : if (fsm_list.size() == 0)
4528 : : {
4529 [ # # ]: 0 : DLIList<FacetEntity*> facet_list;
4530 [ # # ][ # # ]: 0 : DLIList<CubitPoint*> point_list; // needs to be filled in
[ # # ]
4531 [ # # ][ # # ]: 0 : facet_list = chcurv_ptr->get_facet_list();
4532 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
[ # # ]
4533 [ # # ][ # # ]: 0 : CAST_LIST( facet_list, edge_list, CubitFacetEdge );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
4534 [ # # ]: 0 : if (stat != CUBIT_SUCCESS)
4535 : 0 : return stat;
4536 : :
4537 : : // the CurveFacetEvalTool was computed in Cholla. Retreive it
4538 : : // and pass it to make_facet_curve so it can store it with the
4539 : : // new curve
4540 [ # # ]: 0 : CurveFacetEvalTool *eval_tool_ptr = chcurv_ptr->get_eval_tool();
4541 [ # # ]: 0 : if (eval_tool_ptr == NULL)
4542 : 0 : return CUBIT_FAILURE;
4543 : : stat = make_facet_curve( start_ptr, end_ptr,
4544 : : edge_list, point_list,
4545 [ # # ]: 0 : curv_ptr, eval_tool_ptr );
4546 [ # # ]: 0 : if (stat == CUBIT_SUCCESS)
4547 : : {
4548 : 0 : Curve *curvsm_ptr = CAST_TO( curv_ptr, Curve );
4549 [ # # ][ # # ]: 0 : GeometryQueryTool::instance()->make_free_RefEdge( curvsm_ptr );
[ # # ][ # # ]
4550 : 0 : }
4551 : : }
4552 : : else
4553 : : {
4554 [ + - ]: 594 : CurveFacetEvalTool *eval_tool_ptr = chcurv_ptr->get_eval_tool();
4555 [ - + ]: 594 : if (eval_tool_ptr == NULL)
4556 : 0 : return CUBIT_FAILURE;
4557 : : stat = make_facet_curve( start_ptr, end_ptr,
4558 [ + - ]: 594 : curv_ptr, eval_tool_ptr );
4559 [ + - ][ - + ]: 594 : if ( curv_ptr == NULL || stat != CUBIT_SUCCESS )
4560 : : {
4561 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based curves.\n");
[ # # ][ # # ]
4562 : 0 : return stat;
4563 : : }
4564 : : }
4565 [ + - ][ + - ]: 1188 : chcurv_ptr->assign_geometric_curve((void *)curv_ptr);
[ + - ]
4566 : : }
4567 : : }
4568 : 88 : return stat;
4569 : : }
4570 : :
4571 : :
4572 : : //===============================================================================
4573 : : // Function : build_cholla_loop_geometry
4574 : : // Member Type: PRIVATE
4575 : : // Description: From the cholla curve list of a surface, create geometric loops
4576 : : // Author : sjowen
4577 : : // Date : 10/02
4578 : : //===============================================================================
4579 : 341 : CubitStatus FacetModifyEngine::build_cholla_loop_geometry(
4580 : : DLIList<ChollaCurve*> &cholla_curve_list, // curves on a surface
4581 : : ChollaSurface *chsurf_ptr, // the surface
4582 : : DLIList<LoopSM*> &loop_list, // append to this loop list
4583 : : int debug_draw )
4584 : : {
4585 : : //MODIFY_CHECK_RETURN_FAILURE;
4586 : :
4587 : 341 : CubitStatus stat = CUBIT_SUCCESS;
4588 : :
4589 : : typedef CubitLoops<CoEdgeSM, CubitPoint>::CoEdge MyCoEdge;
4590 [ + - ]: 341 : std::vector<MyCoEdge> coedges;
4591 : :
4592 : : // loop through and build co-edges
4593 [ + - ][ + + ]: 1463 : for(int i=0; i<cholla_curve_list.size(); i++)
4594 : : {
4595 [ + - ]: 1122 : ChollaCurve* chcurv_ptr = cholla_curve_list[i];
4596 : :
4597 : : CubitSense orientation;
4598 : : stat = ChollaEngine::determine_curve_orientation( chsurf_ptr,
4599 [ + - ]: 1122 : chcurv_ptr, orientation );
4600 [ - + ]: 1122 : if(stat == CUBIT_FAILURE)
4601 : 0 : return CUBIT_FAILURE;
4602 : :
4603 [ + - ]: 1122 : CubitSense this_orientation = orientation == CUBIT_UNKNOWN ? CUBIT_FORWARD : orientation;
4604 : :
4605 : 1122 : CoEdgeSM *coedge_ptr = NULL;
4606 [ + - ]: 1122 : Curve *curv_ptr = (Curve *)chcurv_ptr->get_geometric_curve();
4607 [ + - ]: 1122 : stat = make_facet_coedge( curv_ptr, this_orientation, coedge_ptr );
4608 [ + - ][ - + ]: 1122 : if ( coedge_ptr == NULL || stat != CUBIT_SUCCESS )
4609 : : {
4610 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based coedges.\n");
[ # # ][ # # ]
4611 : 0 : return stat;
4612 : : }
4613 : :
4614 : : MyCoEdge coedge;
4615 : 1122 : coedge.curve = coedge_ptr;
4616 [ + - ]: 1122 : chcurv_ptr->get_ends( coedge.start, coedge.end );
4617 : 1122 : coedge.sense = this_orientation;
4618 [ + - ]: 1122 : coedges.push_back(coedge);
4619 : :
4620 [ - + ]: 1122 : if(orientation == CUBIT_UNKNOWN)
4621 : : {
4622 [ # # ]: 0 : curv_ptr = (Curve *)chcurv_ptr->get_geometric_curve();
4623 [ # # ]: 0 : stat = make_facet_coedge( curv_ptr, CUBIT_REVERSED, coedge_ptr );
4624 [ # # ][ # # ]: 0 : if ( coedge_ptr == NULL || stat != CUBIT_SUCCESS )
4625 : : {
4626 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based coedges.\n");
[ # # ][ # # ]
4627 : 0 : return stat;
4628 : : }
4629 : :
4630 : 0 : coedge.curve = coedge_ptr;
4631 : 0 : coedge.sense = CUBIT_REVERSED;
4632 [ # # ]: 0 : coedges.push_back(coedge);
4633 : : }
4634 : : }
4635 : :
4636 : : // compute loops from co-edges
4637 [ + - ][ + - ]: 682 : std::vector<std::vector<MyCoEdge*> > loops;
4638 [ + - ]: 341 : CubitLoops<CoEdgeSM, CubitPoint>::make_loops(coedges, loops);
4639 : :
4640 : : // build loops
4641 [ + - ][ + + ]: 671 : for(size_t i=0; i<loops.size(); i++)
4642 : : {
4643 [ + - ]: 330 : DLIList<CoEdgeSM*> coedge_list;
4644 [ + - ][ + - ]: 1452 : for(size_t j=0; j<loops[i].size(); j++)
[ + + ]
4645 : : {
4646 [ + - ][ + - ]: 1122 : coedge_list.append(loops[i][j]->curve);
[ + - ]
4647 : : }
4648 : 330 : LoopSM *loop_ptr = NULL;
4649 [ + - ]: 330 : stat = make_facet_loop( coedge_list, loop_ptr );
4650 [ + - ][ - + ]: 330 : if ( loop_ptr == NULL || stat != CUBIT_SUCCESS )
4651 : : {
4652 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based loops.\n");
[ # # ][ # # ]
4653 : 0 : return stat;
4654 : : }
4655 [ + - ][ + - ]: 330 : loop_list.append( loop_ptr );
[ + - ]
4656 : 330 : }
4657 : :
4658 [ + - ]: 682 : return stat;
4659 : : }
4660 : :
4661 : : //===============================================================================
4662 : : // Function : build_cholla_surface_geometry (PRIVATE)
4663 : : // Member Type: PRIVATE
4664 : : // Description: From the facet surface list, create geometric surface,
4665 : : // loops and coedges for each surface in the list
4666 : : // Author : sjowen
4667 : : // Date : 10/02
4668 : : //===============================================================================
4669 : 88 : CubitStatus FacetModifyEngine::build_cholla_surface_geometry(
4670 : : const CubitEvaluatorData **eval_data,
4671 : : DLIList<ChollaSurface*> &cholla_surface_list,
4672 : : int interp_order,
4673 : : double min_dot,
4674 : : DLIList<Surface *> &surface_list)
4675 : : {
4676 : : // MODIFY_CHECK_RETURN_FAILURE;
4677 : :
4678 : 88 : CubitStatus stat = CUBIT_SUCCESS;
4679 : : int ii, isurface;
4680 : :
4681 : : // make sure the facet flags have been reset
4682 : :
4683 : : ChollaCurve *chcurv_ptr;
4684 : 88 : cholla_surface_list.reset();
4685 [ + + ]: 429 : for ( isurface = 0; isurface < cholla_surface_list.size(); isurface++ )
4686 : : {
4687 : 341 : ChollaSurface *chsurf_ptr = cholla_surface_list.get_and_step();
4688 : 341 : chsurf_ptr->reset_facet_flags();
4689 : : }
4690 : :
4691 : : // now loop through surfaces and create them
4692 : :
4693 : 88 : int mydebug = 0;
4694 : 88 : cholla_surface_list.reset();
4695 [ + + ]: 429 : for ( isurface = 0; isurface < cholla_surface_list.size(); isurface++ )
4696 : : {
4697 [ - + ]: 341 : const CubitEvaluatorData *surf_eval_data = eval_data == NULL ? NULL : eval_data[isurface];
4698 [ + - ]: 341 : ChollaSurface *chsurf_ptr = cholla_surface_list.get_and_step();
4699 : :
4700 [ + - ]: 341 : DLIList<ChollaCurve*> chcurve_list;
4701 [ + - ]: 341 : chsurf_ptr->get_curves( chcurve_list );
4702 : :
4703 : : // init flags for curves on this surface
4704 : :
4705 [ + - ][ + + ]: 1463 : for (ii=0; ii< chcurve_list.size(); ii++)
4706 : : {
4707 [ + - ]: 1122 : chcurv_ptr = chcurve_list.get_and_step();
4708 [ + - ]: 1122 : chcurv_ptr->set_flag(0);
4709 [ - + ]: 1122 : if (mydebug)
4710 : : {
4711 [ # # ]: 0 : chcurv_ptr->debug_draw();
4712 : : }
4713 : : }
4714 : :
4715 : : // generate loops - keep going until we have used all the curves in the list
4716 : :
4717 [ + - ][ + - ]: 682 : DLIList<LoopSM*> loop_list;
[ + - ]
4718 : 341 : int debug_draw = 0;
4719 : : stat = build_cholla_loop_geometry( chcurve_list, chsurf_ptr,
4720 [ + - ]: 341 : loop_list, debug_draw );
4721 [ - + ]: 341 : if (stat != CUBIT_SUCCESS)
4722 : : {
4723 [ # # ][ # # ]: 0 : PRINT_ERROR("Can't build geometric loop from facets\n");
[ # # ][ # # ]
4724 : 0 : return stat;
4725 : : }
4726 : :
4727 : : // create the surface
4728 : :
4729 [ + - ]: 341 : Surface *surf_ptr = (Surface *)chsurf_ptr->get_geometric_surface();
4730 [ + - ]: 341 : if (surf_ptr == NULL)
4731 : : {
4732 [ + - ]: 341 : DLIList<FacetEntity*> facet_entity_list;
4733 [ + - ][ + - ]: 682 : DLIList<CubitPoint*> point_list;
[ + - ]
4734 [ + - ]: 341 : chsurf_ptr->get_points(point_list);
4735 [ + - ]: 341 : chsurf_ptr->get_facets(facet_entity_list);
4736 [ + - ][ + - ]: 682 : DLIList<CubitFacet*> facet_list;
[ + - ]
4737 [ + - ][ + - ]: 1397 : CAST_LIST( facet_entity_list, facet_list, CubitFacet );
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
4738 [ + - ]: 341 : FacetEvalTool *eval_tool_ptr = chsurf_ptr->get_eval_tool();
4739 [ - + ]: 341 : if (eval_tool_ptr == NULL)
4740 : 0 : return CUBIT_FAILURE;
4741 : : stat = make_facet_surface(surf_eval_data, facet_list,point_list,loop_list,
4742 [ + - ]: 341 : interp_order,min_dot,surf_ptr, CUBIT_TRUE, eval_tool_ptr);
4743 [ + - ][ - + ]: 341 : if ( surf_ptr == NULL || stat != CUBIT_SUCCESS )
4744 : : {
4745 [ # # ][ # # ]: 0 : PRINT_ERROR("Problems building mesh based surfaces.\n");
[ # # ][ # # ]
4746 : 0 : return stat;
4747 : : }
4748 [ + - ]: 341 : chsurf_ptr->assign_geometric_surface((void *)surf_ptr);
4749 [ + - ][ + - ]: 682 : surface_list.append(surf_ptr);
[ + - ][ + - ]
[ + - ]
4750 : : }
4751 : 341 : }
4752 : 88 : return stat;
4753 : : }
4754 : :
4755 : : //================================================================================
4756 : : // Description: improve the facets on a surface
4757 : : // Author : Steve Owen
4758 : : // Date : 8/28/2003
4759 : : //================================================================================
4760 : 0 : CubitStatus FacetModifyEngine::improve_facets( RefFace *ref_face_ptr )
4761 : : {
4762 : : //MODIFY_CHECK_RETURN_FAILURE;
4763 : :
4764 : : //CubitStatus rv = CUBIT_SUCCESS;
4765 : :
4766 : : // This must be a facet-based surface - return now if it isn't
4767 : :
4768 [ # # ]: 0 : Surface *surf_ptr = ref_face_ptr->get_surface_ptr();
4769 [ # # ]: 0 : FacetSurface *fsurf_ptr = dynamic_cast<FacetSurface *>(surf_ptr);
4770 [ # # ]: 0 : if (fsurf_ptr == NULL)
4771 : : {
4772 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't improve facets on surface %d. It is not a facet-based geometry.\n",
[ # # ][ # # ]
4773 [ # # ]: 0 : ref_face_ptr->id());
4774 : 0 : return CUBIT_FAILURE;
4775 : : }
4776 : :
4777 : : CubitPoint *point_ptr;
4778 [ # # ]: 0 : DLIList<CubitPoint *> point_list;
4779 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> facet_list;
4780 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge *> edge_list;
4781 : :
4782 : : // get the facets from the facet-based surface
4783 : :
4784 [ # # ]: 0 : fsurf_ptr->get_my_facets(facet_list, point_list);
4785 [ # # ]: 0 : FacetDataUtil::get_edges(facet_list, edge_list);
4786 : :
4787 : : // compute normals if necessary
4788 : :
4789 : : int ii;
4790 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
4791 : : {
4792 [ # # ]: 0 : point_ptr = point_list.get_and_step();
4793 [ # # ]: 0 : point_ptr->normal();
4794 : : }
4795 : :
4796 : : // main clean loop
4797 : :
4798 : : CubitFacet *facet0, *facet1;
4799 : : CubitFacetData *cfacet0, *cfacet1;
4800 : : CubitPoint *pt0, *pt1, *pt2, *pt3;
4801 : : CubitFacetEdge *edge;
4802 : : CubitFacetEdgeData *cedge;
4803 : 0 : int nflip = 0;
4804 [ # # ][ # # ]: 0 : CubitVector n0, n1, n2, n3;
[ # # ][ # # ]
4805 [ # # ][ # # ]: 0 : CubitVector c0, c1, c2, c3;
[ # # ][ # # ]
4806 : : double q0, q1, q2, q3;
4807 [ # # ][ # # ]: 0 : CubitVector nt0, nt1, nt2, nt3;
[ # # ][ # # ]
4808 [ # # ][ # # ]: 0 : DLIList<CubitFacet *>adj_facets;
4809 [ # # ]: 0 : int nedges = edge_list.size();
4810 [ # # ]: 0 : for(ii=0; ii<nedges; ii++)
4811 : : {
4812 [ # # ]: 0 : edge = edge_list.get();
4813 : :
4814 : : // can't be a feature (edge is on a curve)
4815 [ # # ][ # # ]: 0 : if(edge->is_feature())
4816 : : {
4817 [ # # ]: 0 : edge_list.step();
4818 : 0 : continue;
4819 : : }
4820 : :
4821 [ # # ]: 0 : pt0 = edge->point(0);
4822 [ # # ]: 0 : pt1 = edge->point(1);
4823 [ # # ]: 0 : adj_facets.clean_out();
4824 [ # # ]: 0 : edge->facets( adj_facets );
4825 : :
4826 : : // must be 2 adjacent facets.
4827 [ # # ][ # # ]: 0 : if (adj_facets.size() != 2)
4828 : : {
4829 [ # # ]: 0 : edge_list.step();
4830 : 0 : continue;
4831 : : }
4832 [ # # ]: 0 : facet0 = adj_facets.get_and_step();
4833 [ # # ]: 0 : facet1 = adj_facets.get();
4834 : :
4835 : : // get the adjacent vertices, make sure we are oriented correctly
4836 : : // - swap pt0 and pt1 if necessary
4837 [ # # ]: 0 : pt2 = facet0->next_node(pt1);
4838 [ # # ]: 0 : if(pt2 == pt0)
4839 : : {
4840 : 0 : pt2 = pt0;
4841 : 0 : pt0 = pt1;
4842 : 0 : pt1 = pt2;
4843 [ # # ]: 0 : pt2 = facet0->next_node(pt1);
4844 : : }
4845 [ # # ]: 0 : pt3 = facet1->next_node(pt0);
4846 : :
4847 : : // get the normals from the vertices
4848 [ # # ][ # # ]: 0 : n0 = pt0->normal( facet0 );
4849 [ # # ][ # # ]: 0 : n1 = pt1->normal( facet0 );
4850 [ # # ][ # # ]: 0 : n2 = pt2->normal( facet0 );
4851 [ # # ][ # # ]: 0 : n3 = pt3->normal( facet1 );
4852 [ # # ][ # # ]: 0 : c0 = pt0->coordinates();
4853 [ # # ][ # # ]: 0 : c1 = pt1->coordinates();
4854 [ # # ][ # # ]: 0 : c2 = pt2->coordinates();
4855 [ # # ][ # # ]: 0 : c3 = pt3->coordinates();
4856 : :
4857 : : // compute triangle normals by averaging vertices
4858 [ # # ][ # # ]: 0 : nt0 = n0 + n1 + n2;
[ # # ]
4859 [ # # ]: 0 : nt0.normalize();
4860 [ # # ][ # # ]: 0 : nt1 = n0 + n1 + n3;
[ # # ]
4861 [ # # ]: 0 : nt1.normalize();
4862 [ # # ][ # # ]: 0 : nt2 = n0 + n2 + n3;
[ # # ]
4863 [ # # ]: 0 : nt2.normalize();
4864 [ # # ][ # # ]: 0 : nt3 = n1 + n2 + n3;
[ # # ]
4865 [ # # ]: 0 : nt3.normalize();
4866 : :
4867 : : // compute quality for each of the four tris... 2 existing tris
4868 : : // and the two potential tris if we flip
4869 [ # # ]: 0 : q0 = FacetDataUtil::quality(c0, c1, c2, nt0);
4870 [ # # ]: 0 : q1 = FacetDataUtil::quality(c1, c0, c3, nt1);
4871 [ # # ]: 0 : q2 = FacetDataUtil::quality(c0, c3, c2, nt2);
4872 [ # # ]: 0 : q3 = FacetDataUtil::quality(c1, c2, c3, nt3);
4873 [ # # ]: 0 : q0 = CUBIT_MIN( q0, q1 );
4874 [ # # ]: 0 : q2 = CUBIT_MIN( q2, q3 );
4875 [ # # ]: 0 : if (q2 > q0)
4876 : : {
4877 : : // flip
4878 : :
4879 [ # # ]: 0 : facet_list.remove( facet0 ); // these take too long - find another way to remove them
4880 [ # # ]: 0 : facet_list.remove( facet1 );
4881 [ # # ]: 0 : edge_list.change_to(NULL);
4882 : :
4883 [ # # ]: 0 : cfacet0 = dynamic_cast<CubitFacetData *>( facet0 );
4884 [ # # ]: 0 : cfacet1 = dynamic_cast<CubitFacetData *>( facet1 );
4885 [ # # ]: 0 : cedge = dynamic_cast<CubitFacetEdgeData *>( edge );
4886 : :
4887 [ # # ][ # # ]: 0 : delete cfacet0;
4888 [ # # ][ # # ]: 0 : delete cfacet1;
4889 [ # # ][ # # ]: 0 : delete cedge;
4890 : :
4891 : : // get edges
4892 : :
4893 : : CubitFacetEdge *e[4];
4894 [ # # ]: 0 : e[0] = pt2->get_edge( pt0 );
4895 [ # # ]: 0 : e[1] = pt0->get_edge( pt3 );
4896 [ # # ]: 0 : e[2] = pt3->get_edge( pt1 );
4897 [ # # ]: 0 : e[3] = pt1->get_edge( pt2 );
4898 [ # # ][ # # ]: 0 : cedge = new CubitFacetEdgeData( pt2, pt3 );
4899 : 0 : edge = dynamic_cast<CubitFacetEdge *>( cedge );
4900 : :
4901 [ # # ][ # # ]: 0 : cfacet0 = new CubitFacetData( edge, e[0], e[1] );
4902 [ # # ][ # # ]: 0 : cfacet1 = new CubitFacetData( edge, e[2], e[3] );
4903 : 0 : facet0 = dynamic_cast<CubitFacet *>( cfacet0 );
4904 : 0 : facet1 = dynamic_cast<CubitFacet *>( cfacet1 );
4905 : :
4906 [ # # ]: 0 : edge_list.append( edge );
4907 [ # # ]: 0 : facet_list.append( facet0 );
4908 [ # # ]: 0 : facet_list.append( facet1 );
4909 : :
4910 : 0 : nflip++;
4911 : : }
4912 [ # # ]: 0 : edge_list.step();
4913 : : }
4914 [ # # ]: 0 : edge_list.remove_all_with_value(NULL);
4915 [ # # ][ # # ]: 0 : assert(edge_list.size() == nedges);
4916 [ # # ]: 0 : if (nflip > 0)
4917 : : {
4918 [ # # ][ # # ]: 0 : fsurf_ptr->get_eval_tool()->replace_facets(facet_list);
4919 : : }
4920 [ # # ]: 0 : return CUBIT_SUCCESS;
4921 : : }
4922 : :
4923 : :
4924 : : //================================================================================
4925 : : // Description: smooth the facets on a surface
4926 : : // Author : Steve Owen
4927 : : // Date : 8/28/2003
4928 : : // Note: free_laplacian = TRUE will not project the node back to a tangent plane
4929 : : // free_laplacian = FALSE will project to local tangent plane
4930 : : //================================================================================
4931 : 0 : CubitStatus FacetModifyEngine::smooth_facets( RefFace *ref_face_ptr, int niter,
4932 : : CubitBoolean free_laplacian )
4933 : : {
4934 : : //MODIFY_CHECK_RETURN_FAILURE;
4935 : :
4936 : 0 : CubitStatus rv = CUBIT_SUCCESS;
4937 : :
4938 : : // This must be a facet-based surface - return now if it isn't
4939 : :
4940 [ # # ]: 0 : Surface *surf_ptr = ref_face_ptr->get_surface_ptr();
4941 [ # # ]: 0 : FacetSurface *fsurf_ptr = dynamic_cast<FacetSurface *>(surf_ptr);
4942 [ # # ]: 0 : if (fsurf_ptr == NULL)
4943 : : {
4944 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't smooth facets on surface %d. It is not a facet-based geometry.\n",
[ # # ][ # # ]
4945 [ # # ]: 0 : ref_face_ptr->id());
4946 : 0 : return CUBIT_FAILURE;
4947 : : }
4948 : :
4949 : : CubitPoint *point_ptr;
4950 [ # # ]: 0 : DLIList<CubitPoint *>point_list;
4951 : :
4952 : : // get the points from the facet-basec surface
4953 : :
4954 [ # # ]: 0 : fsurf_ptr->get_my_points(point_list);
4955 : :
4956 : : // compute normals if necessary
4957 : :
4958 : : int ii, jj;
4959 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
4960 : : {
4961 [ # # ]: 0 : point_ptr = point_list.get_and_step();
4962 [ # # ]: 0 : point_ptr->normal();
4963 [ # # ]: 0 : point_ptr->marked(0);
4964 : : }
4965 : :
4966 : : // get the points on the facet curves associated with this surface
4967 : :
4968 [ # # ][ # # ]: 0 : DLIList<CubitPoint *>cpoint_list;
4969 : : FacetCurve *fcurv_ptr;
4970 : : Curve *curv_ptr;
4971 : :
4972 : : int idx;
4973 [ # # ][ # # ]: 0 : DLIList<Curve *> curves;
4974 [ # # ]: 0 : fsurf_ptr->curves(curves);
4975 [ # # ][ # # ]: 0 : FacetCurve **fcurve_array = new FacetCurve * [curves.size()];
[ # # ]
4976 [ # # ][ # # ]: 0 : for (ii=0; ii<curves.size(); ii++)
4977 : : {
4978 : 0 : idx = ii+1;
4979 [ # # ]: 0 : curv_ptr = curves.get_and_step();
4980 [ # # ]: 0 : fcurv_ptr = dynamic_cast<FacetCurve *>(curv_ptr);
4981 [ # # ]: 0 : if (!fcurv_ptr)
4982 : : {
4983 [ # # ][ # # ]: 0 : PRINT_ERROR("Couldn't smooth facets on surface %d. At least one of it curves is not a facet-based geometry.\n",
[ # # ][ # # ]
4984 [ # # ]: 0 : ref_face_ptr->id());
4985 : 0 : return CUBIT_FAILURE;
4986 : : }
4987 : :
4988 : : // mark the points on the curve with the index of the curve in the array
4989 : : // this will allow us to project the point back to the owning curve
4990 : :
4991 [ # # ]: 0 : cpoint_list.clean_out();
4992 [ # # ]: 0 : fcurv_ptr->get_points(cpoint_list);
4993 [ # # ][ # # ]: 0 : for (jj=0; jj<cpoint_list.size(); jj++)
4994 : : {
4995 [ # # ]: 0 : point_ptr = cpoint_list.get_and_step();
4996 [ # # ]: 0 : point_ptr->marked( idx );
4997 : : }
4998 : 0 : fcurve_array[idx-1] = fcurv_ptr;
4999 : :
5000 : : // mark the vertices with a negative value so we don't touch them
5001 : :
5002 [ # # ]: 0 : DLIList<TBPoint *> verts;
5003 [ # # ]: 0 : fcurv_ptr->points(verts);
5004 [ # # ][ # # ]: 0 : for(jj=0; jj<verts.size(); jj++)
5005 : : {
5006 [ # # ]: 0 : TBPoint *vert = verts.get_and_step();
5007 [ # # ]: 0 : FacetPoint *fvert = dynamic_cast<FacetPoint *> (vert);
5008 [ # # ][ # # ]: 0 : fvert->get_cubit_point()->marked(-1);
5009 : : }
5010 [ # # ]: 0 : }
5011 : :
5012 : : // laplacian smoothing
5013 : :
5014 [ # # ][ # # ]: 0 : DLIList<CubitPoint *> adj_points;
5015 : : int iter, nadj;
5016 : : CubitPoint *adj_point_ptr;
5017 [ # # ]: 0 : CubitVector new_location;
5018 : :
5019 [ # # ]: 0 : for (iter = 0; iter < niter; iter++)
5020 : : {
5021 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
5022 : : {
5023 [ # # ]: 0 : point_ptr = point_list.get_and_step();
5024 : :
5025 : : // don't smooth points at vertices
5026 : :
5027 [ # # ][ # # ]: 0 : if (point_ptr->marked() >= 0)
5028 : : {
5029 [ # # ]: 0 : adj_points.clean_out();
5030 [ # # ]: 0 : point_ptr->adjacent_points( adj_points );
5031 [ # # ]: 0 : new_location.set(0.0, 0.0, 0.0);
5032 : 0 : nadj=0;
5033 [ # # ][ # # ]: 0 : for (jj = 0; jj<adj_points.size(); jj++)
5034 : : {
5035 [ # # ]: 0 : adj_point_ptr = adj_points.get_and_step();
5036 [ # # ][ # # ]: 0 : if (point_ptr->marked()) // is on a curve
5037 : : {
5038 : : // only use points on the same curve to influence the new location
5039 [ # # ][ # # ]: 0 : if (point_ptr->marked() == adj_point_ptr->marked())
[ # # ]
5040 : : {
5041 [ # # ][ # # ]: 0 : new_location += adj_point_ptr->coordinates();
5042 : 0 : nadj++;
5043 : : }
5044 : : }
5045 : :
5046 : : // interior nodes use all adjacent points
5047 : : else
5048 : : {
5049 [ # # ][ # # ]: 0 : new_location += adj_point_ptr->coordinates();
5050 : 0 : nadj++;
5051 : : }
5052 : : }
5053 [ # # ]: 0 : new_location /= nadj;
5054 : :
5055 : : // project it to a tangent plane defined at the point.
5056 : : // except if we are on a curve or we're using free-laplacian option
5057 [ # # ][ # # ]: 0 : if (!free_laplacian && point_ptr->marked() == 0)
[ # # ][ # # ]
5058 [ # # ][ # # ]: 0 : new_location = point_ptr->project_to_tangent_plane( new_location );
5059 : :
5060 : : // for points on a curve project to the curve definition
5061 [ # # ][ # # ]: 0 : if(point_ptr->marked() != 0)
5062 : : {
5063 [ # # ]: 0 : const CubitVector temp = new_location;
5064 [ # # ]: 0 : fcurve_array[point_ptr->marked()-1]->closest_point( temp,
5065 [ # # ]: 0 : new_location );
5066 : : }
5067 : :
5068 [ # # ][ # # ]: 0 : if (point_ptr->check_inverted_facets(new_location) == CUBIT_SUCCESS)
5069 : : {
5070 [ # # ]: 0 : point_ptr->set(new_location);
5071 : : }
5072 : : }
5073 : : }
5074 : :
5075 : : // update the normals
5076 : :
5077 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
5078 : : {
5079 [ # # ]: 0 : point_ptr = point_list.get_and_step();
5080 [ # # ]: 0 : point_ptr->compute_avg_normal();
5081 : : }
5082 : : }
5083 : :
5084 [ # # ]: 0 : return rv;
5085 : : }
5086 : :
5087 : : //================================================================================
5088 : : // Description: create a shell that is the normal offset of the given shell
5089 : : // Author : Steve Owen
5090 : : // Date : 8/28/2003
5091 : : //================================================================================
5092 : 0 : CubitStatus FacetModifyEngine::create_shell_offset( BodySM *bodysm_ptr,
5093 : : BodySM *&new_bodysm, double offset )
5094 : : {
5095 : : // MODIFY_CHECK_RETURN_FAILURE;
5096 : :
5097 : : // check that this is a facet body
5098 : :
5099 [ # # ]: 0 : FacetBody *fbody_ptr = dynamic_cast<FacetBody *>(bodysm_ptr);
5100 [ # # ]: 0 : if (fbody_ptr == NULL)
5101 : : {
5102 [ # # ][ # # ]: 0 : PRINT_ERROR("Body is not a facet-based geometry. This command is intended for use with facetted models\n");
[ # # ][ # # ]
5103 : 0 : return CUBIT_FAILURE;
5104 : : }
5105 : :
5106 : : // The facet and point lists
5107 : :
5108 [ # # ]: 0 : DLIList<CubitPoint *> point_list;
5109 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> facet_list;
5110 : :
5111 : : // get the surfaces. Check that they are also all facet bodies
5112 : :
5113 : : int ii;
5114 : : Surface *surf_ptr;
5115 : : FacetSurface *fsurf_ptr;
5116 [ # # ][ # # ]: 0 : DLIList<Surface *> surface_list;
5117 [ # # ]: 0 : fbody_ptr->surfaces( surface_list );
5118 [ # # ][ # # ]: 0 : for (ii=0; ii<surface_list.size(); ii++)
5119 : : {
5120 [ # # ]: 0 : surf_ptr = surface_list.get_and_step();
5121 [ # # ]: 0 : fsurf_ptr = dynamic_cast<FacetSurface *>(surf_ptr);
5122 [ # # ]: 0 : if (fsurf_ptr == NULL)
5123 : : {
5124 [ # # ][ # # ]: 0 : PRINT_ERROR("At least one of the surfaces in Body is not facet-based geometry.\n"
[ # # ]
5125 [ # # ]: 0 : "This command is intended for use with facetted models\n");
5126 : 0 : return CUBIT_FAILURE;
5127 : : }
5128 [ # # ]: 0 : fsurf_ptr->get_my_facets(facet_list, point_list);
5129 : : }
5130 : :
5131 : : // create an array of points so we can reference them quickly when generating new facets
5132 : :
5133 [ # # ][ # # ]: 0 : CubitPoint **points = new CubitPoint * [point_list.size()];
[ # # ]
5134 : :
5135 : : // make a unique set of points
5136 : :
5137 : 0 : int id = 0;
5138 : : CubitPoint *point_ptr;
5139 [ # # ][ # # ]: 0 : for (ii=0; ii < point_list.size(); ii++)
5140 : : {
5141 [ # # ][ # # ]: 0 : point_list.get_and_step()->marked(1);
5142 : : }
5143 [ # # ][ # # ]: 0 : for (ii=0; ii<point_list.size(); ii++)
5144 : : {
5145 [ # # ]: 0 : point_ptr = point_list.get_and_step();
5146 [ # # ][ # # ]: 0 : if (point_ptr->marked() == 1)
5147 : : {
5148 [ # # ]: 0 : point_ptr->marked(0);
5149 : 0 : points[id] = point_ptr;
5150 [ # # ]: 0 : point_ptr->set_id( id );
5151 : 0 : id ++;
5152 : : }
5153 : : }
5154 : 0 : int npoints = id;
5155 : :
5156 : : // get the curves and mark any point on a curve as non-smoothable.
5157 : :
5158 : : int jj;
5159 : : Curve *curv_ptr;
5160 : : FacetCurve *fcurv_ptr;
5161 [ # # ][ # # ]: 0 : DLIList<Curve *> curve_list;
5162 [ # # ]: 0 : fbody_ptr->curves( curve_list );
5163 [ # # ][ # # ]: 0 : for(ii=0; ii<curve_list.size(); ii++)
5164 : : {
5165 [ # # ]: 0 : curv_ptr = curve_list.get_and_step();
5166 [ # # ]: 0 : fcurv_ptr = dynamic_cast<FacetCurve *>(curv_ptr);
5167 [ # # ]: 0 : if (fcurv_ptr == NULL)
5168 : : {
5169 [ # # ][ # # ]: 0 : PRINT_ERROR("At least one of the curves in Body is not a facet-based geometry.\n"
[ # # ]
5170 [ # # ]: 0 : "This command is intended for use with facetted models\n");
5171 : 0 : return CUBIT_FAILURE;
5172 : : }
5173 [ # # ]: 0 : point_list.clean_out();
5174 [ # # ]: 0 : fcurv_ptr->get_points( point_list );
5175 [ # # ][ # # ]: 0 : for(jj=0; jj<point_list.size(); jj++)
5176 : : {
5177 [ # # ]: 0 : point_ptr = point_list.get_and_step();
5178 [ # # ]: 0 : point_ptr->marked(1);
5179 : : }
5180 : : }
5181 : :
5182 : : // smooth the normals to reduce chance of overlap on concave regions
5183 : :
5184 [ # # ][ # # ]: 0 : CubitVector new_normal, normal;
5185 : 0 : const int niter = 3;
5186 : : int iter, nadj;
5187 : : CubitPoint *adj_point_ptr;
5188 [ # # ][ # # ]: 0 : DLIList<CubitPoint *> adj_points;
5189 : :
5190 [ # # ]: 0 : for (iter = 0; iter < niter; iter++)
5191 : : {
5192 [ # # ]: 0 : for (ii=0; ii<npoints; ii++)
5193 : : {
5194 : 0 : point_ptr = points[ii];
5195 : :
5196 : : // don't smooth points on curves
5197 : :
5198 [ # # ][ # # ]: 0 : if (point_ptr->marked() != 1)
5199 : : {
5200 [ # # ]: 0 : adj_points.clean_out();
5201 [ # # ]: 0 : point_ptr->adjacent_points( adj_points );
5202 [ # # ]: 0 : new_normal.set(0.0, 0.0, 0.0);
5203 [ # # ]: 0 : nadj = adj_points.size();
5204 [ # # ]: 0 : for (jj = 0; jj<nadj; jj++)
5205 : : {
5206 [ # # ]: 0 : adj_point_ptr = adj_points.get_and_step();
5207 [ # # ][ # # ]: 0 : new_normal += adj_point_ptr->normal();
5208 : : }
5209 [ # # ]: 0 : new_normal.normalize();
5210 [ # # ]: 0 : point_ptr->normal(new_normal);
5211 : : }
5212 : : }
5213 : : }
5214 : :
5215 : : // generate a new set of points offset from the original
5216 : :
5217 : : CubitPointData *new_point;
5218 [ # # ]: 0 : CubitVector new_location;
5219 [ # # ][ # # ]: 0 : CubitPoint **new_points = new CubitPoint * [npoints];
5220 [ # # ]: 0 : for (ii=0; ii<npoints; ii++)
5221 : : {
5222 : 0 : point_ptr = points[ii];
5223 [ # # ][ # # ]: 0 : new_location = point_ptr->coordinates() + point_ptr->normal() * offset;
[ # # ][ # # ]
[ # # ]
5224 [ # # ][ # # ]: 0 : new_point = new CubitPointData( new_location );
5225 [ # # ]: 0 : new_point->set_id( ii );
5226 : 0 : new_points[ii] = (CubitPoint *) new_point;
5227 : : }
5228 : :
5229 : : // generate triangles for the new shell
5230 : :
5231 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> fix_list;
5232 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> orig_list;
5233 : : double dot;
5234 : 0 : double mindot = 1.0;
5235 : : CubitFacet *facet_ptr, *new_facet_ptr;
5236 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> new_facet_list;
5237 : : CubitPoint *p0, *p1, *p2;
5238 : : CubitPoint *np0, *np1, *np2;
5239 [ # # ][ # # ]: 0 : for(ii=0; ii<facet_list.size(); ii++)
5240 : : {
5241 [ # # ]: 0 : facet_ptr = facet_list.get_and_step();
5242 [ # # ]: 0 : facet_ptr->points( p0, p1, p2 );
5243 [ # # ]: 0 : np0 = new_points[p0->id()];
5244 [ # # ]: 0 : np1 = new_points[p1->id()];
5245 [ # # ]: 0 : np2 = new_points[p2->id()];
5246 [ # # ][ # # ]: 0 : new_facet_ptr = (CubitFacet *) new CubitFacetData( np0, np1, np2 );
5247 [ # # ]: 0 : new_facet_list.append( new_facet_ptr );
5248 : :
5249 : : // compare normals to see if we inverted anything
5250 : :
5251 [ # # ][ # # ]: 0 : normal = facet_ptr->normal();
5252 [ # # ][ # # ]: 0 : new_normal = new_facet_ptr->normal();
5253 [ # # ]: 0 : dot = normal % new_normal;
5254 [ # # ]: 0 : if (dot < mindot) mindot = dot;
5255 [ # # ]: 0 : if (dot < 0.707)
5256 : : {
5257 [ # # ]: 0 : new_facet_ptr->marked(1);
5258 [ # # ]: 0 : fix_list.append( new_facet_ptr );
5259 [ # # ]: 0 : orig_list.append( facet_ptr );
5260 : : }
5261 : : }
5262 : :
5263 : : // go back and try to uninvert tris if needed
5264 : :
5265 : : int kk;
5266 [ # # ][ # # ]: 0 : DLIList<CubitFacet *> problem_list;
5267 [ # # ][ # # ]: 0 : if (fix_list.size() > 0)
5268 : : {
5269 [ # # ]: 0 : new_location.set(0.0, 0.0, 0.0);
5270 [ # # ]: 0 : for (iter = 0; iter < niter; iter++)
5271 : : {
5272 [ # # ][ # # ]: 0 : for (ii=0; ii<fix_list.size(); ii++)
5273 : : {
5274 [ # # ]: 0 : facet_ptr = fix_list.get_and_step();
5275 [ # # ]: 0 : point_list.clean_out();
5276 [ # # ]: 0 : facet_ptr->points( point_list );
5277 [ # # ][ # # ]: 0 : for (jj=0; jj<point_list.size(); jj++)
5278 : : {
5279 [ # # ]: 0 : point_ptr = point_list.get_and_step();
5280 : :
5281 : : // don't smooth marked points
5282 : :
5283 [ # # ][ # # ]: 0 : if (point_ptr->marked() != 1)
5284 : : {
5285 [ # # ]: 0 : adj_points.clean_out();
5286 [ # # ]: 0 : point_ptr->adjacent_points( adj_points );
5287 [ # # ]: 0 : new_location.set(0.0, 0.0, 0.0);
5288 [ # # ]: 0 : nadj = adj_points.size();
5289 [ # # ]: 0 : for (kk = 0; kk<nadj; kk++)
5290 : : {
5291 [ # # ]: 0 : adj_point_ptr = adj_points.get_and_step();
5292 [ # # ][ # # ]: 0 : new_location += adj_point_ptr->coordinates();
5293 : : }
5294 [ # # ]: 0 : new_location /= nadj;
5295 [ # # ]: 0 : point_ptr->set(new_location);
5296 : : }
5297 : : }
5298 : : }
5299 : : }
5300 : :
5301 : : // see if it worked
5302 : :
5303 [ # # ]: 0 : fix_list.reset();
5304 [ # # ]: 0 : orig_list.reset();
5305 [ # # ][ # # ]: 0 : for(ii=0; ii<fix_list.size(); ii++)
5306 : : {
5307 [ # # ]: 0 : new_facet_ptr = fix_list.get_and_step();
5308 [ # # ]: 0 : facet_ptr = orig_list.get_and_step();
5309 [ # # ]: 0 : new_facet_ptr->update_plane();
5310 [ # # ][ # # ]: 0 : new_normal = new_facet_ptr->normal();
5311 [ # # ][ # # ]: 0 : normal = facet_ptr->normal();
5312 [ # # ]: 0 : dot = normal % new_normal;
5313 [ # # ]: 0 : if (dot < 0.707)
5314 : : {
5315 [ # # ]: 0 : problem_list.append( new_facet_ptr );
5316 : : }
5317 : : }
5318 : : }
5319 : :
5320 : : // set the normals back the way they were and clean up
5321 : :
5322 [ # # ]: 0 : for (ii=0; ii<npoints; ii++)
5323 : : {
5324 : 0 : point_ptr = points[ii];
5325 [ # # ]: 0 : point_ptr->compute_avg_normal();
5326 : : }
5327 [ # # ]: 0 : delete [] points;
5328 [ # # ]: 0 : delete [] new_points;
5329 : :
5330 : : // build the geometry
5331 : :
5332 : 0 : const char *file_name = NULL;
5333 : 0 : CubitBoolean use_feature_angle = CUBIT_TRUE;
5334 : 0 : double feature_angle = 0.0;
5335 : 0 : int interp_order = 0;
5336 : 0 : CubitBoolean smooth_non_manifold = CUBIT_TRUE;
5337 : 0 : CubitBoolean split_surfaces = CUBIT_FALSE;
5338 : 0 : CubitBoolean stitch = CUBIT_FALSE;
5339 : 0 : CubitBoolean improve = CUBIT_FALSE;
5340 [ # # ][ # # ]: 0 : DLIList<CubitQuadFacet *> quad_facet_list;
5341 [ # # ][ # # ]: 0 : DLIList<Surface *> new_surface_list;
5342 : 0 : FacetFileFormat file_format = FROM_FACET_LIST;
5343 : :
5344 : : CubitStatus rv =
5345 : : FacetQueryEngine::instance()->import_facets( file_name, use_feature_angle, feature_angle, 0.0,
5346 : : interp_order, smooth_non_manifold,
5347 : : split_surfaces, stitch, improve, quad_facet_list,
5348 [ # # ][ # # ]: 0 : new_facet_list, new_surface_list, file_format );
5349 : :
5350 [ # # ][ # # ]: 0 : if(problem_list.size() > 0)
5351 : : {
5352 [ # # ][ # # ]: 0 : PRINT_WARNING("Offset process on facet body, may have resulted in %d overalapping facets.\n"
[ # # ][ # # ]
5353 : : "Check results carefully. Problem facet(s) are displayed in red.)\n",
5354 [ # # ]: 0 : problem_list.size());
5355 [ # # ][ # # ]: 0 : for (ii=0; ii<problem_list.size(); ii++)
5356 : : {
5357 [ # # ]: 0 : facet_ptr = problem_list.get_and_step();
5358 [ # # ]: 0 : GfxDebug::draw_facet(facet_ptr, CUBIT_RED_INDEX);
5359 : : }
5360 [ # # ]: 0 : GfxDebug::flush();
5361 : : }
5362 : :
5363 [ # # ][ # # ]: 0 : if( new_surface_list.size() )
5364 : : {
5365 [ # # ][ # # ]: 0 : new_bodysm = new_surface_list.get()->bodysm();
5366 [ # # ]: 0 : if( !new_bodysm )
5367 : : {
5368 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem offsetting Body\n");
[ # # ][ # # ]
5369 : 0 : return CUBIT_FAILURE;
5370 : : }
5371 : : }
5372 : : else
5373 : : {
5374 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem offsetting Body\n");
[ # # ][ # # ]
5375 : 0 : return CUBIT_FAILURE;
5376 : : }
5377 [ # # ]: 0 : return rv;
5378 : : }
5379 : :
5380 : 0 : CubitStatus FacetModifyEngine::webcut_with_sweep_surfaces(
5381 : : DLIList<BodySM*> &blank_bodies,
5382 : : DLIList<Surface*> &surfaces,
5383 : : const CubitVector& sweep_vector,
5384 : : bool sweep_perp,
5385 : : bool through_all,
5386 : : bool outward,
5387 : : bool up_to_next,
5388 : : Surface *stop_surf,
5389 : : Curve *curve_to_sweep_along,
5390 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
5391 : : DLIList<BodySM*> &results_list,
5392 : : ImprintType imprint_type,
5393 : : bool /*preview*/)
5394 : : {
5395 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5396 : 0 : return CUBIT_FAILURE;
5397 : : }
5398 : :
5399 : 0 : CubitStatus FacetModifyEngine::webcut_with_sweep_curves(
5400 : : DLIList<BodySM*> &blank_bodies,
5401 : : DLIList<Curve*> &curves,
5402 : : const CubitVector& sweep_vector,
5403 : : bool through_all,
5404 : : Surface *stop_surf,
5405 : : Curve *curve_to_sweep_along,
5406 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
5407 : : DLIList<BodySM*> &results_list,
5408 : : ImprintType imprint_type,
5409 : : bool /*preview*/)
5410 : : {
5411 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5412 : 0 : return CUBIT_FAILURE;
5413 : : }
5414 : :
5415 : 0 : CubitStatus FacetModifyEngine::webcut_with_sweep_surfaces_rotated(
5416 : : DLIList<BodySM*> &blank_bodies,
5417 : : DLIList<Surface*> &surfaces,
5418 : : const CubitVector &point,
5419 : : const CubitVector &sweep_axis,
5420 : : double angle,
5421 : : Surface *stop_surf,
5422 : : bool up_to_next,
5423 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
5424 : : DLIList<BodySM*> &results_list,
5425 : : ImprintType imprint_type,
5426 : : bool /*preview*/)
5427 : : {
5428 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5429 : 0 : return CUBIT_FAILURE;
5430 : : }
5431 : :
5432 : 0 : CubitStatus FacetModifyEngine::webcut_with_sweep_curves_rotated(
5433 : : DLIList<BodySM*> &blank_bodies,
5434 : : DLIList<Curve*> &curves,
5435 : : const CubitVector &point,
5436 : : const CubitVector &sweep_axis,
5437 : : double angle,
5438 : : Surface *stop_surf,
5439 : : DLIList<BodySM*> &/*neighbor_imprint_list*/,
5440 : : DLIList<BodySM*> &results_list,
5441 : : ImprintType imprint_type,
5442 : : bool /*preview*/)
5443 : : {
5444 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5445 : 0 : return CUBIT_FAILURE;
5446 : : }
5447 : :
5448 : 0 : CubitStatus FacetModifyEngine::scale( BodySM *&body, const CubitVector& factors )
5449 : : {
5450 : 0 : return FacetQueryEngine::instance()->scale( body, factors );
5451 : : }
5452 : :
5453 : 0 : CubitStatus FacetModifyEngine::tolerant_imprint( DLIList<BodySM*> &bodies_in,
5454 : : DLIList<BodySM*> &new_bodies,
5455 : : double overlap_tol,
5456 : : double imprint_tol,
5457 : : DLIList<TopologyBridge*> *new_tbs,
5458 : : DLIList<TopologyBridge*> *att_tbs ) const
5459 : : {
5460 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5461 : 0 : return CUBIT_FAILURE;
5462 : : }
5463 : :
5464 : 0 : CubitStatus FacetModifyEngine::tolerant_imprint( DLIList<Surface*> &surfs_in,
5465 : : DLIList<BodySM*> &new_bodysm_list) const
5466 : : {
5467 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5468 : 0 : return CUBIT_FAILURE;
5469 : : }
5470 : :
5471 : 0 : CubitStatus FacetModifyEngine::tolerant_imprint_surface_with_curves(
5472 : : Surface * /*surface_to_imprint*/,
5473 : : DLIList<Curve*> & /*curves*/,
5474 : : DLIList<TopologyBridge*> &temporary_bridges,
5475 : : BodySM *& /*new_body*/,
5476 : : DLIList<TopologyBridge*> *new_tbs,
5477 : : DLIList<TopologyBridge*> *att_tbs) const
5478 : : {
5479 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5480 : 0 : return CUBIT_FAILURE;
5481 : : }
5482 : :
5483 : 0 : CubitStatus FacetModifyEngine::curve_surface_intersection( Surface * /*surface*/,
5484 : : Curve* /*curve*/,
5485 : : DLIList<Curve*> &/*new_curves*/ ) const
5486 : : {
5487 [ # # ][ # # ]: 0 : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5488 : 0 : return CUBIT_FAILURE;
5489 : : }
5490 : :
5491 : 0 : BodySM* FacetModifyEngine::create_body( VolumeFacets& volume, std::map<FacetShapes*, GeometryEntity*>& entity_map,
5492 : : const FacetPointSet& points, int interp_order) const
5493 : : {
5494 : 0 : FacetModifyEngine* self = const_cast<FacetModifyEngine*>(this);
5495 : :
5496 : : // loop and make points
5497 [ # # ]: 0 : size_t num_points = points.size() / 3;
5498 [ # # ]: 0 : DLIList<CubitPoint*> cubit_points(num_points);
5499 : :
5500 [ # # ][ # # ]: 0 : std::map<SurfaceFacets*, DLIList<CubitFacet*> > facet_map;
5501 [ # # ][ # # ]: 0 : std::map<CurveFacets*, DLIList<CubitFacetEdge*> > facet_edge_map;
5502 : :
5503 : : // create facets (all facets must be created first so facet edges between surfaces are set up properly)
5504 [ # # ]: 0 : self->create_facets(volume.surfaceTopology, points, interp_order, cubit_points, facet_map, facet_edge_map);
5505 : :
5506 : : // now create the topology on top of the facets that were created
5507 [ # # ][ # # ]: 0 : DLIList<Surface*> surface_list;
5508 [ # # ][ # # ]: 0 : DLIList<CubitSense> surface_sense_list;
5509 [ # # ][ # # ]: 0 : for(size_t i=0; i<volume.surfaceTopology.size(); i++)
5510 : : {
5511 [ # # ]: 0 : SurfaceFacets* surf = volume.surfaceTopology[i].first;
5512 [ # # ]: 0 : CubitSense sense = volume.surfaceTopology[i].second;
5513 [ # # ][ # # ]: 0 : if ( CUBIT_SUCCESS != self->process_topology(surf, sense, interp_order, cubit_points, facet_map, facet_edge_map, entity_map) )
5514 : 0 : return NULL;
5515 [ # # ][ # # ]: 0 : surface_list.append((Surface*)entity_map[surf]);
5516 [ # # ]: 0 : surface_sense_list.append(sense);
5517 : : }
5518 : :
5519 : : // finish creation of body from list of surfaces (shell, lump, etc...)
5520 : 0 : BodySM *body_ptr = NULL;
5521 [ # # ]: 0 : finish_facet_Body(surface_list, surface_sense_list, body_ptr);
5522 [ # # ][ # # ]: 0 : entity_map[&volume] = body_ptr->lump();
5523 [ # # ]: 0 : return body_ptr;
5524 : : }
5525 : :
5526 : : #ifdef KCM_MESH_TO_GEOM
5527 : : CubitStatus FacetModifyEngine::mesh2brep(std::vector<double> &xvals,
5528 : : std::vector<double> &yvals,
5529 : : std::vector<double> &zvals,
5530 : : std::vector<unsigned int> &tri_connectivity,
5531 : : DLIList<BodySM*> &new_body_sms) const
5532 : : {
5533 : : PRINT_ERROR("Option not supported for mesh based geometry.\n");
5534 : : return CUBIT_FAILURE;
5535 : : }
5536 : : #endif
5537 : :
5538 : 0 : void FacetModifyEngine::create_facets(
5539 : : const std::vector<std::pair<SurfaceFacets*, CubitSense> >& surfaceTopology,
5540 : : const FacetPointSet& points,
5541 : : int interp_order,
5542 : : DLIList<CubitPoint*>& cubit_points,
5543 : : std::map<SurfaceFacets*, DLIList<CubitFacet*> >& facet_map,
5544 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map)
5545 : : {
5546 : : // loop and make points
5547 [ # # ]: 0 : size_t num_points = points.size() / 3;
5548 [ # # ]: 0 : for(size_t i=0; i<num_points; i++)
5549 : : {
5550 [ # # ][ # # ]: 0 : cubit_points.append(new CubitPointData(CubitVector(points[i*3], points[i*3+1], points[i*3+2])));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
5551 : : }
5552 : :
5553 [ # # ]: 0 : DLIList<CubitFacet*> all_facets;
5554 : :
5555 : : // process facets for each surface
5556 [ # # ][ # # ]: 0 : for(size_t i=0; i<surfaceTopology.size(); i++)
5557 : : {
5558 [ # # ]: 0 : CubitSense coface_sense = surfaceTopology[i].second;
5559 [ # # ]: 0 : SurfaceFacets* surface = surfaceTopology[i].first;
5560 : :
5561 [ # # ]: 0 : DLIList<CubitFacet*> surface_facets;
5562 : :
5563 [ # # ][ # # ]: 0 : for(size_t j=0; j<surface->facetConnectivity.size(); j+=3)
5564 : : {
5565 : : CubitFacetData* cfe;
5566 [ # # ]: 0 : if(coface_sense == CUBIT_REVERSED)
5567 : : {
5568 : : cfe = new CubitFacetData(
5569 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j]],
5570 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j+2]],
5571 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j+1]]);
[ # # ][ # # ]
5572 : : }
5573 : : else
5574 : : {
5575 : : cfe = new CubitFacetData(
5576 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j]],
5577 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j+1]],
5578 [ # # ][ # # ]: 0 : cubit_points[surface->facetConnectivity[j+2]]);
[ # # ][ # # ]
5579 : : }
5580 [ # # ]: 0 : surface_facets.append(cfe);
5581 : : }
5582 : :
5583 [ # # ][ # # ]: 0 : facet_map.insert(std::make_pair(surface, surface_facets));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
5584 [ # # ]: 0 : all_facets += surface_facets;
5585 [ # # ]: 0 : }
5586 : :
5587 : : // make facet edges for curves
5588 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> feature_edges;
5589 [ # # ]: 0 : std::map<SurfaceFacets*, DLIList<CubitFacet*> >::iterator facet_map_iter;
5590 [ # # ][ # # ]: 0 : for(facet_map_iter = facet_map.begin(); facet_map_iter != facet_map.end(); ++facet_map_iter)
[ # # ][ # # ]
[ # # ]
5591 : : {
5592 [ # # ]: 0 : SurfaceFacets* surface = facet_map_iter->first;
5593 [ # # ]: 0 : int num_loops = surface->curveTopology.size();
5594 [ # # ]: 0 : for(int i=0; i<num_loops; i++)
5595 : : {
5596 [ # # ][ # # ]: 0 : int num_curves = surface->curveTopology[i].size();
5597 [ # # ]: 0 : for(int j=0; j<num_curves; j++)
5598 : : {
5599 [ # # ][ # # ]: 0 : CurveFacets* edge_facets = surface->curveTopology[i][j].first;
5600 : :
5601 [ # # ][ # # ]: 0 : if(facet_edge_map.find(edge_facets) == facet_edge_map.end())
[ # # ][ # # ]
5602 : : {
5603 [ # # ]: 0 : DLIList<CubitFacetEdge*> curve_facets;
5604 : 0 : const std::vector<int>& curve_pts = edge_facets->points;
5605 [ # # ][ # # ]: 0 : for(size_t k=0; k<curve_pts.size()-1; k++)
5606 : : {
5607 [ # # ][ # # ]: 0 : CubitPoint* p1 = cubit_points[curve_pts[k]];
5608 [ # # ][ # # ]: 0 : CubitPoint* p2 = cubit_points[curve_pts[k+1]];
5609 [ # # ][ # # ]: 0 : CubitFacetEdge* edge = new CubitFacetEdgeData(p1, p2);
5610 [ # # ]: 0 : feature_edges.append(edge);
5611 [ # # ]: 0 : curve_facets.append(edge);
5612 [ # # ]: 0 : edge->set_as_feature();
5613 : : }
5614 [ # # ][ # # ]: 0 : facet_edge_map.insert(std::make_pair(edge_facets, curve_facets));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
5615 : : }
5616 : : }
5617 : : }
5618 : : }
5619 : :
5620 : : // create facet edges for facets
5621 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> all_edges;
5622 [ # # ]: 0 : FacetDataUtil::get_edges(all_facets, all_edges);
5623 : :
5624 : : // create features edges (this puts multiple normals when necessary on features)
5625 [ # # ][ # # ]: 0 : ChollaEngine::make_features( feature_edges, CUBIT_FALSE );
5626 : :
5627 : 0 : }
5628 : :
5629 : 0 : CubitStatus FacetModifyEngine::process_topology(SurfaceFacets* surface, CubitSense& coface_sense,
5630 : : int interp_order, const DLIList<CubitPoint*>& cubit_points,
5631 : : std::map<SurfaceFacets*, DLIList<CubitFacet*> >& facet_map,
5632 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map,
5633 : : std::map<FacetShapes*, GeometryEntity*>& entity_map)
5634 : : {
5635 : :
5636 [ # # ][ # # ]: 0 : DLIList<CubitFacet*>& surface_facets = facet_map.find(surface)->second;
5637 [ # # ]: 0 : DLIList<CubitPoint*> surface_points;
5638 [ # # ][ # # ]: 0 : for(int i=0; i<surface_facets.size(); i++)
5639 : : {
5640 [ # # ][ # # ]: 0 : surface_facets[i]->points(surface_points);
5641 : : }
5642 [ # # ]: 0 : surface_points.uniquify_unordered();
5643 [ # # ][ # # ]: 0 : FacetEvalTool* surf_eval = new FacetEvalTool();
5644 [ # # ][ # # ]: 0 : if ( CUBIT_SUCCESS != surf_eval->initialize(surface_facets, surface_points, interp_order, -1.0 ) )
5645 : 0 : return CUBIT_FAILURE;
5646 : :
5647 [ # # ]: 0 : int num_loops = surface->curveTopology.size();
5648 : :
5649 [ # # ][ # # ]: 0 : DLIList<LoopSM*> loops;
5650 : :
5651 : : // loop through curves and construct them
5652 : : // surfaces that are reversed are flipped so we have outward facing normals (do we really need to do this?)
5653 [ # # ]: 0 : for(int i=0; i<num_loops; i++)
5654 : : {
5655 [ # # ]: 0 : DLIList<CoEdgeSM*> current_loop;
5656 [ # # ][ # # ]: 0 : int num_curves = surface->curveTopology[i].size();
5657 [ # # ]: 0 : for(int j=0; j<num_curves; j++)
5658 : : {
5659 [ # # ][ # # ]: 0 : CurveFacets* edge_facets = surface->curveTopology[i][j].first;
5660 [ # # ][ # # ]: 0 : CubitSense coedge_sense = surface->curveTopology[i][j].second;
5661 [ # # ]: 0 : if(coface_sense == CUBIT_REVERSED)
5662 : : {
5663 [ # # ]: 0 : coedge_sense = coedge_sense == CUBIT_FORWARD ? CUBIT_REVERSED : CUBIT_FORWARD;
5664 : : }
5665 [ # # ]: 0 : process_topology(edge_facets, cubit_points, surf_eval, coedge_sense, facet_edge_map, entity_map);
5666 : :
5667 : : CoEdgeSM* tmp_coedge;
5668 [ # # ][ # # ]: 0 : make_facet_coedge((Curve*)entity_map[surface->curveTopology[i][j].first], coedge_sense, tmp_coedge);
[ # # ][ # # ]
5669 : :
5670 [ # # ]: 0 : if(coface_sense == CUBIT_REVERSED)
5671 : : {
5672 [ # # ]: 0 : current_loop.insert_first(tmp_coedge);
5673 : : }
5674 : : else
5675 : : {
5676 [ # # ]: 0 : current_loop.append(tmp_coedge);
5677 : : }
5678 : : }
5679 : :
5680 : : // make loop
5681 : : LoopSM* tmp_loop;
5682 [ # # ]: 0 : make_facet_loop(current_loop, tmp_loop);
5683 [ # # ]: 0 : loops.append(tmp_loop);
5684 [ # # ]: 0 : }
5685 : :
5686 : : // we've reversed it, so tell the caller
5687 [ # # ]: 0 : if(coface_sense == CUBIT_REVERSED)
5688 : : {
5689 : 0 : coface_sense = CUBIT_FORWARD;
5690 : : }
5691 : :
5692 : : Surface* surf_ptr;
5693 : : make_facet_surface(NULL, surface_facets, surface_points, loops, interp_order, -1.0,
5694 [ # # ]: 0 : surf_ptr, CUBIT_TRUE, surf_eval);
5695 [ # # ]: 0 : entity_map[surface] = surf_ptr;
5696 [ # # ]: 0 : return CUBIT_SUCCESS;
5697 : : }
5698 : :
5699 : 0 : void FacetModifyEngine::process_topology(CurveFacets* curve,
5700 : : const DLIList<CubitPoint*>& cubit_points, FacetEvalTool* surf_eval, CubitSense sense,
5701 : : std::map<CurveFacets*, DLIList<CubitFacetEdge*> >& facet_edge_map,
5702 : : std::map<FacetShapes*, GeometryEntity*>& entity_map)
5703 : : {
5704 : : // construct each point for the curves
5705 : :
5706 [ # # ]: 0 : for(size_t j=0; j<2; j++)
5707 : : {
5708 : 0 : VertexFacets* vertex_facets = curve->vertexTopology[j];
5709 [ # # ][ # # ]: 0 : if(entity_map.find(vertex_facets) == entity_map.end())
[ # # ]
5710 : : {
5711 : : TBPoint* new_vertex;
5712 [ # # ][ # # ]: 0 : make_facet_point(cubit_points[vertex_facets->point], new_vertex);
5713 [ # # ][ # # ]: 0 : entity_map.insert(std::make_pair(vertex_facets, new_vertex));
[ # # ]
5714 : : }
5715 : : }
5716 : :
5717 : : // construct the curve
5718 [ # # ][ # # ]: 0 : if(entity_map.find(curve) == entity_map.end())
[ # # ]
5719 : : {
5720 [ # # ]: 0 : DLIList<CubitFacetEdge*>& edge_list = facet_edge_map[curve];
5721 [ # # ]: 0 : DLIList<CubitPoint*> point_list;
5722 : :
5723 [ # # ][ # # ]: 0 : for(int k=0; k<edge_list.size(); k++)
5724 : : {
5725 [ # # ][ # # ]: 0 : point_list.append(edge_list[k]->point(0));
[ # # ]
5726 : : }
5727 [ # # ][ # # ]: 0 : point_list.append(edge_list[edge_list.size()-1]->point(1));
[ # # ][ # # ]
5728 : :
5729 [ # # ][ # # ]: 0 : CurveFacetEvalTool* curve_facet_tool = new CurveFacetEvalTool;
5730 [ # # ]: 0 : CubitStatus status = curve_facet_tool->initialize( edge_list, point_list, surf_eval);
5731 [ # # ]: 0 : if (CUBIT_SUCCESS != status) {
5732 [ # # ][ # # ]: 0 : PRINT_ERROR("Failed to intitialize a CurveFacetEvalTool.\n");
[ # # ][ # # ]
5733 : 0 : return;
5734 : : }
5735 : : Curve* curve_ptr;
5736 [ # # ]: 0 : make_facet_curve((TBPoint*)entity_map[curve->vertexTopology[0]],
5737 [ # # ]: 0 : (TBPoint*)entity_map[curve->vertexTopology[1]],
5738 [ # # ]: 0 : curve_ptr, curve_facet_tool);
5739 [ # # ][ # # ]: 0 : entity_map.insert(std::make_pair(curve, curve_ptr));
[ # # ][ # # ]
[ # # ]
5740 : : }
5741 [ + - ][ + - ]: 6540 : }
5742 : :
5743 : : // EOF
|
