Author: janehu Date: 2008-12-23 14:11:34 -0600 (Tue, 23 Dec 2008) New Revision: 2498 Added: cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2493 cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2494 Modified: cgm/trunk/geom/OCC/OCCModifyEngine.cpp Log: Modified to consider that the curves given in create_arc_three function can have multiple solutions or none solution. In multiple solution case, the first reasonable solution will be choosing. Modified: cgm/trunk/geom/OCC/OCCModifyEngine.cpp =================================================================== --- cgm/trunk/geom/OCC/OCCModifyEngine.cpp 2008-12-23 19:55:52 UTC (rev 2497) +++ cgm/trunk/geom/OCC/OCCModifyEngine.cpp 2008-12-23 20:11:34 UTC (rev 2498) @@ -4968,30 +4968,15 @@ vt3 = *intscts.get(); double u, u11, u12, u21, u22, u31, u32; - u12 = occ_crv1->u_from_position(vt1); - u11 = occ_crv1->u_from_position(vt3); - if(u12 < u11) - { - u = u12; - u12 = u11; - u11 = u; - } - u22 = occ_crv2->u_from_position(vt1); - u21 = occ_crv2->u_from_position(vt2); - if(u22 < u21) - { - u = u22; - u22 = u21; - u21 = u; - } - u32 = occ_crv3->u_from_position(vt2); - u31 = occ_crv3->u_from_position(vt3); - if(u32 < u31) - { - u = u32; - u32 = u31; - u31 = u; - } + occ_crv1->get_param_range(u11, u12); + occ_crv2->get_param_range(u21, u22); + occ_crv3->get_param_range(u31, u32); + + CubitVector pt1, pt2, pt3; + occ_crv1->position_from_u(u11, pt1); + occ_crv2->position_from_u(u21, pt2); + occ_crv3->position_from_u(u31, pt3); + CubitVector tangent1, tangent2, tangent3; occ_crv1->get_tangent(vt1, tangent1); occ_crv2->get_tangent(vt2, tangent2); @@ -5074,8 +5059,13 @@ OCCQueryEngine::instance()->get_intersections(curve3, vt1, p12, intscts,none,none); int_pt = *intscts.pop(); u = occ_crv3->u_from_position (int_pt); - assert(u >= u31-tol && u <= u32+tol); - int_pt1 = int_pt; + if(u >= u31-tol && u <= u32+tol) + int_pt1 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } } OCCQueryEngine::instance()->get_intersections(curve1, vt2, p21, intscts,none,none); @@ -5088,8 +5078,13 @@ OCCQueryEngine::instance()->get_intersections(curve1, vt2, p22, intscts,none,none); int_pt = *intscts.pop(); u = occ_crv1->u_from_position (int_pt); - assert(u >= u11-tol && u <= u12+tol); - int_pt2 = int_pt; + if(u >= u11-tol && u <= u12+tol) + int_pt2 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } } OCCQueryEngine::instance()->get_intersections(curve2, vt3, p31, intscts,none,none); @@ -5102,8 +5097,13 @@ OCCQueryEngine::instance()->get_intersections(curve2, vt3, p32, intscts,none,none); int_pt = *intscts.pop(); u = occ_crv2->u_from_position (int_pt); - assert(u >= u21-tol && u <= u22+tol); - int_pt3 = int_pt; + if(u >= u21-tol && u <= u22+tol) + int_pt3 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } } //4. use the 3 intersection points to find the arc or circle. OCCPoint occ_p1(int_pt1); Copied: cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2493 (from rev 2493, cgm/trunk/geom/OCC/OCCModifyEngine.cpp) =================================================================== --- cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2493 (rev 0) +++ cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2493 2008-12-23 20:11:34 UTC (rev 2498) @@ -0,0 +1,5632 @@ +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- + +// Filename : OCCModifyEngine.cpp +// +// Purpose : ModifyEngine for OCC geometry +// +// Special Notes : Modeled after GeometryModifyEngine and AcisModifyEngine. +// +// Author : Jane Hu +// +// Creation Date : 1/08 +// +//------------------------------------------------------------------------- +#include "gp_Pnt.hxx" +#include "gp_Ax2.hxx" +#include "gp_Dir.hxx" +#include "gp_Hypr.hxx" +#include "gp_Parab.hxx" +#include "gp_Elips.hxx" +#include "gp_Pln.hxx" +#include "gp_Cylinder.hxx" +#include "gp_Cone.hxx" +#include "gp_Sphere.hxx" +#include "gp_Torus.hxx" +#include "BRepBuilderAPI_MakeShell.hxx" +#include "BRepBuilderAPI_MakeSolid.hxx" +#include "BRepOffsetAPI_MakeDraft.hxx" +#include "BRepBuilderAPI_TransitionMode.hxx" +#include "BRepBuilderAPI_MakeWire.hxx" +#include "BRepPrimAPI_MakeHalfSpace.hxx" +#include "BRepBndLib.hxx" +#include "TopoDS_Shape.hxx" +#include "TopAbs_Orientation.hxx" +#include "TColgp_Array1OfPnt.hxx" +#include "GC_MakeArcOfCircle.hxx" +#include "GC_MakeCircle.hxx" +#include "GC_MakeArcOfHyperbola.hxx" +#include "GC_MakeArcOfParabola.hxx" +#include "GC_MakeArcOfEllipse.hxx" +#include "GC_MakeSegment.hxx" +#include "GC_MakeTrimmedCone.hxx" +#include "GC_MakeTrimmedCylinder.hxx" +#include "gce_MakeElips.hxx" +#include "Geom_BezierCurve.hxx" +#include "BndLib_AddSurface.hxx" +#include "Handle_Geom_Plane.hxx" +#include "BRepExtrema_DistShapeShape.hxx" +#include "Extrema_ExtPC.hxx" +#include "BRepPrimAPI_MakePrism.hxx" +#include "BRepSweep_Revol.hxx" +#include "BRepPrimAPI_MakeCone.hxx" +#include "BRepOffsetAPI_ThruSections.hxx" +#include "BRepLib_FuseEdges.hxx" +#include "BRepOffsetAPI_MakePipe.hxx" +#include "BRepPrimAPI_MakeTorus.hxx" +#include "BRepPrimAPI_MakeCylinder.hxx" +#include "BRepBuilderAPI_Transform.hxx" +#include "BRepAdaptor_Curve.hxx" +#include "GC_MakeEllipse.hxx" +#include "BRepBuilderAPI_MakeEdge.hxx" +#include "BRepAdaptor_Surface.hxx" +#include "BRepBuilderAPI_MakeFace.hxx" +#include "BRepOffsetAPI_MakeThickSolid.hxx" +#include "BRepBuilderAPI_Sewing.hxx" +#include "BRepBuilderAPI_Copy.hxx" +#include "LocOpe_SplitShape.hxx" +#include "BRep_Tool.hxx" +#include "BRep_Builder.hxx" +#include "GProp_GProps.hxx" +#include "BRepGProp.hxx" +#include "TopoDS.hxx" +#include "TopologyBridge.hpp" +#include "ProgressTool.hpp" +#include "BRepAlgoAPI_Fuse.hxx" +#include "BRepAlgoAPI_Cut.hxx" +#include "BRepAlgoAPI_Section.hxx" +#include "BRepAlgoAPI_Common.hxx" +#include "BRepPrimAPI_MakeSphere.hxx" +#include "BRepPrimAPI_MakeBox.hxx" +#include "BRepPrimAPI_MakeWedge.hxx" +#include "BRepTools_WireExplorer.hxx" +#include "Handle_Geom_TrimmedCurve.hxx" +#include "Handle_Geom_RectangularTrimmedSurface.hxx" +#include "BndLib_Add3dCurve.hxx" +#include "TopOpeBRep_EdgesIntersector.hxx" +#include "TopExp_Explorer.hxx" +#include "TopExp.hxx" +#include "OCCModifyEngine.hpp" +#include "OCCQueryEngine.hpp" +#include "OCCCoFace.hpp" +#include "CubitMessage.hpp" +#include "CubitDefines.h" +#include "TopTools_DataMapOfShapeInteger.hxx" +#include "BRepFeat_SplitShape.hxx" +#include "TopOpeBRep_ShapeIntersector.hxx" +#include "TopTools_ListIteratorOfListOfShape.hxx" +#include "CubitUtil.hpp" +#include "CubitPoint.hpp" +#include "CubitPointData.hpp" +#include "CubitFacet.hpp" +#include "CubitQuadFacet.hpp" +#include "CubitFacetData.hpp" +#include "CubitFacetEdge.hpp" +#include "CubitFacetEdgeData.hpp" +#include "GeometryQueryTool.hpp" +#include "GeometryModifyTool.hpp" +#include "ChollaSurface.hpp" +#include "ChollaCurve.hpp" +#include "ChollaPoint.hpp" +#include "OCCPoint.hpp" +#include "OCCCurve.hpp" +#include "CurveFacetEvalTool.hpp" +#include "FacetEvalTool.hpp" +#include "OCCCoEdge.hpp" +#include "OCCLoop.hpp" +#include "OCCSurface.hpp" +#include "OCCShell.hpp" +#include "OCCLump.hpp" +#include "OCCBody.hpp" +#include "ChollaEngine.hpp" +#include "TDGeomFacet.hpp" +#include "CubitFileIOWrapper.hpp" +#include "TDFacetBoundaryPoint.hpp" +#include "Cholla.h" +#include "Body.hpp" +#include "GfxDebug.hpp" +#include "RefFace.hpp" +#include "FacetDataUtil.hpp" +#include "FBDataUtil.hpp" +#include "FBIntersect.hpp" +#include "IntegerHash.hpp" +#include "CpuTimer.hpp" +#include "AppUtil.hpp" +#include "SphereEvaluator.hpp" +#include "CylinderEvaluator.hpp" +#include <vector> +OCCModifyEngine* OCCModifyEngine::instance_ = 0; +#define DEBUG +//=============================================================================== +// Function : OCCModifyEngine +// Member Type: PUBLIC +// Description: constructor +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +OCCModifyEngine::OCCModifyEngine() +{ +// assert( !instance_ ); + + // add this modify engine to geometrymodifytool + GeometryModifyTool::instance()->add_gme(this); +} + + +//=============================================================================== +// Function : ~OCCModifyEngine +// Member Type: PUBLIC +// Description: destructor +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +OCCModifyEngine::~OCCModifyEngine() +{ + instance_ = 0; +} + +//=============================================================================== +// Function : make_Point +// Member Type: PUBLIC +// Description: make a geometric entity point +// Author : Jane Hu +// Date : 10/07 +//=============================================================================== +Point* OCCModifyEngine::make_Point( CubitVector const& point) const +{ + gp_Pnt pt = gp_Pnt( point.x(), point.y(), point.z()); + TopoDS_Vertex theVertex = BRepBuilderAPI_MakeVertex(pt); + + // Create a new PointACIS object + return OCCQueryEngine::instance()->populate_topology_bridge( theVertex ); +} + +//=============================================================================== +// Function : make_Curve +// This function creates a curve given an existing curve, copy. +// Member Type: PUBLIC +// Description: make a curve +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve(Curve * curve_ptr) const +{ + OCCCurve* occ_curve = CAST_TO(curve_ptr, OCCCurve); + if (!occ_curve) + { + PRINT_ERROR("Cannot create an OCC curve from the given curve.\n" + "Possible incompatible geometry engines.\n"); + return (Curve *)NULL; + } + + TopoDS_Edge *theEdge = occ_curve->get_TopoDS_Edge(); + + BRepBuilderAPI_Copy api_copy(*theEdge); + + TopoDS_Shape newShape = api_copy.ModifiedShape(*theEdge); + + TopoDS_Edge newEdge = TopoDS::Edge(newShape); + + return OCCQueryEngine::instance()->populate_topology_bridge(newEdge); +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a curve by projecting a straight line defined by +// point1_ptr, and point2_ptr onto face_ptr, third_point +// is used for curves that could be periodic to dertermine +// the correct direction. +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( Point const* point1_ptr, + Point const* point2_ptr, + Surface* face_ptr, + const CubitVector * third_point) const +{ + assert (point1_ptr != NULL && point2_ptr != NULL); + GeometryType type = STRAIGHT_CURVE_TYPE; + CubitBoolean closed = CUBIT_FALSE; + DLIList<CubitVector*> mid_points; + Curve* curve = NULL; + if (point1_ptr != point2_ptr) + curve = make_Curve(type, point1_ptr, point2_ptr, mid_points); + else //could be a closed shape + { + if(third_point != NULL && face_ptr != NULL) + { + closed = CUBIT_TRUE; + Point * Pnt = make_Point(*third_point); + curve = make_Curve(type, point1_ptr, Pnt, mid_points); + } + else + { + PRINT_ERROR("Cannot create an OCC curve from the given duplicated points.\n"); + return (Curve *)NULL; + } + } + + Curve* new_curve = NULL; + if(face_ptr == NULL) + return curve; + + DLIList<Point*> points; + new_curve = + CAST_TO(curve, OCCCurve)->project_curve(face_ptr, points, closed, third_point); + + delete curve; + return new_curve; +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a spline curve by using the points on surface. +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( GeometryType curve_type, + Point const* point1_ptr, + Point const* point2_ptr, + DLIList<CubitVector*>& vector_list, + Surface* face_ptr) const +{ + assert(point1_ptr != NULL && point2_ptr != NULL); + + if (curve_type != SPLINE_CURVE_TYPE + && curve_type != STRAIGHT_CURVE_TYPE) + { + PRINT_ERROR("Cannot create an OCC curve from the given curve_type.\n" + "Candidates are SPLINE_CURVE_TYPE and STRAIGHT_CURVE_TYPE.\n"); + return (Curve *)NULL; + } + + if (curve_type == STRAIGHT_CURVE_TYPE) + return make_Curve(curve_type, point1_ptr, point2_ptr, NULL, CUBIT_FORWARD); + + OCCPoint* occ_point1 = CAST_TO(const_cast<Point*>(point1_ptr), OCCPoint); + OCCPoint* occ_point2 = CAST_TO(const_cast<Point*>(point2_ptr), OCCPoint); + + if (occ_point1 == NULL || occ_point2 == NULL) + { + PRINT_ERROR("Cannot create an OCC curve from the given points.\n" + "Possible incompatible geometry engines.\n"); + return (Curve *)NULL; + } + + //project all points on the surface if possible + OCCSurface* occ_face = NULL; + if (face_ptr != NULL) + occ_face = CAST_TO(face_ptr, OCCSurface); + + gp_Pnt pt; + int size = 2+vector_list.size(); + TColgp_Array1OfPnt points(1, size); + CubitVector* vector = NULL; + CubitVector closest_location; + for(int i = 1; i <= size; i++) + { + if (i == 1) + { + TopoDS_Vertex *point = occ_point1->get_TopoDS_Vertex(); + pt = BRep_Tool::Pnt(*point); + vector = new CubitVector(point1_ptr->coordinates()); + } + else if (i == size) + { + TopoDS_Vertex *point = occ_point2->get_TopoDS_Vertex(); + pt = BRep_Tool::Pnt(*point); + vector = new CubitVector(point2_ptr->coordinates()); + } + else + { + vector = vector_list.get_and_step(); + pt.SetCoord(vector->x(), vector->y(), vector->z()); + } + + if (occ_face != NULL) + { + occ_face->closest_point(*vector, &closest_location); + pt.SetCoord(closest_location.x(), closest_location.y(), closest_location.z()) ; + } + + points.SetValue(i, pt); + } + + //make curve according to the curve type. + if(curve_type == SPLINE_CURVE_TYPE) + { + Geom_BezierCurve BezierCurve(points); + Geom_BezierCurve* curve = new Geom_BezierCurve(BezierCurve); + Handle(Geom_BoundedCurve) curve_ptr(curve); + TopoDS_Vertex * vt1 = occ_point1->get_TopoDS_Vertex(); + TopoDS_Vertex * vt2 = occ_point2->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt2); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); + } + + return (Curve*) NULL; +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a curve +// For STRAIGHT_CURVE_TYPE: +// intermediate_point_ptr is not used +// +// For PARABOLA_CURVE_TYPE +// intermediate_point_ptr is the tip of the parabola +// +// For HYPERBOLA_CURVE_TYPE +// intermediate_point_ptr is the center of its two foci +// +// For ELLIPSE_CURVE_TYPE +// intermediate_point_ptr is the center of the ellipse +// the two points are vertices, one gives the major radius, +// the other point gives the minor radius. +// sense is used to determine which part of the ellipse is required +// +// For ARC_CURVE_TYPE +// arc passes three points +// +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( GeometryType curve_type, + Point const* point1_ptr, + Point const* point2_ptr, + CubitVector const* intermediate_point_ptr, + CubitSense sense) const +{ + assert (point1_ptr != NULL && point2_ptr != NULL); + DLIList<CubitVector*> mid_points; + if (intermediate_point_ptr) + { + CubitVector mid_point = *intermediate_point_ptr; + mid_points.append(&mid_point); + } + + CubitVector v1(point1_ptr->coordinates()); + CubitVector v2(point2_ptr->coordinates()); + + gp_Pnt pt1(v1.x(),v1.y(), v1.z()); + gp_Pnt pt2(v2.x(),v2.y(), v2.z()); + + CubitVector v3; + gp_Pnt pt3; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + + Handle(Geom_TrimmedCurve) curve_ptr; + if(intermediate_point_ptr != NULL) + { + v3 = *intermediate_point_ptr; + pt3.SetCoord(v3.x(),v3.y(), v3.z()); + } + + if (curve_type == STRAIGHT_CURVE_TYPE) + curve_ptr = GC_MakeSegment(pt1,pt2); + + else if (curve_type == ARC_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + curve_ptr = GC_MakeArcOfCircle(pt1, pt3, pt2); + } + + else if (curve_type == ELLIPSE_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + + gp_Pnt center(v3.x(), v3.y(), v3.z()); + + gp_Elips ellipse; + gce_MakeElips ellipse1(pt1 , pt2 , center); + if(ellipse1.IsDone()) + ellipse = ellipse1.Value(); + else if(!ellipse1.IsDone() && ellipse1.Status() == gce_InvertRadius) + { + gce_MakeElips ellipse2(pt2, pt1, center); + if(ellipse2.IsDone()) + ellipse = ellipse2.Value(); + else + { + PRINT_ERROR("Can't create an ellipse from give 3 points.\n"); + return (Curve *)NULL; + } + } + else + { + PRINT_ERROR("Can't create an ellipse from give 3 points.\n"); + return (Curve *)NULL; + } + CubitBoolean use_sense = (sense == CUBIT_FORWARD ? CUBIT_TRUE : CUBIT_FALSE); + curve_ptr = GC_MakeArcOfEllipse(ellipse, pt1, pt2, use_sense); + } + + else if(curve_type == PARABOLA_CURVE_TYPE || + curve_type == HYPERBOLA_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + + //find the directrix and focus of the parabola + //or the axis, major radius and minor radius of the hyperbola + CubitVector width_vec = v2 - v1; + if(width_vec.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "2 end points are the same.\n"); + return (Curve *)NULL; + } + + CubitVector midpoint_vec = (v1 + v2)/2.0; + CubitVector height_vec = midpoint_vec - v3; + gp_Pnt center(v3.x(), v3.y(), v3.z()); + + if (height_vec.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "3 points are in the same line.\n"); + return (Curve *)NULL; + } + CubitVector x = height_vec; + x.normalize(); + gp_Dir x_dir(x.x(), x.y(), x.z()); + + CubitVector N = x * (v2 - v1); + if (N.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "3 points are in the same line.\n"); + return (Curve *)NULL; + } + N.normalize(); + gp_Dir N_dir(N.x(), N.y(), N.z()); + + gp_Ax2 axis(center, N_dir, x_dir); + + if(curve_type == HYPERBOLA_CURVE_TYPE) + { + // (focus2) (v3) . (v2) + // . . . (midpoint = focus1) + // . (v1) + CubitVector focus2 = 2 * v3 - midpoint_vec; + + //according to the definition of hyperbola, + //2 * a = length(v2 - focus2)-length(v2 - focus1) + + double major = (v2 - focus2).length()/2.0 - (v2 - midpoint_vec).length()/2.0; + + // if a = 1/2 length major axis, b = 1/2 length minor axis and + // c = distance center to focus, then a*a + b*b = c*c + + double c_squared = (midpoint_vec - v3).length_squared(); + double minor = sqrt(c_squared - major*major ); + gp_Hypr hypt(axis, major, minor); + curve_ptr = + GC_MakeArcOfHyperbola(hypt, pt1, pt2, CUBIT_TRUE); + } + + else + { + // Find the focus of this parabola. + // Since for a parabola with its peak at the origin, y = (1/(4*a))*x^2, + // and since we have restricted this parabola to be symmetric (per the + // FastQ method, see the FastQ file getwt.f), we can use the following + // relationship to + // determine "a", the distance the focus lies from the peak on the line + // formed by the peak and the midpoint of the start and end points` + double a = width_vec.length_squared()/(16. * height_vec.length()); + gp_Parab parab(axis, a); + curve_ptr = + GC_MakeArcOfParabola(parab, pt1, pt2, CUBIT_TRUE); + } + } + + else + { + PRINT_ERROR("In OCCModifyEngine::make_Curve\n" + " Invalid curve type.\n"); + return (Curve *)NULL; + } + + OCCPoint* occ_pt1 = CAST_TO(const_cast<Point*>(point1_ptr),OCCPoint); + OCCPoint* occ_pt2 = CAST_TO(const_cast<Point*>(point2_ptr),OCCPoint); + TopoDS_Vertex * vt1 = occ_pt1->get_TopoDS_Vertex(); + TopoDS_Vertex * vt2 = occ_pt2->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt2); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); +} + +//=============================================================================== +// Function : make_Surface +// This function creates a surface given an existing surface, copy. +// Member Type: PUBLIC +// Description: make a surface, OCC allows to create a stand along surface, +// however the CGM has a design of making all surfaces in a (sheet) +// body. This will add complexity on all free surface related +// calculation and modification, and adding potential bugs too. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Surface* OCCModifyEngine::make_Surface( Surface * surface_ptr, + CubitBoolean extended_from) const +{ + OCCSurface* occ_surface = CAST_TO(surface_ptr, OCCSurface); + if (!occ_surface) + { + PRINT_ERROR("Cannot create an OCC surface from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (Surface *)NULL; + } + + //Start of the codes + double UMax, VMax, UMin, VMin; + occ_surface->get_param_range_U(UMin, UMax); + occ_surface->get_param_range_V(VMin, VMax); + + TopoDS_Face *theFace = occ_surface->get_TopoDS_Face(); + if( !theFace) + { + PRINT_ERROR("Cannot create an OCC surface from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (Surface *)NULL; + } + + TopoDS_Face newFace; + BRepAdaptor_Surface asurface(*theFace); + + CubitBox bounding_box = GeometryQueryTool::instance()->model_bounding_box(); + double const height = 2*(bounding_box.diagonal()).length(); + CubitBox box = occ_surface->bounding_box(); + double ratio = height/(box.diagonal().length()); + + double middleU = (UMin + UMax)/2.0; + double middleV = (VMin + VMax)/2.0; + double U1 = middleU - (UMax-UMin)/2.0 * ratio; + double U2 = middleU + (UMax-UMin)/2.0 * ratio; + double V1 = middleV - (VMax - VMin)/2.0 * ratio; + double V2 = middleV + (VMax - VMin)/2.0 * ratio; + + if (extended_from == CUBIT_TRUE) + { + // We need to get the type of surface. + GeometryType type = occ_surface->geometry_type(); + if (type == PLANE_SURFACE_TYPE) + { + gp_Pln plane = asurface.Plane(); + newFace = BRepBuilderAPI_MakeFace(plane, U1, U2, V1, V2); + } + else if(type == CONE_SURFACE_TYPE) + { + //make an infinite cone. + //Given this lets create another face that is extended from it. + if(asurface.GetType() == GeomAbs_Cone) + { + gp_Cone cone = asurface.Cone(); + gp_Pnt Apex = cone.Apex(); + double semi_angle = cone.SemiAngle(); + gp_Pnt p2; + double radius2; + gp_XYZ xyz; + if (semi_angle > 0) + xyz = Apex.XYZ() + cone.Position().Direction().XYZ()*height; + + else + xyz = Apex.XYZ() - cone.Position().Direction().XYZ()*height; + + p2.SetXYZ(xyz); + radius2 = height * tan(fabs(semi_angle)); + Handle(Geom_RectangularTrimmedSurface) trimmed_cone; + trimmed_cone = GC_MakeTrimmedCone(Apex, p2, 0, radius2); + newFace = BRepBuilderAPI_MakeFace(trimmed_cone); + } + else + { + gp_Cylinder cylinder = asurface.Cylinder(); + //gp_Pnt pnt = asurface.Value(UMin,V1); + double radius = cylinder.Radius(); + gp_Ax1 axis = cylinder.Axis(); + Handle(Geom_RectangularTrimmedSurface) trimmed_cyl; + trimmed_cyl = GC_MakeTrimmedCylinder(axis, radius, height); + newFace = BRepBuilderAPI_MakeFace(trimmed_cyl); + } + } + else if(type == SPHERE_SURFACE_TYPE) + { + //make a whole sphere. + gp_Sphere sphere = asurface.Sphere(); + newFace = BRepBuilderAPI_MakeFace(sphere); + } + else if(type == TORUS_SURFACE_TYPE) + { + //make a whole torus + gp_Torus torus = asurface.Torus(); + newFace = BRepBuilderAPI_MakeFace(torus); + } + else if(type == SPLINE_SURFACE_TYPE ) + { + //extend the surfaces using the equation if possible. + Handle(Geom_BezierSurface) bezier = asurface.Bezier(); + newFace = BRepBuilderAPI_MakeFace(bezier, U1, U2, V1, V2); + } + } + + else + { + BRepBuilderAPI_Copy api_copy(*theFace); + TopoDS_Shape newShape = api_copy.ModifiedShape(*theFace); + newFace = TopoDS::Face(newShape); + } + + Surface *surface = OCCQueryEngine::instance()->populate_topology_bridge( + newFace, CUBIT_TRUE); + + return surface; +} + +//=============================================================================== +// Function : make_Surface +// Member Type: PUBLIC +// Description: make a surface of type surface_type, given the list of curves. +// check edges option is done in GeometryModifyTool level, so +// disregard this option. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Surface* OCCModifyEngine::make_Surface( GeometryType surface_type, + DLIList<Curve*>& curve_list, + Surface * old_surface_ptr, + bool check_edges) const +{ + //Create TopoDS_Edge list to make a surface. + DLIList<DLIList<TopoDS_Edge*>*> topo_edges_loops; + curve_list.reset() ; + + //check no intersections of the TopoDS_Edge's. + //need to check that no intersection in the middle of the curves, not at + //vertices or out of boundary. + + int count = 0; //intersection point should be the same as curve_list size. + for ( int i = 0 ; i < curve_list.size()-1 ; i++ ) + { + for(int j = i+1; j < curve_list.size(); j ++) + { + DLIList<CubitVector*> intscts; + CubitBoolean bounded = CUBIT_TRUE;//dummy arg. + CubitBoolean closest = CUBIT_TRUE;//dummy arg. + CubitStatus yes_int = + OCCQueryEngine::instance()->get_intersections(curve_list[i], + curve_list[j], intscts, bounded, closest); + if(yes_int) + { + //check intscts point should be vertex or outside boundary. + if (intscts.size() > 2 ) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + else + { + for(int k = 0; k < intscts.size(); k++) + { + CubitVector *v = intscts.get_and_step(); + CubitPointContainment is_on = CAST_TO(curve_list[i],OCCCurve)-> + point_containment(*v); + if (is_on == CUBIT_PNT_BOUNDARY) + { + is_on = CAST_TO(curve_list[j],OCCCurve)-> + point_containment(*v); + if (is_on == CUBIT_PNT_BOUNDARY) + count++; + } + else if(is_on == CUBIT_PNT_INSIDE) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + } + } + } + } + } + + if (count > curve_list.size()) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + + CubitStatus stat = sort_curves(curve_list, topo_edges_loops); + if( stat == CUBIT_FAILURE ) //case of one disconnected curve + return (Surface*) NULL; + + // Use the topo_edges to make a topo_face + TopoDS_Face* topo_face; + topo_face = make_TopoDS_Face(surface_type,topo_edges_loops, old_surface_ptr); + + for (int i = 0; i < topo_edges_loops.size(); i++) + { + DLIList<TopoDS_Edge*>* topo_edges = topo_edges_loops.get_and_step(); + for(int j = 0; j < topo_edges->size(); j++) + topo_edges->pop(); + delete topo_edges; + } + + if(!topo_face) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface object.\n"); + return (Surface *)NULL; + } + + // make the topology bridges for the face + Surface *surface = OCCQueryEngine::instance()->populate_topology_bridge( + *topo_face, CUBIT_TRUE); + topo_face->Nullify(); + delete topo_face; + return surface ; +} + +//=============================================================================== +// Function : sort_curves +// Member Type: PROTECTED +// Description: sort the curves so they are in order and make closed loop +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::sort_curves(DLIList<Curve*> curve_list, + DLIList<DLIList<TopoDS_Edge*>*>& topo_edges_loops)const +{ + topo_edges_loops.clean_out(); + CubitStatus stat = CUBIT_SUCCESS; + std::vector< DLIList<TopoDS_Edge*>* > topo_edges(curve_list.size()); + int size_in = curve_list.size(); + for(int i = 0; i < size_in; i++) + topo_edges[i] = new DLIList<TopoDS_Edge*>; + + curve_list.reset() ; + Curve const* curve_ptr = NULL ; + OCCCurve* occ_curve = NULL; + TopoDS_Edge* topo_edge = NULL; + + OCCPoint* start = NULL; + OCCPoint* end = NULL; + DLIList<OCCPoint*> point_list; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + CubitBoolean new_end; + int size = curve_list.size(); + + int count = 0; + for ( int i = 0 ; i < size ; i++ ) + { + if (i == 0) + new_end = CUBIT_TRUE; + for(int j = 0; j < curve_list.size(); j ++) + { + curve_ptr = curve_list.get() ; + occ_curve = CAST_TO(const_cast<Curve*>(curve_ptr), OCCCurve); + + if(occ_curve == NULL) + { + PRINT_ERROR("In OCCModifyEngine::sort_curves\n" + " Got a NULL pointer to OCCCurve\n") ; + return CUBIT_FAILURE; + } + + point_list.clean_out(); + occ_curve->get_points(point_list); + //assert(point_list.size()==2); + + if (i == 0) + { + start = point_list.get(); + end = point_list.pop(); + break; + } + + if(end->is_equal(*(point_list.get()), tol) || + end->is_equal(*(point_list.step_and_get()),tol)) + { + end = point_list.step_and_get(); + new_end = CUBIT_TRUE; + break; + } + + else if(start->is_equal(*(point_list.get()), tol) || + start->is_equal(*(point_list.step_and_get()),tol)) + { + start = end; + end = point_list.step_and_get(); + new_end = CUBIT_TRUE; + break; + } + curve_list.step(); + } + + if (new_end)//found next curve + { + topo_edge = occ_curve->get_TopoDS_Edge(); + topo_edges[count]->append(topo_edge); + curve_list.remove(); + if(start->is_equal( *end, tol)) //formed a closed loop + { + i = -1; + size = curve_list.size() ; + topo_edges_loops.append(topo_edges[count]); + count++; + } + else + new_end = CUBIT_FALSE; + } + else + { + stat = CUBIT_FAILURE; + i = -1; + size = curve_list.size(); + topo_edges_loops.append(topo_edges[count]); + count++; + } + } + + if( new_end == CUBIT_FALSE ) //case of one disconnected curve + { + topo_edges_loops.append(topo_edges[count]); + stat = CUBIT_FAILURE; + } + + for(int i = 0; i < size_in; i++) + { + if(topo_edges[i]->size() == 0) + delete topo_edges[i]; + } + return stat; +} +//=============================================================================== +// Function : make_TopoDS_Face +// Member Type: PROTECTED +// Description: make a opoDS_Face of type surface_type, given the list of +// TopoDS_Edge. the TopoDS_Edge's should be in order in loops. +// check edges option is done in GeometryModifyTool level, so +// disregard this option. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +TopoDS_Face* OCCModifyEngine::make_TopoDS_Face(GeometryType surface_type, + DLIList<DLIList<TopoDS_Edge*>*> topo_edges_list, + Surface * old_surface_ptr)const +{ + TopoDS_Face* topo_face = NULL; + // Make sure a supported type of surface is being requested. + if ( surface_type != PLANE_SURFACE_TYPE && + surface_type != BEST_FIT_SURFACE_TYPE) + { + PRINT_WARNING("In OCCGeometryEngine::make_TopoDS_Face\n" + " At this time, cannot make a TopoDS_Face that isn't" + " planar or best fit.\n"); + return topo_face; + } + + // Set the TopoDS_Face pointer, if requested. + TopoDS_Face *fit_Face = NULL; + Handle_Geom_Surface S; + if ( old_surface_ptr != NULL ) + { + OCCSurface *surf = CAST_TO(old_surface_ptr, OCCSurface ); + fit_Face = surf->get_TopoDS_Face(); + S = BRep_Tool::Surface(*fit_Face); + } + + // Make a wire from the topo_edges. + // Coincident TopoDS_Vertex will be deleted by OCC. + if(topo_edges_list.size() == 0) + return topo_face; + + DLIList<TopoDS_Wire*> wires; + GProp_GProps myProps; + double max_area = 0.0; + TopoDS_Wire* out_Wire = NULL; + TopoDS_Wire test_Wire; + DLIList<TopoDS_Edge*>* topo_edges; + //check and make sure the outer loop is in the first + for(int i = 0; i < topo_edges_list.size() ; i++) + { + topo_edges = topo_edges_list.get_and_step(); + BRepBuilderAPI_MakeWire aWire(*(topo_edges->get())); + for(int j = 1; j < topo_edges->size(); j++) + aWire.Add(*(topo_edges->step_and_get())); + + test_Wire = aWire.Wire(); + wires.append(&test_Wire); + + if (topo_edges_list.size() == 1) + break; + + BRepBuilderAPI_MakeFace made_face(test_Wire); + + if (!made_face.IsDone()) + { + PRINT_ERROR("In OCCModifyEngine::make_TopoDS_Face\n" + " Cannot find the best fit surface for given curves.\n"); + return topo_face; + } + TopoDS_Face test_face = made_face.Face(); + BRepGProp::SurfaceProperties(test_face, myProps); + double area = myProps.Mass(); + out_Wire = max_area > area ? out_Wire : &test_Wire; + max_area = max_area > area ? max_area : area; + } + + if (out_Wire) + { + wires.remove(out_Wire); + wires.insert_first(out_Wire); + } + + //create the TopoDS_Face + CubitBoolean error = CUBIT_FALSE; + + for(int i = 0; i < topo_edges_list.size() ; i++) + { + TopoDS_Wire *the_wire = wires.get_and_step(); + if (i == 0) + { + if( old_surface_ptr != NULL ) + { + BRepBuilderAPI_MakeFace made_face(S, *the_wire); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + topo_face = new TopoDS_Face(made_face.Face()); + } + else + { + CubitBoolean is_planar = (surface_type == PLANE_SURFACE_TYPE ? + CUBIT_TRUE : CUBIT_FALSE); + BRepBuilderAPI_MakeFace made_face(*the_wire, is_planar); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + + topo_face = new TopoDS_Face(made_face.Face()); + } + } + else + { + BRepBuilderAPI_MakeFace made_face(*topo_face, *the_wire); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + delete topo_face; + topo_face = new TopoDS_Face(made_face.Face()); + } + } + + if(error) + { + PRINT_ERROR("In OCCModifyEngine::make_TopoDS_Face\n" + " Cannot find the best fit surface for given curves.\n"); + return (TopoDS_Face*) NULL; + } + + return topo_face; +} +//=============================================================================== +// Function : make_Lump +// Member Type: PUBLIC +// Description: make a lump of one shell +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Lump* OCCModifyEngine::make_Lump( DLIList<Surface*>& surface_list ) const +{ + if (surface_list.size() < 2) + return (Lump*) NULL; + + //all surfaces should be stand along surface bodies or shell bodies' surface + DLIList<BodySM*> body_list; + for(int i = 0; i < surface_list.size(); i++) + { + OCCSurface* occ_surface = CAST_TO(surface_list.get_and_step(), OCCSurface); + if (occ_surface == NULL) + { + PRINT_ERROR("Cannot create an OCC lump from the given surfaces.\n" + "Possible incompatible geometry engines.\n"); + return (Lump *)NULL; + } + OCCBody* occ_body = occ_surface->my_body(); + if(occ_body && occ_body->my_sheet_surface() == NULL) + { + PRINT_ERROR("Cannot create an OCC lump from the given surfaces.\n" + "The surfaces are not free.\n"); + return (Lump *)NULL; + } + else if(!occ_body) + { + OCCShell* shell = occ_surface->my_shell(); + if(!shell) + { + PRINT_ERROR("This is a bug, please report it. \n"); + return (Lump*)NULL; + } + occ_body = shell->my_body(); + } + body_list.append_unique(occ_body); + } + + TopoDS_Shape aShape; + CubitStatus stat = stitch_surfs(body_list, aShape); + if(!stat) + { + PRINT_ERROR("The surfaces are not all connected, can't make a lump. \n"); + return (Lump*)NULL; + } + + TopExp_Explorer Ex, Ex2; + TopoDS_Shell aShell ; + for (Ex.Init(aShape, TopAbs_SHELL, TopAbs_SOLID); Ex.More()&& stat; Ex.Next()) + aShell = TopoDS::Shell(Ex.Current()); + + //check to make sure the aShell is closed. + int num_edges = 0; + int pairs = 0; + //sometimes there's duplicate TopoDS_Edges in the shell. + DLIList<TopoDS_Edge*> edge_list; + for (Ex.Init(aShell, TopAbs_EDGE); Ex.More()&& stat; Ex.Next()) + { + TopoDS_Edge edge1 = TopoDS::Edge(Ex.Current()); + TopoDS_Edge* new_edge = new TopoDS_Edge(edge1); + edge_list.append(new_edge); + } + + int size = edge_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Edge edge1 = *edge_list[i]; + int same = 0; + for (int j = i+1; j < edge_list.size(); j++) + { + TopoDS_Edge edge2 = *edge_list[j]; + if(edge1.IsEqual(edge2)) + { + same ++; + edge_list.remove(&edge1); + i--; + size--; + break; + } + } + if(same > 0) + continue; + + else + num_edges++; + + for (int j = 0; j < size; j++) + { + TopoDS_Edge edge2 = *edge_list[j]; + if (!edge1.IsEqual(edge2)&& edge1.IsSame(edge2)) + { + pairs++; + break; + } + } + } + + for (int k = 0; k < edge_list.size(); k++) + { + TopoDS_Edge* edge = edge_list.get_and_step(); + edge->Nullify(); + delete edge; + } + + if (num_edges == pairs ) + aShell.Closed(CUBIT_TRUE); + + else + PRINT_ERROR("Surfaces must make a water-tight shape to make a lump.\n"); + + if(aShell.Closed()) + { + BRepBuilderAPI_MakeSolid aMakeSolid(aShell); + if (!aMakeSolid.IsDone()) + { + PRINT_ERROR("Cannot create an OCC Lump from the given surfaces.\n" + "OCC internal error.\n"); + return (Lump *)NULL; + } + + TopoDS_Solid aSolid = aMakeSolid.Solid(); + + return + OCCQueryEngine::instance()->populate_topology_bridge(aSolid, CUBIT_TRUE); + } + + return (Lump*) NULL; +} + +//=============================================================================== +// Function : make_BodySM +// Member Type: PUBLIC +// Description: make a BodySM from a surface +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +BodySM* OCCModifyEngine::make_BodySM( Surface *surface ) const +{ + OCCSurface* occ_surface = CAST_TO(surface, OCCSurface); + if(!occ_surface) + { + PRINT_ERROR("Cannot create an OCC body from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + + OCCBody* occ_body = occ_surface->my_body(); + if(occ_body) + return occ_body; + + TopoDS_Face* face = occ_surface->get_TopoDS_Face(); + surface = OCCQueryEngine::instance()->populate_topology_bridge(*face, CUBIT_TRUE); + + return CAST_TO(surface, OCCSurface)->my_body(); +} + + + +//=============================================================================== +// Function : make_BodySM +// Member Type: PUBLIC +// Description: make a BodySM given a list of Lumps. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +BodySM* OCCModifyEngine::make_BodySM( DLIList<Lump*>& lump_list ) const +{ + if (lump_list.size() == 0) + return (BodySM*) NULL; + + //Create a compsolid shape, copy all BodySM's solids to create new compbody + DLIList<BodySM*> bodysm_list; + TopoDS_CompSolid CS; + BRep_Builder B; + B.MakeCompSolid(CS); + + //Add every shape to the CompSolid + for(int i = 0; i < lump_list.size(); i++) + { + Lump* lump = lump_list.get_and_step(); + OCCLump* occ_lump = CAST_TO(lump, OCCLump); + if(!occ_lump) + { + PRINT_ERROR("Cannot create an OCC BodySM from the given lumps.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + TopoDS_Solid* solid = occ_lump->get_TopoDS_Solid(); + BRepBuilderAPI_Copy api_copy(*solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(*solid); + B.Add(CS, newShape); + } + + BodySM* bodysm = OCCQueryEngine::instance()->populate_topology_bridge(CS); + + return bodysm; + +} + + +//=============================================================================== +// Function : sphere +// Member Type: PUBLIC +// Description: build an OCC sphere +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::sphere(double radius) const +{ + if (radius <= 0) + return (BodySM*) NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeSphere(radius); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + return CAST_TO(lump, OCCLump)->get_body(); +} + + +//=============================================================================== +// Function : brick +// Member Type: PUBLIC +// Description: build an OCC brick +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::brick( double wid, double dep, double hi ) const +{ + if (wid <= 0 || dep <=0 || hi <= 0) + return (BodySM*)NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeBox(wid, dep, hi); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + return (BodySM*)NULL; + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body,OCCBody)->move(-wid/2.0, -dep/2.0, -hi/2.0); + return body; +} + + +//=============================================================================== +// Function : brick +// Member Type: PUBLIC +// Description: create an OCC brick given center axes and extension +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::brick( const CubitVector& center, + const CubitVector axes[3], + const CubitVector &extension) const +{ + CubitVector left_corner = center - 0.5 * extension; + gp_Pnt left_point(left_corner.x(), left_corner.y(), left_corner.z()); + gp_Dir main_dir(axes[2].x(), axes[2].y(), axes[2].z()); + gp_Dir x_dir(axes[0].x(), axes[0].y(), axes[0].z()); + gp_Ax2 Axis(left_point, main_dir, x_dir); + TopoDS_Solid S = BRepPrimAPI_MakeBox( Axis, extension.x(), extension.y(), + extension.z()); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : prism +// Member Type: PUBLIC +// Description: create an OCC prism +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::prism( double height, int sides, double major, + double minor) const +{ + //currently OCC only support 4 sided prism + if (sides != 4) + { + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return (BodySM*) NULL; + } + + return brick(2 * major, 2 * minor, height); +} + +//=============================================================================== +// Function : pyramid +// Member Type: PUBLIC +// Description: create an OCC pyramid +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::pyramid( double height, int sides, double major, + double minor, double top) const +{ + //currently OCC only support 4 sided pyramid + if (sides != 4) + { + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return (BodySM*) NULL; + } + + TopoDS_Solid S = BRepPrimAPI_MakeWedge( 2 * major, 2* minor, height, + 2 * top); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body, OCCBody)->move(-major, -minor, -height/2.0); + return body; + +} + +//=============================================================================== +// Function : cylinder +// Member Type: PUBLIC +// Description: create an OCC cylinder, its base shape can be ellipse with +// r1, r2 while r3 = 0; or it can be a cone with r1, +// r3 while r2 = 0. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::cylinder( double hi, double r1, double r2, double r3 ) const +{ + TopoDS_Solid S; + if(r2 != r1)//elliptical based cylinder + { + gp_Pnt center(0.0, 0.0, 0.0); + gp_Dir main_dir(0.0, 0.0, 1.0); + gp_Dir x_dir(1.0, 0.0, 0.0); + gp_Ax2 Axis(center, main_dir, x_dir); + Handle(Geom_Curve) curve_ptr = GC_MakeEllipse(Axis, r1, r2); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr); + BRepBuilderAPI_MakeWire aWire(new_edge); + + TopoDS_Wire test_Wire = aWire.Wire(); + + BRepOffsetAPI_ThruSections builder(CUBIT_TRUE, CUBIT_TRUE); + builder.AddWire(test_Wire); + if (r3 == 0) + { + gp_Pnt pt = gp_Pnt( 0.0, 0.0, hi); + TopoDS_Vertex theVertex = BRepBuilderAPI_MakeVertex(pt); + builder.AddVertex(theVertex); + } + else + { + gp_Pnt center2(0.0, 0.0,hi); + gp_Ax2 Axis2(center2, main_dir, x_dir); + Handle(Geom_Curve) curve_ptr = GC_MakeEllipse(Axis2, r3, r3*r2/r1); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr); + BRepBuilderAPI_MakeWire aWire(new_edge); + TopoDS_Wire test_Wire = aWire.Wire(); + builder.AddWire(test_Wire); + } + builder.Build() ; + S = TopoDS::Solid(builder.Shape()); + } + + else // cone + { + if(r1 == r3) //cylinder + S = BRepPrimAPI_MakeCylinder(r1, hi); + else + S = BRepPrimAPI_MakeCone(r1, r3, hi); + } + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + { + PRINT_ERROR("In OCCModifyEngine::cylinder\n" + " Cannot create a cylinder for given radii.\n"); + return (BodySM*)NULL; + } + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body, OCCBody)->move(0, 0, -hi/2.0); + return body; +} + +//=============================================================================== +// Function : torus +// Member Type: PUBLIC +// Description: create an OCC torus +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::torus( double r1, double r2 ) const +{ + if (r1 <= 0 || r2 <= 0) + return (BodySM*) NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeTorus(r1, r2); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + { + PRINT_ERROR("In OCCModifyEngine::torus\n" + " Cannot create a torus for given radii.\n"); + return (BodySM*)NULL; + } + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : planar_sheet +// Member Type: PUBLIC +// Description: create an OCC planar_sheet with four vectors. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::planar_sheet ( const CubitVector& p1, + const CubitVector& p2, + const CubitVector& p3, + const CubitVector& p4) const +{ + Point* point1 = make_Point(p1); + Point* point2 = make_Point(p2); + Point* point3 = make_Point(p3); + Point* point4 = make_Point(p4); + Curve * curve1 = make_Curve( point1, point2); + if (curve1 == NULL) + return (BodySM*) NULL; + Curve * curve2 = make_Curve( point2, point3); + if (curve2 == NULL) + return (BodySM*) NULL; + Curve * curve3 = make_Curve( point3, point4); + if (curve3 == NULL) + return (BodySM*) NULL; + Curve * curve4 = make_Curve( point4, point1); + if (curve4 == NULL) + return (BodySM*) NULL; + DLIList<Curve*> curves; + curves.append(curve1); + curves.append(curve2); + curves.append(curve3); + curves.append(curve4); + Surface* surface = make_Surface(PLANE_SURFACE_TYPE, curves); + if (surface == NULL) + return (BodySM*) NULL; + return CAST_TO(surface,OCCSurface)->my_body(); +} + +//=============================================================================== +// Function : copy_body +// Member Type: PUBLIC +// Description: copy an OCC-based body +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::copy_body ( BodySM* bodyPtr ) const +{ + OCCBody* occ_body = CAST_TO(bodyPtr, OCCBody); + if (!occ_body) + { + PRINT_ERROR("Cannot create an OCC bodySM from the given bodySM.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + + TopoDS_CompSolid *theCS = occ_body->get_TopoDS_Shape(); + + if (theCS == NULL) //sheet body + { + OCCShell* occ_shell = occ_body->shell(); + if (occ_shell != NULL) + { + TopoDS_Shell* shell = occ_shell->get_TopoDS_Shell(); + BRepBuilderAPI_Copy api_copy(*shell); + TopoDS_Shape newShape = api_copy.ModifiedShape(*shell); + TopoDS_Shell newShell = TopoDS::Shell(newShape); + return OCCQueryEngine::instance()->populate_topology_bridge(newShell, CUBIT_TRUE)->my_body(); + } + + Surface* surface = make_Surface(occ_body->my_sheet_surface()); + if (surface == NULL) + { + PRINT_ERROR("Cannot create an OCC sheet bodySM from the given bodySM.\n"); + return (BodySM *)NULL; + } + + return CAST_TO(surface,OCCSurface)->my_body(); + } + + if(OCCQueryEngine::instance()->OCCMap->IsBound(*theCS)) + { + BRepBuilderAPI_Copy api_copy(*theCS); + + TopoDS_Shape newShape = api_copy.ModifiedShape(*theCS); + + TopoDS_CompSolid newCS = TopoDS::CompSolid(newShape); + + return OCCQueryEngine::instance()->populate_topology_bridge(newCS); + } + + //single lump body + Lump *lump = occ_body->lumps().get(); + TopoDS_Solid solid = *(CAST_TO(lump, OCCLump)->get_TopoDS_Solid()); + BRepBuilderAPI_Copy api_copy(solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(solid); + TopoDS_Solid newSolid = TopoDS::Solid(newShape); + lump = OCCQueryEngine::instance()->populate_topology_bridge(newSolid, + CUBIT_TRUE); + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : stitch_surfs +// Member Type: PUBLIC +// Description: stitch all surfs and try to make a shell body. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::stitch_surfs( + DLIList<BodySM*>& surf_bodies, + BodySM*& new_body) const +{ + new_body = NULL; + if (surf_bodies.size()==0) + return CUBIT_SUCCESS; + + if (surf_bodies.size()==1) + { + new_body = surf_bodies.get(); + return CUBIT_SUCCESS; + } + + TopoDS_Shape fuse; + CubitStatus stat = stitch_surfs(surf_bodies, fuse); + + DLIList<TopologyBridge*> tbs = OCCQueryEngine::instance()-> + populate_topology_bridge(fuse); + + if (stat) + { + OCCBody* body = CAST_TO(tbs.get(), OCCBody); + + if (body) + new_body = body ; + } + + else + { + surf_bodies.clean_out(); + for(int i= 0; i<tbs.size(); i++) + surf_bodies.append(CAST_TO(tbs.get_and_step(), OCCBody)); + } + + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : stitch_surfs +// Member Type: PUBLIC +// Description: stitch all surfs and try to make a TopoDS_Shell . +// called by stitch into surface body +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::stitch_surfs( + DLIList<BodySM*>& surf_bodies, + TopoDS_Shape& fuse) const +{ + if (surf_bodies.size() < 2) + return CUBIT_SUCCESS; + + DLIList<TopoDS_Shape*> faces_to_stitch; + for (int i = 0; i < surf_bodies.size(); i++) + { + BodySM * tool_body = surf_bodies.get_and_step(); + OCCBody* occ_body = CAST_TO(tool_body, OCCBody); + OCCSurface* surface = occ_body->my_sheet_surface(); + OCCShell* shell = occ_body->shell(); + if (surface == NULL && shell == NULL) + { + PRINT_ERROR("Can't stitch non-sheet bodySM's. \n"); + return CUBIT_FAILURE; + } + + delete occ_body; + if (surface) + { + delete surface->my_shell(); + delete surface->my_lump(); + surface->set_shell(NULL); + surface->set_lump(NULL); + surface->set_body(NULL); + + TopoDS_Face* topods_face = surface->get_TopoDS_Face(); + if (topods_face != NULL) + faces_to_stitch.append(topods_face); + } + else + { + delete shell->my_lump(); + shell->set_body(NULL); + shell->set_lump(NULL); + + TopoDS_Shell* topods_shell = shell->get_TopoDS_Shell(); + if(topods_shell) + faces_to_stitch.append(topods_shell); + } + } + + faces_to_stitch.reset(); + surf_bodies.reset(); + TopoDS_Shape* first_face = faces_to_stitch.pop(); + + TopoDS_Shape* second_face = NULL; + for( int i = faces_to_stitch.size()-1; i >= 0; i --) + { + second_face = faces_to_stitch[i]; + BRepAlgoAPI_Fuse fuser(*second_face, *first_face); + + TopoDS_Shape new_shape ; + for(int j = 0; j < 2; j++) + { + TopTools_IndexedMapOfShape M; + if(j == 0) + TopExp::MapShapes(*second_face, TopAbs_FACE, M); + else + TopExp::MapShapes(*first_face, TopAbs_FACE, M); + for(int ii=1; ii<=M.Extent(); ii++) + { + TopoDS_Face face = TopoDS::Face(M(ii)); + TopTools_ListOfShape shapes; + shapes.Assign(fuser.Modified(face)); + if (shapes.Extent() == 1) + { + new_shape = shapes.First(); + OCCSurface::update_OCC_entity(face, TopoDS::Face(new_shape), &fuser); + } + else if(fuser.IsDeleted(face) || shapes.Extent() > 1) + { + TopoDS_Face null_face; + OCCSurface::update_OCC_entity(face, null_face, &fuser); + } + } + } + + fuse = fuser.Shape(); + first_face = &fuse; + } + + TopExp_Explorer Ex; + int count_shell = 0; + for (Ex.Init(fuse, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next()) + count_shell++; + + if ( count_shell != 1) + { + PRINT_ERROR("Can't stitch all surfaces into one BodySM's. \n"); + return CUBIT_FAILURE; + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : subtract +// Member Type: PUBLIC +// Description: subtract boolean operation on OCC-based bodies +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::subtract(DLIList<BodySM*> &tool_body_list, + DLIList<BodySM*> &from_bodies, + DLIList<BodySM*> &new_bodies, + bool imprint, + bool keep_old) const +{ + // copy the bodies in case keep_old is true + DLIList<TopoDS_Shape*> tool_bodies_copy; + + //for subtract function, tool-body has to be solid, + //otherwise it's just imprint + DLIList<CubitBox*>* tool_boxes = new DLIList<CubitBox*>(); + DLIList<CubitBoolean> is_tool_volume; + //keep the tool_body untouched + CubitStatus stat = + get_shape_list(tool_body_list, tool_bodies_copy, is_tool_volume, CUBIT_TRUE, tool_boxes); + + if(!stat) + return stat; + + //check that tool_bodies are all solid, shell and surface body can't be used + //for subtracting purpose. + if(is_tool_volume.is_in_list(CUBIT_FALSE)) + { + PRINT_WARNING("Surfaces or Shells can't be used to cut a body.\n"); + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + return CUBIT_FAILURE; + } + + stat = do_subtract(from_bodies, tool_bodies_copy, is_tool_volume, + tool_boxes, new_bodies, keep_old, imprint) ; + + //ok, we're done wih all cuts, delete unnecessaries. + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + if(!keep_old) //delete tool_bodies + OCCQueryEngine::instance()->delete_solid_model_entities(tool_body_list); + return stat; +} + +CubitStatus OCCModifyEngine::do_subtract(DLIList<BodySM*> &from_bodies, + DLIList<TopoDS_Shape*> &tool_bodies_copy, + DLIList<CubitBoolean> &is_tool_volume, + DLIList<CubitBox*>* tool_boxes, + DLIList<BodySM*> &new_bodies, + bool keep_old, + bool imprint) const +{ + DLIList<TopoDS_Shape*> from_bodies_copy; + DLIList<CubitBoolean> is_volume; + //get the from_bodies underling shapes + CubitStatus stat = get_shape_list(from_bodies, from_bodies_copy, is_volume, keep_old); + if(!stat) + { + for (int i = 0; i < tool_bodies_copy.size(); i++) + { + TopoDS_Shape* shape = tool_bodies_copy.get_and_step(); + delete shape; + } + tool_bodies_copy.clean_out(); + return CUBIT_FAILURE; + } + + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + int fraction_remaining = 100; + + // subtract the tool body from each body in the list + + CubitMessage* cmi = CubitMessage::instance(); + TopoDS_Shape* from_shape = from_bodies_copy.get(); + DLIList<TopologyBridge*> tbs; + for (int i = 0; i < from_bodies_copy.size(); i++) + { + BodySM* from_body = from_bodies.get(); + CubitBox box1 = CAST_TO(from_body, OCCBody)->get_bounding_box(); + int count = 0; //count for not preforming cut + for(int j = 0; j < tool_bodies_copy.size(); j ++) + { + if (cmi->Interrupt()) + { + PRINT_ERROR("Subtraction interrupted. Aborting...\n"); + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + while (from_bodies_copy.size()) + delete from_bodies_copy.pop(); + return CUBIT_FAILURE; + } + CubitBox tool_box = *tool_boxes->get_and_step(); + if(!tool_box.overlap(tol,box1)) + { + count++; + continue; + } + TopoDS_Shape* tool_shape = tool_bodies_copy.get_and_step(); + + //bodies overlap, proceed with the subtract + BRepAlgoAPI_Cut cutter(*from_shape, *tool_shape); + TopoDS_Shape cut_shape = cutter.Shape(); + + //compare to see if the from_shape has gotten cut. + CubitBoolean has_changed; + check_operation(cut_shape, from_shape, is_volume[i], has_changed, &cutter, keep_old); + + CubitStatus stat; + if(!has_changed && !from_shape->IsNull()) + { + stat = CUBIT_FAILURE; + //Add imprint code here + if(imprint) + stat = imprint_toposhapes(from_shape, tool_shape); + if(!stat) + { + PRINT_ERROR("Can't do imprint operation on the body. \n"); + count++; + } + continue; + } + } + + //ok, we're done with all cuts, construct new Body' + if (count < tool_bodies_copy.size() ) + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*from_shape); + else + { + PRINT_INFO("The %d body did not change because cutting tools are not interscting with it.\n", i+1); + from_bodies.change_to(NULL); + } + from_bodies.step(); + from_shape = from_bodies_copy.step_and_get(); + + // done with this j iteration; write out count, if necessary + if (from_bodies.size() * tool_bodies_copy.size() > 1) + { + int frac_done = (100 * (i+1)) / (from_bodies.size()); + if ((100 - frac_done) < fraction_remaining) + { + fraction_remaining = 100 - frac_done; + PRINT_INFO("%d%% remaining.\n ", fraction_remaining+1); + } + } + } + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + //ok, we're done wih all cuts, delete unnecessaries. + if(keep_old) + { + int size = from_bodies_copy.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = from_bodies_copy.pop(); + shape->Nullify(); + delete shape; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : imprint_toposhapes +// Member Type: PROTECTED +// Description: imprint boolean operation on OCC-based bodies. +// from_shape must be TopoDS_Face or above, tool_shape can be +// TopoDS_Edge or above. +// on_faces works only when tool_shape is an Edge, indicates that +// those edges only imprint on the on_faces. +// Author : Jane HU +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint_toposhapes(TopoDS_Shape*& from_shape, + TopoDS_Shape* tool_shape, + DLIList<TopoDS_Face*>*on_faces)const +{ + int count = 0; //number of imprinting + + //indicate if there's more faces to be imprinted + CubitBoolean more_face = CUBIT_TRUE; + DLIList<TopoDS_Face*> list_for_delete; + + //list of face on from_shape that has been imprinted + DLIList<TopoDS_Face*> from_faces; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + while( more_face) + { + TopoDS_Face from_face,tool_face; + TopoDS_Edge* common_edge = NULL; + DLIList<TopoDS_Shape*> tool_faces_edges; + TopTools_ListOfShape list_of_edges; + BRepFeat_SplitShape splitor(*from_shape); + CubitBoolean qualified = CUBIT_TRUE; + if (tool_shape->TShape()->ShapeType() == TopAbs_EDGE) + { + if(count == 1) + break; + + DLIList<TopoDS_Face*> faces; + //need to delete TopoDS_Face* in faces + common_edge = find_imprinting_edge(*from_shape, TopoDS::Edge(*tool_shape),faces); + if (common_edge) + { + if (on_faces) + qualified = CUBIT_FALSE; + for(int j = 0; j < faces.size(); j++) + { + from_face = *faces.get(); + for (int i = 0; on_faces && i < on_faces->size(); i++) + { + if (from_face.IsSame(*(on_faces->get_and_step()))) + { + qualified = CUBIT_TRUE; + break; + } + } + faces.get()->Nullify(); + delete faces.get(); + faces.step(); + } + if (qualified && (from_faces.size() == 0 || (from_faces.size() && !from_face.IsSame(*from_faces.get()))) ) + list_of_edges.Append(*common_edge); + else + from_face.Nullify(); + common_edge->Nullify(); + delete common_edge; + } + } + else + { + TopOpeBRep_ShapeIntersector intersector; + intersector.InitIntersection(*from_shape, *tool_shape); + + //find the intersecting edges and faces. + int max_edge = 0; + for(; intersector.MoreIntersection(); intersector.NextIntersection()) + { + TopoDS_Shape face1; + face1 = intersector.ChangeFacesIntersector().Face(1); + CubitBoolean has_imprinted = CUBIT_FALSE; + for (int j = 0; j < from_faces.size(); j++) + { + TopoDS_Face* topo_face = from_faces.get_and_step(); + if(face1.IsSame(*topo_face)) + { + has_imprinted = CUBIT_TRUE; + break; + } + } + + if (has_imprinted) + continue; + + TopoDS_Shape edge_face; + + edge_face = intersector.ChangeFacesIntersector().Face(2); + BRepAlgoAPI_Section section(face1, edge_face); + + //intersection edges between face1 and edge_face + TopTools_ListOfShape temp_list_of_edges; + temp_list_of_edges.Assign(section.SectionEdges()); + int num_edges = temp_list_of_edges.Extent(); + + CubitBoolean is_same = face1.IsSame(from_face); + CubitBoolean is_same_tool = CUBIT_FALSE; + for (int j = 0; j < tool_faces_edges.size(); j++) + { + TopoDS_Shape* topo_face_edge = tool_faces_edges.get_and_step(); + if(edge_face.IsSame(*topo_face_edge)) + { + is_same_tool = CUBIT_TRUE; + break; + } + } + if (max_edge < num_edges ) + { + list_of_edges.Assign(temp_list_of_edges); + max_edge = num_edges ; + from_face = TopoDS::Face(face1); + TopoDS_Shape* topo_shape = new TopoDS_Shape(edge_face); + DLIList<TopoDS_Shape*> shape_list; + for(int iii = 0; iii < tool_faces_edges.size(); iii++) + { + int size = shape_list.size(); + shape_list.append_unique(tool_faces_edges.get_and_step()); + if (size < shape_list.size()) + { + shape_list.last(); + shape_list.get()->Nullify(); + delete shape_list.get(); + } + } + tool_faces_edges.clean_out(); + for(int i = 0 ; i < num_edges; i++) + //later has to use it num_edges times + tool_faces_edges.append(topo_shape); + } + else if(num_edges == max_edge && is_same && !is_same_tool) + //multi tool faces cut the same face + { + TopTools_ListIteratorOfListOfShape Itor, temp_Itor; + temp_Itor.Initialize(temp_list_of_edges); + for(; temp_Itor.More(); temp_Itor.Next()) + { + TopoDS_Edge temp_edge = TopoDS::Edge(temp_Itor.Value()); + Itor.Initialize(list_of_edges); + CubitBoolean same_edge = CUBIT_FALSE; + + GProp_GProps myProps1; + BRepGProp::LinearProperties(temp_edge, myProps1); + gp_Pnt center1 = myProps1.CentreOfMass(); + for(; Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + GProp_GProps myProps2; + BRepGProp::LinearProperties(edge, myProps2); + gp_Pnt center2 = myProps2.CentreOfMass(); + if(center1.IsEqual(center2, tol)) + { + same_edge = CUBIT_TRUE; + break; + } + } + if(!same_edge) + { + list_of_edges.Append(temp_edge); + TopoDS_Shape* topo_shape = new TopoDS_Shape(edge_face); + tool_faces_edges.append(topo_shape); + } + } + } + } + } + if (from_face.IsNull()) + { + more_face = CUBIT_FALSE; + DLIList<TopoDS_Shape*> shape_list; + for(int iii = 0; iii < tool_faces_edges.size(); iii++) + { + int size = shape_list.size(); + shape_list.append_unique(tool_faces_edges.get_and_step()); + if (size < shape_list.size()) + { + shape_list.last(); + shape_list.get()->Nullify(); + delete shape_list.get(); + } + } + tool_faces_edges.clean_out(); + + for (int iii=0; iii < from_faces.size(); iii++) + { + TopoDS_Face* topo_face = from_faces.get_and_step(); + topo_face->Nullify(); + delete topo_face; + } + + for (int iii=0; iii < list_for_delete.size(); iii++) + { + TopoDS_Face* topo_face = list_for_delete.get_and_step(); + topo_face->Nullify(); + delete topo_face; + } + continue; + } + + TopTools_ListIteratorOfListOfShape Itor; + + //list_of_edges is the intersection edges on tool_faces_edges + Itor.Initialize(list_of_edges); + int total_edges = list_of_edges.Extent(); + DLIList<Curve*> curve_list; + CubitBoolean topo_changed = CUBIT_FALSE; + tool_faces_edges.reset(); + + //check to see if the intersection edge is: + //1. on from_face: if not, skip it + //2. overlap with from_edges : if not, add the edge for splitting face + //3. if overlap, is it the same edge:if not add it for splitting edge + // if yes, skip it too + + Surface* face = NULL; + if (OCCQueryEngine::instance()->OCCMap->IsBound(from_face)) + { + int i = OCCQueryEngine::instance()->OCCMap->Find(from_face); + face = (OCCSurface*)(OCCQueryEngine::instance()->OccToCGM->find(i))->second; + } + else + face = OCCQueryEngine::instance()->populate_topology_bridge(from_face); + OCCSurface* occ_face = CAST_TO(face, OCCSurface); + + DLIList<Curve*> common_curves; + for(; Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + //copy the edge for imprinting. + BRepBuilderAPI_Copy api_copy(edge); + TopoDS_Shape newShape = api_copy.ModifiedShape(edge); + edge = TopoDS::Edge(newShape); + Curve* curve = NULL; + curve = OCCQueryEngine::instance()->populate_topology_bridge(edge); + if(curve) + common_curves.append(curve); + } + + DLIList<DLIList<TopoDS_Edge*>*> temp_edge_lists; + list_of_edges.Clear(); + if (common_curves.size() >= 1) + { + sort_curves(common_curves, temp_edge_lists); + DLIList<TopoDS_Edge*>* edge_list; + int size = temp_edge_lists.size(); + for(int i = 0; i < size; i++) + { + edge_list = temp_edge_lists.pop(); + //make sure the copied edges are sharing vertices. + BRepBuilderAPI_MakeWire myWire; + edge_list->reset(); + for(int i = 0; i < edge_list->size(); i++) + { + TopoDS_Edge e = *(edge_list->get_and_step()); + myWire.Add(e); + } + TopoDS_Wire wire = myWire.Wire(); + BRepTools_WireExplorer Ex(wire); + for(; Ex.More(); Ex.Next()) + list_of_edges.Append(Ex.Current()); + } + } + for(Itor.Initialize(list_of_edges); Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + //check to see if the intersection edge is on from_face + TopExp_Explorer Ex; + CubitBoolean added = CUBIT_FALSE; + CubitBoolean skipped = CUBIT_FALSE; + GProp_GProps myProps1; + BRepGProp::LinearProperties(edge, myProps1); + double d1 = myProps1.Mass(); + gp_Pnt pt = myProps1.CentreOfMass(); + CubitVector p(pt.X(), pt.Y(), pt.Z()); + + CubitVector point_on_surf; + occ_face->closest_point_trimmed(p, point_on_surf); + if(p.distance_between(point_on_surf) > tol) //edge not on from_face + { + skipped = CUBIT_TRUE; + total_edges--; + } + + else + { + for (Ex.Init(from_face, TopAbs_EDGE); Ex.More(); Ex.Next()) + { + //check if the edge is on from_face edges, add such edge on existing + //edge to split it. + TopoDS_Edge from_edge = TopoDS::Edge(Ex.Current()); + + GProp_GProps myProps2; + BRepGProp::LinearProperties(from_edge, myProps2); + double d2 = myProps2.Mass(); + Curve* curve = NULL; + if (OCCQueryEngine::instance()->OCCMap->IsBound(from_edge)) + { + int i = OCCQueryEngine::instance()->OCCMap->Find(from_edge); + curve = (OCCCurve*)(OCCQueryEngine::instance()->OccToCGM->find(i))->second; + } + else + curve = OCCQueryEngine::instance()->populate_topology_bridge(from_edge); + OCCCurve* occ_curve = CAST_TO(curve, OCCCurve); + CubitPointContainment pc = occ_curve->point_containment(p); + + if(pc == CUBIT_PNT_ON) //overlap + { + //check if they are the same edge, so don't need to be split + //the overlapped edges are considered the same if they have the + //same length + if((d2 - d1) > tol) + { + added = CUBIT_TRUE; + splitor.Add(edge, from_edge); + } + else + skipped = CUBIT_TRUE; + total_edges--; + break; + } + } + } + if(added) + { + topo_changed = CUBIT_TRUE; + continue; + } + if (!skipped) + { + //check if edge's inside from_face by checking bounding boxes + BRepAdaptor_Curve acurve(edge); + BRepAdaptor_Surface asurface( from_face); + Bnd_Box aBox_edge, aBox_face; + BndLib_Add3dCurve::Add(acurve, Precision::Approximation(), aBox_edge); + BndLib_AddSurface::Add(asurface, Precision::Approximation(), aBox_face); + double min[3], max[3]; + aBox_edge.Get( min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox aBox_e(min, max); + aBox_face.Get( min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox aBox_f(min, max); + if (aBox_e <= aBox_f) + { + Curve* curve = OCCQueryEngine::instance()->populate_topology_bridge(edge); + curve_list.append(curve); + } + } + } + + DLIList<DLIList<TopoDS_Edge*>*> edge_lists; + if (total_edges >= 1) + { + CubitStatus stat = sort_curves(curve_list, edge_lists); + DLIList<TopoDS_Edge*>* edge_list; + int size = edge_lists.size(); + for (int iii = 0; iii < size; iii++) + { + edge_list = edge_lists.pop(); + + //check if the edges make a split of the surface, error out if it's + //just a scar on the surface + int count_intersection = 0; + if (stat == CUBIT_FAILURE) //Open wire + { + count_intersection = check_intersection(edge_list, from_face); + + if (count_intersection < 2) + PRINT_WARNING("Cant make a scar on existing face without splitting it. \n"); + } + if (stat || count_intersection == 2) + { + BRepBuilderAPI_MakeWire myWire; + edge_list->reset(); + for(int i = 0; i < edge_list->size(); i++) + { + TopoDS_Edge e = *(edge_list->get_and_step()); + myWire.Add(e); + } + splitor.Add(myWire.Wire(),from_face); + topo_changed = CUBIT_TRUE; + break; + } + for(int iii = 0; iii < edge_list->size(); iii++) + edge_list->pop(); + delete edge_list; + } + } + if(topo_changed) + { + splitor.Build(); + topo_changed = CUBIT_FALSE; + if(splitor.IsDone()) + { + //take care of on_faces list first:after operation, the on_faces + // will have at least one face changed, update the pointer. + if (on_faces) + { + for(int k = 0; k < on_faces->size(); k++) + { + TopoDS_Face* compare_face = on_faces->get_and_step(); + if(from_face.IsSame(*compare_face)) + { + on_faces->remove(compare_face); + TopTools_ListOfShape shapes; + shapes.Assign(splitor.Modified(from_face)); + while(shapes.Extent() > 0) + { + TopoDS_Face* face = + new TopoDS_Face(TopoDS::Face(shapes.First())); + shapes.RemoveFirst(); + on_faces->append(face); + list_for_delete.append(face); + } + } + } + } + + TopoDS_Shape new_from_shape = splitor.Shape(); + if(from_shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + TopoDS_CompSolid old_csolid = TopoDS::CompSolid(*from_shape); + OCCBody::update_OCC_entity(old_csolid, new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + + else if(from_shape->TShape()->ShapeType() == TopAbs_SOLID) + { + TopoDS_Solid old_solid = TopoDS::Solid(*from_shape); + OCCLump::update_OCC_entity(old_solid, new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + else if(from_shape->TShape()->ShapeType() == TopAbs_SHELL) + { + TopoDS_Shell old_shell = TopoDS::Shell(*from_shape); + OCCShell::update_OCC_entity(old_shell,new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + else if(from_shape->TShape()->ShapeType() == TopAbs_FACE) + { + TopoDS_Face old_face = TopoDS::Face(*from_shape); + OCCSurface::update_OCC_entity(old_face,new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + + TopTools_ListOfShape shapes; + for(int i = 0; i < from_faces.size(); i++) + { + TopoDS_Face* topo_face = from_faces.get(); + shapes.Assign(splitor.Modified(*topo_face)); + topo_face = new TopoDS_Face(TopoDS::Face(shapes.First())); + from_faces.get()->Nullify(); + delete from_faces.get(); + from_faces.change_to(topo_face); + from_faces.step(); + } + count++; + } + } + else + { + TopoDS_Face* topo_face = new TopoDS_Face(from_face); + from_faces.append(topo_face); + } + } + + + TopExp_Explorer Ex; + int num_face = 0; + for (Ex.Init(*from_shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + TopoDS_Face face = TopoDS::Face(Ex.Current()); + num_face++; + } + +#ifdef DEBUG + PRINT_INFO("Total %d cuts performed, with from_shape having %d faces.\n", count, num_face); +#endif + + if (count > 0) + return CUBIT_SUCCESS; + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : find_imprinting_edge +// Member Type: PROTECTED +// Description: imprint boolean operation on OCC-based bodies. +// from_shape must be TopoDS_Face or above, tool_shape must be +// TopoDS_Edge. +// Author : Jane HU +// Date : 05/08 +//=============================================================================== +TopoDS_Edge* OCCModifyEngine::find_imprinting_edge(TopoDS_Shape& from_shape, + TopoDS_Edge& tool_shape, + DLIList<TopoDS_Face*>& from_faces)const +{ + TopoDS_Edge* edge = NULL; + //list of face on from_shape that has been imprinted + from_faces.clean_out(); + TopExp_Explorer Ex; + for (Ex.Init(from_shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + TopoDS_Face face = TopoDS::Face(Ex.Current()); + BRepAlgoAPI_Common intersector(face, tool_shape); + TopTools_ListOfShape shapes; + shapes.Assign(intersector.Modified(tool_shape)); + if (shapes.IsEmpty()) + continue; + if ( shapes.Extent() > 1) + { + PRINT_ERROR("Edge has multiple intersection with the shape, make it simpler. \n"); + continue; + } + if (shapes.First().TShape()->ShapeType() != TopAbs_EDGE) + continue; + if(edge == NULL) + { + TopoDS_Edge common_edge = TopoDS::Edge(shapes.First()); + BRepBuilderAPI_Copy api_copy(common_edge); + TopoDS_Shape newShape = api_copy.ModifiedShape(common_edge); + edge = new TopoDS_Edge(TopoDS::Edge(newShape)); + } + from_faces.append(new TopoDS_Face(face)); + } + return edge; +} + +int OCCModifyEngine::check_intersection(DLIList<TopoDS_Edge*>* edge_list, + TopoDS_Face from_face)const +{ + int count_intersection = 0; + //Consider if edge_list has only one edge, and it intersects the from_face + //at two different places. + CubitBoolean double_check = CUBIT_FALSE; + if (edge_list->size() == 1) + double_check = CUBIT_TRUE; + + gp_Pnt intsec_pnt[2]; + for(int j = 0; j < edge_list->size(); j++) + { + TopoDS_Edge* edge = edge_list->get_and_step(); + BRepAdaptor_Curve acurve(*edge); + double lower_bound = acurve.FirstParameter(); + double upper_bound = acurve.LastParameter(); + TopExp_Explorer Ex; + gp_Pnt newP[2]; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + for (Ex.Init(from_face, TopAbs_EDGE); Ex.More(); Ex.Next()) + { + TopoDS_Edge from_edge = TopoDS::Edge(Ex.Current()); + BRepAdaptor_Curve acurve2(from_edge); + double lower_bound2 = acurve2.FirstParameter(); + double upper_bound2 = acurve2.LastParameter(); + BRepExtrema_DistShapeShape distShapeShape(*edge, from_edge); + CubitBoolean qualified[2] = {CUBIT_FALSE, CUBIT_FALSE}; + if (distShapeShape.IsDone() && distShapeShape.Value() < tol) + { + newP[0] = distShapeShape.PointOnShape1(1); + if (double_check && distShapeShape.NbSolution() == 2) + newP[1] = distShapeShape.PointOnShape1(2); + double newVal[2]; + for(int j =0; j < distShapeShape.NbSolution(); j++) + { + Extrema_ExtPC ext(newP[j], acurve, Precision::Approximation()); + if (ext.IsDone() && (ext.NbExt() > 0)) { + for ( int i = 1 ; i <= ext.NbExt() ; i++ ) { + if ( ext.IsMin(i) ) { + newVal[j] = ext.Point(i).Parameter(); + if ((newVal[j]-lower_bound) >= -tol && + (upper_bound - newVal[j]) >= -tol) + { + qualified[j] = CUBIT_TRUE; + break; + } + } + } + } + } + for(int j = 0; j < distShapeShape.NbSolution(); j++) + { + if (qualified[j]) + { + qualified[j] = CUBIT_FALSE; + Extrema_ExtPC ext(newP[j], acurve2, Precision::Approximation()); + double newVal; + if (ext.IsDone() && (ext.NbExt() > 0)) { + for ( int i = 1 ; i <= ext.NbExt() ; i++ ) { + if ( ext.IsMin(i) ) { + newVal = ext.Point(i).Parameter(); + if ((newVal-lower_bound2) >= -tol && + (upper_bound2 - newVal) >= -tol) + { + qualified[j] = CUBIT_TRUE; + break; + } + } + } + } + } + } + for(int k = 0; k < distShapeShape.NbSolution(); k++) + { + if (qualified[k]) + count_intersection++; + intsec_pnt[count_intersection-1] = newP[k]; + if (count_intersection == 2) + { + //make sure the two intersect point are not the same one + if (intsec_pnt[0].IsEqual(intsec_pnt[1], tol)) + count_intersection--; + } + } + } + if (count_intersection == 2) + break; + } //for loop + } + return count_intersection; +} +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: imprint boolean operation on OCC-based bodies +// Author : Jane Hu +// Date : 04/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint(BodySM* BodyPtr1, BodySM* BodyPtr2, + BodySM*& newBody1, BodySM*& newBody2, + bool keep_old) const +{ + newBody1 = NULL; + newBody2 = NULL; + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + + DLIList<BodySM*> bodysm_list; + bodysm_list.append(BodyPtr1); + bodysm_list.append(BodyPtr2); + + CubitStatus stat = get_shape_list(bodysm_list,shape_list,is_volume,keep_old); + + if(!stat) + return stat; + + TopoDS_Shape* shape1 = shape_list.get(); + TopoDS_Shape* shape2 = shape_list.step_and_get(); + DLIList<TopologyBridge*> tbs; + stat = imprint_toposhapes(shape1, shape2); + if(stat) + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape1); + newBody1 = CAST_TO(tbs.get(),BodySM); + } + + else if(!stat && keep_old) + { + delete shape1; + PRINT_INFO("There's no imprint on the first body.\n"); + newBody1 = BodyPtr1; + } + + tbs.clean_out(); + stat = imprint_toposhapes(shape2, shape1); + if(stat) + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape2); + newBody2 = CAST_TO(tbs.get(),BodySM); + } + + else if(!stat && keep_old) + { + delete shape2; + PRINT_INFO("There's no imprint on the second body.\n"); + newBody2 = BodyPtr2; + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : get_the_shape_list +// Member Type: PRIVATE +// Description: get the TopoDS_Shape list for imprinting use. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::get_shape_list(DLIList<BodySM*>& BodySM_list, + DLIList<TopoDS_Shape*>& shape_list, + DLIList<CubitBoolean>& is_volume, + bool keep_old, + DLIList<CubitBox*>* b_boxes) const +{ + OCCBody* occ_body = NULL; + shape_list.clean_out(); + is_volume.clean_out(); + CubitStatus stat = CUBIT_SUCCESS; + for(int i = 0; i <BodySM_list.size(); i++) + { + occ_body = CAST_TO(BodySM_list.get_and_step(), OCCBody); + if (!occ_body) + continue; + + OCCSurface* surface = occ_body->my_sheet_surface(); + OCCShell* shell = occ_body->shell(); + is_volume.append( CUBIT_TRUE); + + if(b_boxes) + { + CubitBox *tool_box = new CubitBox(occ_body->get_bounding_box()); + b_boxes->append(tool_box); + } + + if(surface) + { + TopoDS_Face* topo_face = surface->get_TopoDS_Face(); + if(!topo_face) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*topo_face); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topo_face); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(topo_face); + is_volume.change_to( CUBIT_FALSE); + } + else if(shell) + { + TopoDS_Shell* topo_shell = shell->get_TopoDS_Shell(); + if(!topo_shell) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*topo_shell); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topo_shell); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(topo_shell); + is_volume.change_to( CUBIT_FALSE); + } + + else + { + DLIList<Lump*> lumps = occ_body->lumps(); + if (lumps.size() > 1) + { + PRINT_ERROR("Can't do boolean operation on CompSolid types. \n"); + stat = CUBIT_FAILURE; + break; + } + + TopoDS_Solid* solid = CAST_TO(lumps.get(), OCCLump)->get_TopoDS_Solid(); + if(!solid) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(*solid); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(solid); + } + } + if(!stat) + { + for (int i = 0; keep_old && i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + delete shape; + } + shape_list.clean_out(); + return CUBIT_FAILURE; + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Function : imprint multiple bodies at once +// Member Type: PUBLIC +// Description: imprint boolean operation on OCC-based bodies +// Author : Jane HU +// Date : 04/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint(DLIList<BodySM*> &from_body_list , + DLIList<BodySM*> &new_from_body_list, + bool keep_old, + DLIList<TopologyBridge*>* new_tbs, + DLIList<TopologyBridge*>* att_tbs) const +{ + CubitStatus success = CUBIT_SUCCESS; + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(from_body_list, shape_list, is_vo,keep_old); + + if(!stat) + return stat; + + int size = shape_list.size(); + // total number of imprints to be done + int total_imprints = (size * (size -1))/2; + + if( size > 2 ) + { + char message[128]; + sprintf(message, "Imprinting %d OCC Bodies", from_body_list.size() ); + AppUtil::instance()->progress_tool()->start(0, total_imprints, message); + } + + for(int i = 0; i < size; i++) + { + TopoDS_Shape* shape1 = shape_list[i]; + CubitBoolean modified = CUBIT_FALSE; + for(int j = i+1; j < size+i; j ++) + { + if (CubitMessage::instance()->Interrupt()) + { + success = CUBIT_FAILURE; + break; + } + + TopoDS_Shape* shape2 = shape_list[j%size]; + DLIList<TopologyBridge*> tbs; + CubitStatus stat = imprint_toposhapes(shape1, shape2); + if(stat) + modified = CUBIT_TRUE; + } + if(modified) + { + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape1); + new_from_body_list.append(CAST_TO(tbs.get(),BodySM)); + } + shape_list.reset(); + if( size > 2 ) + AppUtil::instance()->progress_tool()->step(); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->end(); + + if( CubitMessage::instance()->Interrupt() ) + PRINT_INFO("Imprint aborted.\n"); + + return success; +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: imprint curves onto body_list +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<BodySM*> &body_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + bool show_messages) const +{ + CubitStatus success = CUBIT_SUCCESS; + DLIList<TopoDS_Shape*> shape_list, tool_shapes; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(body_list, shape_list, is_vo, keep_old); + if (!stat) + return stat; + + int size = ref_edge_list.size(); + // total number of imprints to be done + + if( size > 2 && show_messages) + { + char message[128]; + sprintf(message, "Imprinting %d OCC Bodies", body_list.size() ); + AppUtil::instance()->progress_tool()->start(0, size, message); + } + for (int i = 0; i < ref_edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(ref_edge_list.get_and_step(), OCCCurve) ; + if (!curve) + continue; + + TopoDS_Edge* edge = curve->get_TopoDS_Edge(); + if (edge->IsNull()) + continue; + + if (CubitMessage::instance()->Interrupt()) + { + success = CUBIT_FAILURE; + break; + } + + for(int j = 0; j < shape_list.size(); j ++) + { + TopoDS_Shape* shape = shape_list.get(); + + stat = imprint_toposhapes(shape, (TopoDS_Shape*)edge); + if (stat) + shape_list.change_to(shape); + shape_list.step(); + body_list.step(); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->step(); + } + + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append(CAST_TO(tbs.get(),BodySM)); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->end(); + + if( CubitMessage::instance()->Interrupt() ) + PRINT_INFO("Imprint aborted.\n"); + return success; +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: to be consistante with Acis imprint. +// The surfaces must be part of a body, but the curves +// just have to be valid OCC edge. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old ) const +{ + DLIList<TopoDS_Face*> face_list; + DLIList<TopoDS_Shape*> shape_list; + + face_edge_imprint(ref_face_list, edge_list, face_list, shape_list, keep_old); + + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + if (shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + if(!OCCQueryEngine::instance()->OCCMap->IsBound(*shape)) + { + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_SOLID);Ex.More(); Ex.Next()) + { + TopoDS_Shape subshape = Ex.Current(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(subshape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + } + else + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + + if (keep_old) + { + for(int i = 0; i < face_list.size(); i++) + { + TopoDS_Face* face = face_list.get(); + face->Nullify(); + delete face; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : face_edge_imprint +// Member Type: PRIVATE +// Description: to be consistante with Acis imprint. +// The surfaces must be part of a body, but the curves +// just have to be valid OCC edge. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::face_edge_imprint( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &edge_list, + DLIList<TopoDS_Face*>& face_list, + DLIList<TopoDS_Shape*>& shape_list, + bool keep_old ) const +{ + for(int i = 0; i <ref_face_list.size(); i++) + { + OCCSurface* surface = CAST_TO(ref_face_list.get_and_step(), OCCSurface); + if(!surface) + continue; + + TopoDS_Face* topo_face = surface->get_TopoDS_Face(); + face_list.append(topo_face); + + if(surface->my_shell() && !surface->my_body())//shell body + shape_list.append(surface->my_shell()->get_TopoDS_Shell()); + else if(surface->my_body()) //a sheet body + shape_list.append(topo_face); + else + { + //int size = shape_list.size(); + OCCQueryEngine* oqe = OCCQueryEngine::instance(); + DLIList <OCCBody* > *bodies = oqe->BodyList; + TopTools_IndexedDataMapOfShapeListOfShape M; + OCCBody * body = NULL; + for(int j = 0; j < bodies->size(); j++) + { + body = bodies->get_and_step(); + TopExp_Explorer Ex; + TopoDS_Face the_face; + TopoDS_Shape ashape = *(body->get_TopoDS_Shape()); + M.Clear(); + TopExp::MapShapesAndAncestors(ashape, TopAbs_FACE, TopAbs_COMPSOLID, M); + if(!M.Contains(*topo_face)) + continue; + shape_list.append_unique(body->get_TopoDS_Shape()); + } + } + } + + if(keep_old) + { + for(int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get(); + BRepBuilderAPI_Copy api_copy(*shape); + TopoDS_Shape newShape = api_copy.ModifiedShape(*shape); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + for(int j = 0; j < face_list.size(); j++) + { + TopoDS_Face* face = face_list.get(); + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + if(face->IsSame(Ex.Current())) + { + face = new TopoDS_Face(TopoDS::Face(api_copy.ModifiedShape(*face))); + face_list.change_to(face); + } + } + face_list.step(); + } + shape_list.change_to(Shape1); + shape_list.step(); + } + } + + for (int i = 0; i < edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(edge_list.get_and_step(), OCCCurve) ; + if (!curve) + continue; + + TopoDS_Edge* edge = curve->get_TopoDS_Edge(); + if (edge->IsNull()) + continue; + + for(int j = 0; j < shape_list.size(); j ++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + imprint_toposhapes(shape, (TopoDS_Shape*)edge, &face_list); + } + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: To be consistent with AcisModifyEngine, althought it's hard +// to have a GUI interface for users to input. All surface must +// on the same body. +// Author : Jane HU +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<Surface*>& surface_list, + DLIList<DLIList<Curve*>*>& curve_lists_list, + BodySM*& new_body, + bool keep_old ) const +{ + DLIList<TopoDS_Face*> face_list; + DLIList<TopoDS_Shape*> shape_list; + DLIList<TopoDS_Shape*> shape_list_all; + + assert (surface_list.size() == curve_lists_list.size()); + + for(int j = 0; j < surface_list.size(); j++) + { + Surface* surface = surface_list.get_and_step(); + DLIList<Surface*> ref_face_list; + ref_face_list.append(surface); + DLIList<Curve*> *edge_list = curve_lists_list.get_and_step(); + face_edge_imprint(ref_face_list, *edge_list, face_list, shape_list, keep_old); + + for(int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + shape_list_all.append_unique(shape); + } + shape_list.clean_out(); + + if (keep_old) + { + for(int i = 0; i < face_list.size(); i++) + { + TopoDS_Face* face = face_list.get(); + face->Nullify(); + delete face; + } + } + + face_list.clean_out(); + } + + DLIList<BodySM*> new_body_list; + shape_to_bodySM(shape_list, new_body_list); + + if (new_body_list.size() == 1) + { + new_body = new_body_list.get(); + return CUBIT_SUCCESS; + } + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : shape_to_bodySM +// Member Type: PRIVATE +// Description: After imprint, update shape list to bodySM_list +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +void OCCModifyEngine::shape_to_bodySM( DLIList<TopoDS_Shape*> shape_list, + DLIList<BodySM*>& new_body_list)const +{ + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + if (shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + if(!OCCQueryEngine::instance()->OCCMap->IsBound(*shape)) + { + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_SOLID);Ex.More(); Ex.Next()) + { + TopoDS_Shape subshape = Ex.Current(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(subshape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + } + else + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: Imprints locations to bodies (for splitting curves, there's +// no known ways to put hard points on surfaces in OCC, so I just +// add free_vertex on OCCSurface definition, mesh should look on +// this structure). +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<BodySM*> &body_list, + DLIList<CubitVector*> &vector_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + DLIList<TopologyBridge*>*, + DLIList<TopologyBridge*>* ) const +{ + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(body_list, shape_list, is_vo, keep_old); + if(!stat) + return stat; + + for (int i = 0; i < body_list.size(); i++) + { + OCCBody* body = CAST_TO(body_list.get_and_step(), OCCBody); + TopoDS_Shape* from_shape = shape_list.get_and_step(); + if (!body) + continue; + DLIList<OCCSurface*> surfaces; + DLIList<OCCCurve*> curves; + + body->get_all_surfaces(surfaces); + body->get_all_curves(curves); + + CubitBoolean on_vertex = CUBIT_FALSE; + CubitBoolean on_curve = CUBIT_FALSE; + for (int j = 0; j < vector_list.size(); j ++) + { + CubitVector* v = vector_list[j]; + if(v == NULL) + continue; + for (int k = 0; k < curves.size(); k ++) + { + OCCCurve* curve = curves.get_and_step(); + CubitPointContainment pc = curve->point_containment(*v); + if(pc == CUBIT_PNT_BOUNDARY) + { + on_vertex = CUBIT_TRUE; + break; + } + + else if( pc == CUBIT_PNT_INSIDE) + { + LocOpe_SplitShape splitor(*from_shape); + on_curve = CUBIT_TRUE; + TopoDS_Edge edge = *curve->get_TopoDS_Edge(); + gp_Pnt pt = gp_Pnt(v->x(), v->y(), v->z()); + TopoDS_Vertex vertex = BRepBuilderAPI_MakeVertex(pt); + double param = curve->u_from_position(*v); + splitor.Add(vertex, param, edge); + + //update the curve_list + TopTools_ListOfShape edge_shapes; + edge_shapes.Assign(splitor.DescendantShapes(edge)); + while(edge_shapes.Extent()) + { + TopoDS_Shape edge_shape = edge_shapes.First(); + TopoDS_Edge occ_edge = TopoDS::Edge(edge_shape); + OCCCurve* test_curve; + test_curve = CAST_TO(OCCQueryEngine::instance()->populate_topology_bridge(occ_edge), OCCCurve); + if(test_curve) + curves.append(test_curve); + edge_shapes.RemoveFirst(); + } + curves.remove(curve); + + TopTools_ListOfShape shapes; + shapes.Assign(splitor.DescendantShapes(*from_shape)); + if(from_shape->TShape()->ShapeType() ==TopAbs_COMPSOLID) + OCCBody::update_OCC_entity(*from_shape, shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + else if(shapes.First().TShape()->ShapeType() == TopAbs_SOLID) + OCCLump::update_OCC_entity(TopoDS::Solid(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + else if(shapes.First().TShape()->ShapeType() == TopAbs_SHELL) + OCCShell::update_OCC_entity(TopoDS::Shell(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + else if(shapes.First().TShape()->ShapeType() == TopAbs_FACE) + OCCSurface::update_OCC_entity(TopoDS::Face(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(shapes.First()); + break; + } + } + if(on_vertex || on_curve) + continue; + + //check possible on surface + for(int n = 0; n < surfaces.size(); n ++) + { + OCCSurface* surface = surfaces.get_and_step(); + if(!surface->is_position_on(*v)) + continue; + + CubitPointContainment ps = surface->point_containment(*v); + if(ps == CUBIT_PNT_INSIDE) + { + Point* p = make_Point(*v); + if(p) + surface->add_hardpoint(CAST_TO(p, OCCPoint)); + break; + } + } + } + } + + shape_to_bodySM(shape_list, new_body_list); + + return stat; +} + +//=============================================================================== +// Function : imprint_projected_edges +// Member Type: PUBLIC +// Description: Projects a list of Curves on to a list of Surfaces +// and imprint the faces with the new Curves +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::imprint_projected_edges( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old_body, + bool keep_free_edges) const +{ + DLIList<Curve*> projected_curves; + CubitStatus + stat = project_edges(ref_face_list, ref_edge_list, projected_curves); + if(!stat) + return stat; + + // imprint Surface with curves + stat = imprint(ref_face_list, projected_curves, new_body_list, keep_old_body ); + + if(keep_free_edges) + return stat; + + PRINT_INFO( "Removing projected curves \n"); + for(int i=0; i< projected_curves.size();i++) + { + // Now delete this Curve and its underlying solid model entities + + Curve* curve = projected_curves.get_and_step(); + stat = OCCQueryEngine::instance()->delete_solid_model_entities( curve ); + if (stat == CUBIT_FAILURE) + { + PRINT_ERROR("In OCCQueryEngine::delete_geometry\n" + " Could not delete OCCCurve.\n" + " The Model database is likely corrupted " + "due to\n this unsuccessful deletion.\n" ); + } + } + return stat; +} +//=============================================================================== +// Function : project_edges +// Member Type: PUBLIC +// Description: Projects a list of Curves on to a list of Surfaces +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::project_edges( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &ref_edge_list, + DLIList<Curve*> &projected_curves, + bool print_error ) const + +{ + CubitVector* v = NULL; + Curve* projected_curve = NULL; + DLIList<Point*> points; + //project curves onto surfaces. + for(int i = 0; i < ref_edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(ref_edge_list.get_and_step(), OCCCurve); + if(!curve) + continue; + + for (int j = 0; j < ref_face_list.size(); j++) + { + OCCSurface* surface = CAST_TO(ref_face_list.get_and_step(), OCCSurface); + if(!surface) + continue; + if(surface->is_closed_in_U() || surface->is_closed_in_V()) + { + if(print_error) + PRINT_ERROR("This function can't project curves on closed surfaces.\n"); + return CUBIT_FAILURE; + } + + projected_curve = NULL; + projected_curve = curve->project_curve(surface, points, CUBIT_FALSE, v); + if(projected_curve) + projected_curves.append_unique(projected_curve); + } + } + while(points.size() > 0) + delete points.pop(); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : imprint_projected_edges +// Member Type: PUBLIC +// Description: Projects a list of curves on to a list of surfaces +// and imprint the bodies with the new curves +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::imprint_projected_edges(DLIList<Surface*> &ref_face_list, + DLIList<BodySM*> &body_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + bool keep_free_edges) const +{ + DLIList<Curve*> projected_curves; + CubitStatus + stat = project_edges(ref_face_list, ref_edge_list, projected_curves); + if(!stat) + return stat; + return CUBIT_FAILURE; + + // imprint bodies with curves + stat = imprint(body_list,projected_curves, new_body_list, keep_old); + + if (keep_free_edges) + return stat; + + PRINT_INFO( "Removing projected curves \n"); + for(int i=0; i< projected_curves.size();i++) + { + // Now delete this Curve + Curve* curve = projected_curves.get_and_step(); + stat = OCCQueryEngine::instance()-> + delete_solid_model_entities( curve ); + if (stat == CUBIT_FAILURE) + { + PRINT_ERROR("In OCCModifyEngine::delete_geometry\n" + " Could not delete Curve.\n" + " The Model database is likely corrupted " + "due to\n this unsuccessful deletion.\n" ); + } + } + return stat; +} + +//=============================================================================== +// Function : intersect +// Member Type: PUBLIC +// Description: intersect boolean operation of body with list of bodies. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::intersect(BodySM* tool_body_ptr, + DLIList<BodySM*> &from_bodies, + DLIList<BodySM*> &new_bodies, + bool keep_old) const +{ + DLIList<BodySM*> tool_bodies; + DLIList<TopoDS_Shape*> tool_shapes; + DLIList<CubitBoolean> is_tool_volume, is_volume; + + tool_bodies.append(tool_body_ptr); + //get tool_body's underlying shape, copy it, so boolean wouldn't touch it. + CubitStatus stat = + get_shape_list(tool_bodies, tool_shapes, is_tool_volume, CUBIT_TRUE); + if(!stat) + return stat; + + DLIList<TopoDS_Shape*> shape_list; + stat = get_shape_list(from_bodies, shape_list, is_volume, keep_old); + if(!stat) + { + for (int i = 0; i < tool_shapes.size(); i++) + { + TopoDS_Shape* shape = tool_shapes.get_and_step(); + delete shape; + } + tool_shapes.clean_out(); + return CUBIT_FAILURE; + } + + TopoDS_Shape* tool_shape = tool_shapes.get(); + CubitBoolean has_changed; + DLIList<TopologyBridge*> tbs; + for (int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* from_shape = shape_list.get_and_step(); + //BodySM* from_body = from_bodies.get_and_step(); + BRepAlgoAPI_Common intersector(*from_shape, *tool_shape); + TopoDS_Shape common_shape = intersector.Shape(); + check_operation(common_shape, from_shape, is_volume[i], has_changed, + &intersector, keep_old); + + if(from_shape->IsNull()) + { + PRINT_INFO("The %d body did not have common part with the tool_body.\n", i+1); + continue; + } + else + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*from_shape); + } + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + //ok, we're done wih all cuts, delete unnecessaries. + if(!keep_old) + OCCQueryEngine::instance()->delete_solid_model_entities(tool_body_ptr); + + for(int i = 0; i < tool_shapes.size(); i++) + { + TopoDS_Shape* shape = tool_shapes.get_and_step(); + shape->Nullify(); + delete shape; + } + + if(keep_old) + { + int size = shape_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = shape_list.pop(); + shape->Nullify(); + delete shape; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : check_operation +// Member Type: PRIVATE +// Description: check and update the from_shape according to type of the body. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +void OCCModifyEngine::check_operation(TopoDS_Shape& cut_shape, + TopoDS_Shape*& from_shape, //output + CubitBoolean is_volume, + CubitBoolean& has_changed, //output + BRepAlgoAPI_BooleanOperation* op, + CubitBoolean keep_old) const +{ + //compare to see if the from_shape has gotten cut. + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + if(is_volume) + { + GProp_GProps myProps; + BRepGProp::VolumeProperties(*from_shape, myProps); + double orig_mass = myProps.Mass(); + BRepGProp::VolumeProperties(cut_shape, myProps); + double after_mass = myProps.Mass(); + if(fabs(-after_mass + orig_mass) <= tol) + { + has_changed= CUBIT_FALSE; //common is itself + return; + } + + //got cut. Update the entities + if(after_mass < tol) //no common section + cut_shape.Nullify(); + has_changed = CUBIT_TRUE; + TopExp_Explorer Ex; + Ex.Init(*from_shape, TopAbs_SOLID); + TopoDS_Solid old_solid = TopoDS::Solid(Ex.Current()); + OCCLump::update_OCC_entity(old_solid , cut_shape, op); + } + else + { + GProp_GProps myProps; + BRepGProp::SurfaceProperties(*from_shape, myProps); + double orig_mass = myProps.Mass(); + BRepGProp::SurfaceProperties(cut_shape, myProps); + double after_mass = myProps.Mass(); + if(fabs(-after_mass + orig_mass) <= tol) + { + has_changed= CUBIT_FALSE; //common is itself, or not cut + return; + } + //got cut. Update the entities + if(after_mass < tol)//no common section + cut_shape.Nullify(); + has_changed = CUBIT_TRUE; + if(from_shape->TShape()->ShapeType() == TopAbs_SHELL) + { + TopoDS_Shell old_shell = TopoDS::Shell(*from_shape); + OCCShell::update_OCC_entity(old_shell,cut_shape, op); + } + else + { + TopoDS_Face old_face = TopoDS::Face(*from_shape); + OCCSurface::update_OCC_entity(old_face,cut_shape, op); + } + } + if(keep_old) + delete from_shape; + from_shape = new TopoDS_Shape(cut_shape); +} + +//=============================================================================== +// Function : chop +// Member Type: PUBLIC +// Description: chop boolean operation between OCC-based bodies +// bodies has a size() = 2, a blank body and a tool body. +// chops the blank with the tool, returing the body formed +// by subtracting the tool from the blank, and the body formed +// by intersecting the tool with the blank, simultaneously. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::chop(DLIList<BodySM*>& bodies, + DLIList<BodySM*> &intersectBodies, + DLIList<BodySM*> &outsideBodies, + BodySM*& leftoversBody, + bool keep_old , + bool nonreg) const +{ + //according to Acis chop function, leftoverBody = 0; + leftoversBody = 0; + + //there's no effect of nonreg. keep_old mean if to keep the tool_body + if(bodies.size() != 2) + { + PRINT_WARNING("Chop operation works only on two bodies. Nothing modified\n"); + return CUBIT_FAILURE; + } + + //outsideBodies keeps the surface, curve ids if keep_old is false. + BodySM* blank_body = bodies.get(); + + //copy blank_body for intersect operation, because it will get changed. + DLIList<BodySM*> tool_bodies, from_bodies; + from_bodies.append(blank_body); + BodySM* tool_body = bodies.step_and_get(); + tool_bodies.append(tool_body); + + CubitStatus stat = intersect(tool_body, from_bodies, + intersectBodies, CUBIT_TRUE); + + if(!stat) + return CUBIT_FAILURE; + + stat = subtract(tool_bodies, from_bodies, outsideBodies, + CUBIT_FALSE, keep_old); + + return stat; +} + +//=============================================================================== +// Function : unite +// Member Type: PUBLIC +// Description: unite boolean operation between OCC-based bodies +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::unite(DLIList<BodySM*> &bodies, + DLIList<BodySM*> &newBodies, + bool keep_old) const +{ + if(bodies.size() < 2) + { + newBodies = bodies; + return CUBIT_SUCCESS; + } + //all bodies must have only one lump in order for boolean operation to work. + DLIList<Lump*> lumps; + for (int i = 0; i < bodies.size(); i++) + { + lumps = CAST_TO(bodies.get_and_step(), OCCBody)->lumps(); + if (lumps.size() > 1) + { + PRINT_WARNING("All bodies must have only one lump for boolean operations to work.\n"); + return CUBIT_FAILURE; + } + } + + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + CubitStatus stat = + get_shape_list(bodies, shape_list, is_volume, keep_old); + + if(!stat) + return stat; + + //find a non-sheet body to be the first shape + TopoDS_Shape* first_shape; + CubitBoolean first_is_volume; + if((first_is_volume = is_volume.move_to(CUBIT_TRUE))) + { + int index = is_volume.get_index(); + first_shape = shape_list[index]; + shape_list.remove(first_shape); + is_volume.step(index); + is_volume.remove(); + bodies.step(index); + bodies.remove(); + } + + else + { + first_shape = shape_list.pop(); + bodies.pop(); + } + + int size = shape_list.size(); + for(int i = 0; i < size; i++) + { + TopoDS_Shape* second_shape = shape_list.get_and_step(); + + BRepAlgoAPI_Fuse fuser(*first_shape, *second_shape); + TopoDS_Shape new_shape = fuser.Shape(); + + CubitBoolean has_changed; + check_operation(new_shape, first_shape, first_is_volume, has_changed, &fuser, keep_old); + + check_operation(new_shape,second_shape, is_volume[i], has_changed, &fuser, keep_old); + } + + //ok, we're done with all unites, construct new Body' + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*first_shape); + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + newBodies.append(bodysm); + } + + //ok, we're done with all unites, delete unnecessaries. + if(keep_old) + { + shape_list.append(first_shape); + int size = shape_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = shape_list.pop(); + shape->Nullify(); + delete shape; + } + } + + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::thicken( DLIList<BodySM*>& bodies, + DLIList<BodySM*>& new_bodies, + double depth, + CubitBoolean both) const +{ + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : hollow +// Member Type: PUBLIC +// Description: Hollow existing solid body by remove one or several surfaces +// Can only take one body at a time. +// depth > 0, thick body going outside bodies +// depth < 0, thick body going inside bodies +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::hollow( DLIList<BodySM*>& bodies, + DLIList<Surface*>& surfs_to_remove, + DLIList<BodySM*>& new_bodies, + double depth) const +{ + if(bodies.size() != 1 || surfs_to_remove.size() < 1) + { + PRINT_ERROR("Making thick solid in OCC will take one body and at least one surface at a time.\n"); + return CUBIT_FAILURE; + } + + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + CubitStatus stat = get_shape_list(bodies, shape_list, is_volume, CUBIT_FALSE); + + if(!stat) + return stat; + + if(!is_volume.get())//sheet body + { + PRINT_ERROR("Making thick solid in OCC needs an initial solid body to hollow with.\n"); + return CUBIT_FAILURE; + } + + //make sure the body to be hollowed has only one lump + OCCBody* occ_body = CAST_TO(bodies.get(), OCCBody); + DLIList<Lump*> lumps; + lumps = occ_body->lumps(); + if(lumps.size()!=1) + { + PRINT_ERROR("bodies with more than one lump can't be hollowed to make a thick body.\n"); + return CUBIT_FAILURE; + } + + //make sure surfs_to_remove are all in bodies + DLIList<OCCSurface*> surfaces; + TopTools_ListOfShape face_shapes; + occ_body->get_all_surfaces(surfaces); + for(int i = 0; i < surfs_to_remove.size(); i++) + { + OCCSurface* occ_surf = CAST_TO(surfs_to_remove.get(), OCCSurface); + if(!occ_surf) + continue; + if(!surfaces.is_in_list(occ_surf)) + continue; + TopoDS_Face * face = occ_surf->get_TopoDS_Face(); + face_shapes.Append(*face); + } + + if(face_shapes.IsEmpty()) + { + PRINT_ERROR("The surfaces provided should be from the body to be hollowed.\n"); + return CUBIT_FAILURE; + } + + double tol = 1.e-3; //hard coded for now, can be changed by application + TopoDS_Shape* solid = shape_list.get(); + BRepOffsetAPI_MakeThickSolid hollower(*solid, face_shapes, depth, tol, + BRepOffset_Skin, Standard_False, + Standard_False, GeomAbs_Intersection); + TopoDS_Shape new_shape = hollower.Shape(); + TopoDS_Solid old_solid = TopoDS::Solid(*solid); + OCCLump::update_OCC_entity(old_solid , new_shape, &hollower); + + //ok, we're done with all hollowing, construct new Body' + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : flip_normals +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine :: flip_normals( DLIList<Surface*>& face_list ) const +{ + DLIList<Surface*> surface_list; + while (face_list.size()) + { + OCCSurface* occ_surface = CAST_TO(face_list.pop(), OCCSurface); + OCCShell* occ_shell = occ_surface->my_shell(); + DLIList<OCCSurface*> surfaces; + surfaces.append(occ_surface); + if(occ_shell) //find all surfaces in face_list that belong to this shell + { + int size = face_list.size(); + for ( int i = 0; i < size; i++) + { + occ_surface = CAST_TO(face_list.get(), OCCSurface); + if(occ_shell == occ_surface->my_shell()) + surfaces.append(CAST_TO(face_list.remove(),OCCSurface)); + else + face_list.step(); + } + + if (!occ_shell->is_sheet()) + { + DLIList<OCCCoFace*> cofaces; + cofaces = occ_shell->cofaces(); + for(int i = 0; i < cofaces.size(); i++) + { + OCCCoFace* coface =cofaces.get_and_step(); + occ_surface = coface->surface(); + if(surfaces.is_in_list(occ_surface)) + { + TopoDS_Face* topoface = occ_surface->get_TopoDS_Face(); + TopAbs_Orientation ori = topoface->Orientation(); + topoface->Orientation(ori == TopAbs_FORWARD ? TopAbs_REVERSED : + TopAbs_FORWARD); + occ_surface->set_TopoDS_Face(*topoface); + coface->set_sense(coface->sense() == CUBIT_FORWARD ? + CUBIT_REVERSED : CUBIT_FORWARD); + surface_list.append(occ_surface); + } + } + } + else //sheet body + { + TopoDS_Face* topoface = occ_surface->get_TopoDS_Face(); + TopAbs_Orientation ori = topoface->Orientation(); + topoface->Orientation(ori == TopAbs_FORWARD ? TopAbs_REVERSED : + TopAbs_FORWARD); + occ_surface->set_TopoDS_Face(*topoface); + surface_list.append(occ_surface); + } + PRINT_INFO( "Modified volume\n" ); + } + else + PRINT_WARNING( "Volume was not modified\n" ); + } + face_list = surface_list; + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : sweep_translational +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 09/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_translational( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + const CubitVector& sweep_vector, + double draft_angle, //in Radius + int draft_type, //RightCorner=1 or RoundCorner =2 + bool switchside,//not used, shell and surfaces are one sided, not like Acis + bool rigid, //not used here, in Acis, it means whether the end surface is + // parallel to the starting surface, or perpendicular to the path + Surface* stop_surf, + BodySM* to_body) const +{ + //in OCC, there's no sweep surface with draft option, this can be done by + //creating draft shell then make solid to achieve. + //while if draft_angle is 0, and stop_surf = 0, to_body = 0 + // directly use sweep functions. + TopoDS_Shape *stop_shape = NULL; + if(stop_surf) + { + OCCSurface* occ_surface = CAST_TO(stop_surf, OCCSurface); + stop_shape = occ_surface->get_TopoDS_Face(); + } + else if(to_body) + { + OCCBody* occ_body = CAST_TO(to_body, OCCBody); + if(occ_body->is_sheet_body()) + stop_shape = occ_body->my_sheet_surface()->get_TopoDS_Face(); + else if(occ_body->shell()) + stop_shape = occ_body->shell()->get_TopoDS_Shell(); + else + stop_shape = occ_body->get_TopoDS_Shape(); + } + + gp_Dir adir(sweep_vector.x(), sweep_vector.y(), sweep_vector.z()); + gp_Vec aVec(sweep_vector.x(), sweep_vector.y(), sweep_vector.z()); + + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, &sweep_vector, toposhape); + if(!stat) + continue; + } + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + } + + DLIList<TopologyBridge*> tbs; + //create the draft or the sweep + if(stop_shape == NULL && draft_angle == 0.) + { + BRepSweep_Prism swept(toposhape, aVec); + TopoDS_Shape new_shape = swept.Shape(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + + BRepOffsetAPI_MakeDraft draft(toposhape, adir, draft_angle); + BRepBuilderAPI_TransitionMode Cornertype; + if(draft_type == 1) + Cornertype = BRepBuilderAPI_RightCorner; + else if(draft_type == 2) + Cornertype = BRepBuilderAPI_RoundCorner; + + draft.SetOptions(Cornertype); + if(stop_shape) + draft.Perform(*stop_shape); + else + draft.Perform(sweep_vector.length()); + TopoDS_Shape new_shape = draft.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if(bodysm && surface != NULL) //only gets swept side and original surfaces + { + //get surfaces from the shell body and create a top surface to + //make a swept solid. + OCCShell* occ_shell = CAST_TO(bodysm, OCCBody)->shell(); + if(!occ_shell) + { + PRINT_WARNING("Sweep surface failed inside OCC engine.\n"); + return CUBIT_FAILURE; + } + DLIList<OCCCoFace*> cofaces = occ_shell->cofaces(); + DLIList<Surface*> surface_list; + for(int i = 0; i < cofaces.size(); i++) + surface_list.append(cofaces.get_and_step()->surface()); + + //create the top surface from edges. + DLIList<OCCCoEdge*> coedges; + for(int i = 0; i < surface_list.size(); i++) + CAST_TO(surface_list.get_and_step(), OCCSurface)->get_coedges(coedges); + for(int i = 0; i < coedges.size(); i++) + { + OCCCoEdge* coedge = coedges[i]; + if(coedge == NULL) + continue; + for(int j = i+1; j < coedges.size(); j++) + { + OCCCoEdge* temp_coedge = coedges[j]; + if(temp_coedge == NULL) + continue; + if(coedge->curve() == temp_coedge->curve() && + coedge->sense() != temp_coedge->sense()) + { + coedges.move_to(coedge); + coedges.change_to((OCCCoEdge*)NULL); + coedges.move_to(temp_coedge); + coedges.change_to((OCCCoEdge*)NULL); + } + } + } + coedges.remove_all_with_value(NULL); + assert(coedges.size() > 0); + DLIList<Curve*> curves; + for(int i = 0; i < coedges.size(); i++) + curves.append(coedges.get_and_step()->curve()); + + Surface* surf = make_Surface(PLANE_SURFACE_TYPE, curves); + if(!surf) + surf = make_Surface(BEST_FIT_SURFACE_TYPE, curves); + if(!surf) + { + PRINT_ERROR("Can't calculate for the top surface.\n"); + continue; + } + surface_list.append(surf); + DLIList<BodySM*> bodies; + create_solid_bodies_from_surfs(surface_list, bodies); + + if(bodies.size() == 1) + bodysm = bodies.get(); + else + { + PRINT_WARNING("Sweep surface failed in creating solid.\n"); + return CUBIT_FAILURE; + } + } + if (bodysm) + result_body_list.append(bodysm); + } + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::get_sweepable_toposhape(OCCCurve*& curve, + TopoDS_Shape& toposhape)const +{ + DLIList<OCCLoop*> loops; + loops = curve->loops(); + if( loops.size()) //not a free curve + { + //copy the curve + Curve* c_curve = make_Curve(curve); + if(c_curve) + curve = CAST_TO(c_curve, OCCCurve); + else + { + PRINT_ERROR("Can't copy the curve for sweep.\n"); + return CUBIT_FAILURE; + } + } + TopoDS_Edge *edge = curve->get_TopoDS_Edge( ); + toposhape = BRepBuilderAPI_MakeWire(*edge); + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::get_sweepable_toposhape(OCCSurface*& surface, + const CubitVector* sweep_v_p, + TopoDS_Shape& toposhape)const +{ + GeometryEntity* ref_ent = NULL; + //Make copy of the surface if it's not a sheet surface. + Surface* c_surface = NULL; + if(surface != NULL) + { + //check if the surface is sheet body, if not, copy it. + if(surface->my_body() == NULL) //not a sheet body + { + c_surface = make_Surface(surface); + if (c_surface == NULL) + { + PRINT_ERROR("Cannot copy surface in sweep_translational.\n"); + return CUBIT_FAILURE; + } + surface = CAST_TO(c_surface, OCCSurface); + } + + if(sweep_v_p) + { + CubitVector center = surface->center_point(); + CubitVector normal; + surface->closest_point(center,NULL,&normal); + CubitVector sweep_vector = *sweep_v_p; + if(normal % sweep_vector > 0) + { + DLIList<Surface*> surfaces; + surfaces.append(surface); + flip_normals(surfaces); + surface = CAST_TO(surfaces.get(), OCCSurface); + ref_ent = (GeometryEntity *)surface; + } + + else if(normal % sweep_vector == 0) + { + PRINT_ERROR("Sweeping direction should not be on the surface.\n"); + return CUBIT_FAILURE; + } + } + else + ref_ent = (GeometryEntity *)surface; + + if(surface->my_body() != NULL) //sheet body + { + delete surface->my_body(); + delete surface->my_shell(); + delete surface->my_lump(); + surface->set_shell(NULL); + surface->set_lump(NULL); + surface->set_body(NULL); + } + + TopoDS_Shape* toposhape_prt = + OCCQueryEngine::instance()->get_TopoDS_Shape_of_entity(ref_ent); + + if(!toposhape_prt) + { + PRINT_WARNING("GeometryEntity without TopoDS_Shape found.\n"); + return CUBIT_FAILURE; + } + toposhape = *toposhape_prt; + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_perpendicular( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + double distance, + double draft_angle, + int draft_type, + bool switchside, //has no effect + bool rigid, //has no effect + Surface* stop_surf, + BodySM* to_body) const +{ + //find the vector perpendicular to the ref_ent normal, and sweep_translate + //the 'distance' along this vector + DLIList<GeometryEntity*> edge_list; + CubitVector vec; + for(int i = 0; i < ref_ent_list.size(); i++) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + Surface *face = CAST_TO(ref_ent, Surface); + Curve* edge = CAST_TO(ref_ent, Curve); + DLIList<GeometryEntity*> face_list; + if(face != NULL) + { + OCCSurface* occ_face = CAST_TO(face, OCCSurface); + CubitVector center = occ_face->center_point(); + CubitVector closest_p, unit_normal; + CubitStatus stat = + occ_face->closest_point(center, &closest_p, &unit_normal); + if(stat) + { + vec = distance * unit_normal; + face_list.append(ref_ent); + stat = sweep_translational(face_list, result_body_list, vec, + draft_angle, draft_type, switchside, + rigid, stop_surf, to_body); + } + } + else if (edge != NULL) + { + edge_list.append(ref_ent); + } + } + if(edge_list.size()) + PRINT_ERROR("Curves cannot be swept perpendicularly, please use the vector sweep.\n"); + + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : sweep_rotational +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_rotational( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + const CubitVector& point, + const CubitVector& direction, + double angle, //in radians + int steps, //not used + double draft_angle, //not used + int draft_type, //not used + bool switchside, //not used + bool make_solid, + bool rigid, //not used + Surface* stop_surf, //not used + BodySM* to_body ) const //not used +{ + gp_Dir adir(direction.x(), direction.y(), direction.z()); + gp_Pnt pt = gp_Pnt( point.x(), point.y(), point.z()); + gp_Ax1 axis = gp_Ax1(pt, adir); + + gp_Lin line = gp_Lin(axis); + TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(line); + OCCCurve* acurve = new OCCCurve(&edge); + assert(acurve); + + CubitVector start; + CubitVector end; + + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface or curve for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, (CubitVector*)NULL, toposhape); + if(!stat) + continue; + //only non-intersecting of surface and axis can be swept. + DLIList<CubitVector*> intersect_pts; + OCCQueryEngine::instance()->get_intersections(acurve, surface, + intersect_pts, CUBIT_TRUE); + if(intersect_pts.size() > 0) + { + PRINT_ERROR("Only surfaces with no intersection point with the axis can be revolve-swept.\n"); + continue; + } + } + else if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + //closed curve can't intersect with the axis, while open curve can only + //intersect the axis at the end points. + //only curve not intersecting with axis in curve's middle locations + //can be revolved + DLIList<CubitVector*> intersect_pts; + OCCQueryEngine::instance()->get_intersections(curve, acurve, + intersect_pts, CUBIT_TRUE, CUBIT_TRUE); + if(!toposhape.Closed()) + { + //get start and end points + DLIList<OCCPoint*> point_list; + curve->get_points(point_list); + assert(2 == point_list.size()); + GeometryType type = curve->geometry_type(); + start = point_list.get_and_step()->coordinates(); + end = point_list.get()->coordinates(); + CubitBoolean start_int = CUBIT_FALSE; + CubitBoolean end_int = CUBIT_FALSE; + if(intersect_pts.size() > 0) + { + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + CubitBoolean non_int = CUBIT_FALSE; + for(int i = 0; i < intersect_pts.size(); i++) + { + CubitVector prt = *(intersect_pts.get_and_step()); + if(prt.distance_between(start) > tol && + prt.distance_between(end) > tol) + { + non_int = CUBIT_TRUE; + PRINT_ERROR("Only curves with no intersection point with the axis can be revolve-swept.\n"); + break; + } + else if(prt.distance_between(start) <= tol) + start_int = CUBIT_TRUE; + else if(prt.distance_between(end) <= tol) + end_int = CUBIT_TRUE; + } + if(non_int) + continue; + if(start_int && end_int && type == STRAIGHT_CURVE_TYPE) + { + PRINT_ERROR("Sweep along curve itself is not allowed.\n"); + continue; + } + } + } + else + { + if(intersect_pts.size() > 0) + { + PRINT_ERROR("Only curves with no intersection point with the axis can be revolve-swept.\n"); + continue; + } + } + } + else + { + PRINT_ERROR("Only surface or curve can be revolve-swept.\n"); + continue; + } + TopoDS_Shape new_shape; + DLIList<TopologyBridge*> tbs; + if(make_solid && curve != NULL ) + //giving an open wire and want a solid + { + if(!toposhape.Closed()) + { + //project the start and end points onto the axis + CubitBoolean start_closed = CUBIT_FALSE; + CubitBoolean end_closed = CUBIT_FALSE; + if(acurve->point_containment(start) != CUBIT_PNT_OFF) + start_closed = CUBIT_TRUE; + if(acurve->point_containment(end) != CUBIT_PNT_OFF) + end_closed = CUBIT_TRUE; + CubitVector start_proj, end_proj; + TopoDS_Edge edge1, edge2; + BRepBuilderAPI_MakeWire m_wire; + if(!start_closed) + { + acurve->closest_point(start, start_proj); + gp_Pnt pt1 = gp_Pnt( start.x(), start.y(), start.z()); + gp_Pnt pt2 = gp_Pnt( start_proj.x(), start_proj.y(), start_proj.z()); + edge1 = BRepBuilderAPI_MakeEdge(pt1, pt2); + m_wire.Add(edge1); + m_wire.Add(TopoDS::Wire(toposhape)); + } + else + { + m_wire.Add(TopoDS::Wire(toposhape)); + start_proj = start; + } + + if(!end_closed) + { + acurve->closest_point(end,end_proj); + gp_Pnt pt1 = gp_Pnt( end.x(), end.y(), end.z()); + gp_Pnt pt2 = gp_Pnt( end_proj.x(), end_proj.y(), end_proj.z()); + edge2 = BRepBuilderAPI_MakeEdge(pt1, pt2); + m_wire.Add(edge2); + } + + else + end_proj = end; + + gp_Pnt pt1 = gp_Pnt( end_proj.x(), end_proj.y(), end_proj.z()); + gp_Pnt pt2 = gp_Pnt( start_proj.x(), start_proj.y(), start_proj.z()); + TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge(pt2, pt1); + m_wire.Add(edge3); + + TopoDS_Wire wire = m_wire.Wire(); + toposhape = BRepBuilderAPI_MakeFace(wire); + } + else //closed + { + TopoDS_Wire wire = TopoDS::Wire(toposhape); + toposhape = BRepBuilderAPI_MakeFace(wire); + } + } + BRepSweep_Revol revol(toposhape, axis, angle); + new_shape = revol.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + OCCQueryEngine::instance()->delete_solid_model_entities(acurve); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : sweep_along_curve +// Member Type: PUBLIC +// Description: The ref_edge_list must provide a list of curves which are +// connected, and making G1 continuous wire. +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine::sweep_along_curve( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + DLIList<Curve*>& ref_edge_list, + double draft_angle, //only used for straight curve case + int draft_type, //only used for straight curve case + bool rigid, //not used + Surface* stop_surf, //not used + BodySM* to_body) const //not used +{ + //make wire out of ref_edge_list + BRepBuilderAPI_MakeWire awire; + TopTools_ListOfShape L; + OCCCurve* occ_curve = NULL; + GeometryType type; + int num_curve = 0; + for(int i = 0; i < ref_edge_list.size(); i++) + { + Curve* curve = ref_edge_list.get_and_step(); + occ_curve = CAST_TO(curve, OCCCurve); + if(!occ_curve) + continue; + TopoDS_Edge* topoedge = occ_curve->get_TopoDS_Edge( ); + BRepBuilderAPI_Copy api_copy(*topoedge); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topoedge); + L.Append(newShape); + type = occ_curve->geometry_type(); + num_curve++; + } + if(L.IsEmpty()) + { + PRINT_ERROR("There's no valid sweeping path.\n"); + return CUBIT_FAILURE; + } + + if(num_curve == 1 && type == STRAIGHT_CURVE_TYPE && draft_angle != 0.0) + { + DLIList<OCCPoint*> point_list; + occ_curve->get_points(point_list); + CubitVector v1 = point_list.get_and_step()->coordinates(); + CubitVector v2 = point_list.get()->coordinates(); + CubitVector sweep_vector = v2-v1; + return sweep_translational(ref_ent_list,result_body_list,sweep_vector, + draft_angle, draft_type, CUBIT_FALSE, + rigid, stop_surf, to_body); + } + awire.Add(L); + TopoDS_Wire wire; + wire = awire.Wire(); + + BRepTools_WireExplorer it(wire); + int num_edges = 0; + for(; it.More(); it.Next()) + num_edges++; + + BRepLib_FuseEdges fuser(wire); + fuser.SetConcatBSpl(); + fuser.Perform(); + TopoDS_Shape spline = fuser.Shape(); + wire = TopoDS::Wire(spline); + + DLIList<TopologyBridge*> tbs; + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface or curve for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, (CubitVector*)NULL, toposhape); + if(!stat) + continue; + } + else if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + } + + //sweep along the wire + BRepOffsetAPI_MakePipe maker(wire, toposhape); + if(!maker.IsDone()) + { + PRINT_ERROR("Can't sweep along the provided curve(s).\n"); + continue; + } + TopoDS_Shape newShape = maker.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(newShape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + return CUBIT_SUCCESS; +} + +//HEADER- Webcut-related functions + +//=============================================================================== +// Function : webcut +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut(DLIList<BodySM*>& webcut_body_list, + const CubitVector &v1, + const CubitVector &v2, + const CubitVector &v3, + DLIList<BodySM*>& results_list, + bool imprint ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut(DLIList<BodySM*>& /*webcut_body_list*/, + BodySM const* /*tool_body*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_across_translate +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_across_translate( DLIList<BodySM*>& /*body_list*/, + Surface* /*plane_surf1*/, + Surface* /*plane_surf2*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_sheet +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_sheet(DLIList<BodySM*> & /*webcut_body_list*/, + BodySM * /*sheet_body*/, + DLIList<BodySM*> & /*new_bodies*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_extended_surf +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_extended_surf(DLIList<BodySM*> & /*webcut_body_list*/, + Surface * /*extend_from*/, + DLIList<BodySM*> & /*new_bodies*/, + int & /*num_cut*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_cylinder +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_cylinder(DLIList<BodySM*> &webcut_body_list, + double radius, + const CubitVector &axis, + const CubitVector ¢er, + DLIList<BodySM*>& results_list, + bool imprint ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_brick +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_brick( + DLIList<BodySM*>& /*webcut_body_list*/, + const CubitVector &/*center*/, + const CubitVector* /*axes[3]*/, + const CubitVector &/*extension*/, + DLIList<BodySM*> &/*results_list*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_planar_sheet +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_planar_sheet( + DLIList<BodySM*>& /*webcut_body_list*/, + const CubitVector &/*center*/, + const CubitVector* /*axes[2]*/, + double /*width*/, + double /*height*/, + DLIList<BodySM*> &/*results_list*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_curve_loop +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_curve_loop( + DLIList<BodySM*> &/*webcut_body_list*/, + DLIList<Curve*> &/*ref_edge_list*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : section +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 11/08 +//=============================================================================== +CubitStatus OCCModifyEngine::section( DLIList<BodySM*> §ion_body_list, + const CubitVector &point_1, + const CubitVector &point_2, + const CubitVector &point_3, + DLIList<BodySM*>& new_body_list, + bool keep_normal_side, + bool keep_old, + bool keep_both_sides) +{ + if (keep_both_sides == CUBIT_TRUE ) + { + PRINT_ERROR("keeping both sides of section is not implemented.\n"); + return CUBIT_FAILURE; + } + + //Calculate normal of the section plan + CubitVector v1, v2, normal; + v1 = point_2 - point_1; + v2 = point_3 - point_1; + normal = ~(v1 * v2); + if(normal.length() != 1) + { + PRINT_ERROR("The three points are co-linear, and can't be used as a cutting plane.\n"); + return CUBIT_FAILURE; + } + + if(keep_normal_side) + normal *= -1; + + gp_Pnt pt = gp_Pnt( point_1.x(), point_1.y(), point_1.z()); + gp_Dir normal_dir(normal.x(), normal.y(), normal.z()); + gp_Pln plane(pt, normal_dir); + gp_Vec vec(normal_dir); + pt = pt.Translated(vec); + + TopoDS_Face face = BRepBuilderAPI_MakeFace(plane); + TopoDS_Solid solid = BRepPrimAPI_MakeHalfSpace(face, pt); + + DLIList<CubitBoolean> is_tool_volume; + is_tool_volume.append(CUBIT_TRUE); + DLIList<CubitBox*> tool_boxes ; + Bnd_Box box; + BRepBndLib::Add(solid, box); + double min[3], max[3]; + box.Get(min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox* cBox = new CubitBox(min, max); + + tool_boxes.append(cBox); + DLIList<TopoDS_Shape*> solids; + solids.append(&solid); + CubitStatus stat = do_subtract(section_body_list, solids, is_tool_volume, + &tool_boxes, new_body_list, keep_old) ; + delete cBox; + return stat; +} + +//=============================================================================== +// Function : split_body +// Member Type: PUBLIC +// Description: Splits multiple lumps in one body into separate bodies +// Author : Corey Ernst +// Date : 08/04 +//=============================================================================== +CubitStatus OCCModifyEngine::split_body( BodySM *body_ptr, + DLIList<BodySM*> &new_bodies ) +{ + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : reverse_body +// Member Type: PUBLIC +// Description: Turn body inside-out +// Author : Jason Kraftcheck +// Date : 05/25/04 +//=============================================================================== +CubitStatus OCCModifyEngine::reverse_body( BodySM* body_ptr ) +{ + return CUBIT_SUCCESS; +} + + + +//=============================================================================== +// Function : split_periodic +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::split_periodic( BodySM * /*body_ptr*/, + BodySM *& /*new_body*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : regularize_body +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::regularize_body( BodySM * /*body_ptr*/, + BodySM *& /*new_body_ptr*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : regularize_refentity +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::regularize_entity( GeometryEntity * /*old_entity_ptr*/, + BodySM *& /*new_body_ptr*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : offset_curves +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::offset_curves( DLIList<Curve*>& /*ref_edge_list*/, + DLIList<Curve*>&, + double /*offset_distance*/, + const CubitVector& /*offset_direction*/, + int /*gap_type*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : trim_curve +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +Curve* OCCModifyEngine::trim_curve( Curve* /*trim_curve*/, + const CubitVector& /*trim_vector*/, + const CubitVector& /*keep_vector*/, + bool ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return 0; +} + +//=============================================================================== +// Function : create_body_from_surfs +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 4/22/08 +//=============================================================================== +CubitStatus OCCModifyEngine::create_solid_bodies_from_surfs(DLIList<Surface*> & ref_face_list, + DLIList<BodySM*>& new_bodies, + bool keep_old, + bool heal) const +{ + //keep_old and heal are ignored, always delete old. + //all surfaces should be stand along surface bodies or shell bodies' surface + Lump* lump = make_Lump(ref_face_list); + if (!lump) + return CUBIT_FAILURE; + + new_bodies.append(CAST_TO(lump, OCCLump)->get_body()); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : create_arc_three +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 12/08 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_three( Point* pt1, + Point* pt2, + Point* pt3, + bool full ) +{ + if(!full) + { + CubitVector v2(pt2->coordinates()); + return make_Curve(ARC_CURVE_TYPE,pt1,pt3, &v2, CUBIT_FORWARD); + } + else + { + CubitVector v1(pt1->coordinates()); + CubitVector v2(pt2->coordinates()); + CubitVector v3(pt3->coordinates()); + + gp_Pnt gp_pt1(v1.x(),v1.y(), v1.z()); + gp_Pnt gp_pt2(v2.x(),v2.y(), v2.z()); + gp_Pnt gp_pt3(v3.x(),v3.y(), v3.z()); + + Handle(Geom_Circle) curve_ptr; + curve_ptr = GC_MakeCircle(gp_pt1,gp_pt2,gp_pt3); + + OCCPoint* occ_pt1 = CAST_TO(const_cast<Point*>(pt1),OCCPoint); + TopoDS_Vertex * vt1 = occ_pt1->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt1); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); + } +} + +//=============================================================================== +// Function : create_arc_three +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 12/08 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_three( Curve* curve1, + Curve* curve2, + Curve* curve3, + bool full ) +{ + OCCCurve* occ_crv1 = CAST_TO(curve1, OCCCurve); + OCCCurve* occ_crv2 = CAST_TO(curve2, OCCCurve); + OCCCurve* occ_crv3 = CAST_TO(curve3, OCCCurve); + GeometryType type1 = occ_crv1->geometry_type(); + GeometryType type2 = occ_crv2->geometry_type(); + GeometryType type3 = occ_crv3->geometry_type(); + if(type1 != STRAIGHT_CURVE_TYPE || type2 != STRAIGHT_CURVE_TYPE || + type3 != STRAIGHT_CURVE_TYPE) + { + PRINT_WARNING("Need three straight curves to calculate incenter.\n"); + return (Curve*) NULL; + } + + //0.check that non of the curves are parallel of each other. + double u11, u12, u21, u22, u31, u32; + occ_crv1->get_param_range(u11, u12); + occ_crv2->get_param_range(u21, u22); + occ_crv3->get_param_range(u31, u32); + + CubitVector pt1, pt2, pt3; + occ_crv1->position_from_u(u11, pt1); + occ_crv2->position_from_u(u21, pt2); + occ_crv3->position_from_u(u31, pt3); + + CubitVector tangent1, tangent2, tangent3; + occ_crv1->get_tangent(pt1, tangent1); + occ_crv2->get_tangent(pt2, tangent2); + occ_crv3->get_tangent(pt3, tangent3); + + CubitVector normal1 = tangent1 * tangent2; + CubitVector normal2 = tangent2 * tangent3; + CubitVector normal3 = tangent3 * tangent1; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + if( normal1.length()< tol || normal2.length()< tol || + normal3.length() < tol ) + { + PRINT_WARNING("Three curves must be able to form a triangle.\n"); + return (Curve*) NULL; + } + + //normals must parallel to each other, meaning all curves must be on + //the same plane. + normal1.normalize(); + normal2.normalize(); + normal3.normalize(); + + CubitVector parallel1 = normal1 * normal2; + CubitVector parallel2 = normal2 * normal3; + CubitVector parallel3 = normal3 * normal1; + if(parallel1.length() > tol || parallel2.length() > tol || + parallel3.length() > tol) + { + PRINT_WARNING("Three curves must be able to form a triangle.\n"); + return (Curve*) NULL; + } + //1.find the angle between each of the two curves + double angle1, angle2, angle3; + angle1 = tangent1.interior_angle(tangent2); + angle2 = tangent2.interior_angle(tangent3); + angle3 = tangent3.interior_angle(tangent1); + + //2.create curves to bisection each of the angle passing through the + // vertices of the triangle + DLIList<CubitVector*> intscts; + CubitVector vt1, vt2, vt3; + OCCQueryEngine::instance()->get_intersections(curve1, curve2, intscts,0,0); + vt1 = *intscts.get(); + intscts.clean_out(); + OCCQueryEngine::instance()->get_intersections(curve2,curve3, intscts,0,0); + vt2 = *intscts.get(); + intscts.clean_out(); + OCCQueryEngine::instance()->get_intersections(curve3, curve1, intscts,0,0); + vt3 = *intscts.get(); + //Create 6 curves, find 3 of them which have intersection points inside + // the third curve + CubitVector t_curve11 = + vectorRotate(angle1/2.0, normal1, tangent1); + t_curve11.normalize(); + CubitVector p11 = vt1+t_curve11; + + CubitVector t_curve12 = + vectorRotate(90.0 - angle1/2.0, -normal1, tangent1); + t_curve12.normalize(); + CubitVector p12 = vt1 + t_curve12; + + CubitVector t_curve21 = + vectorRotate(angle2/2.0, normal2, tangent2); + t_curve21.normalize(); + CubitVector p21 = vt2 + t_curve21; + + CubitVector t_curve22 = + vectorRotate(90.0 - angle2/2.0, -normal2, tangent2); + t_curve22.normalize(); + CubitVector p22 = vt2 + t_curve22; + + CubitVector t_curve31 = + vectorRotate(angle3/2.0, normal3, tangent3); + t_curve31.normalize(); + CubitVector p31 = vt3 + t_curve31; + + CubitVector t_curve32 = + vectorRotate(90.0 - angle3/2.0, -normal3, tangent3); + t_curve32.normalize(); + CubitVector p32 = vt3 + t_curve32; + + //3. find the intersection of each of the bisection curve with the third curve + CubitVector int_pt1, int_pt2, int_pt3; + intscts.clean_out(); + CubitBoolean none = CUBIT_FALSE; + OCCQueryEngine::instance()->get_intersections(curve3, vt1, p11, intscts,none,none); + CubitVector int_pt = *intscts.pop(); + double u = occ_crv3->u_from_position (int_pt); + if(u >= u31-tol && u <= u32+tol) //found intersection point + int_pt1 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve3, vt1, p12, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv3->u_from_position (int_pt); + if(u >= u31-tol && u <= u32+tol) + int_pt1 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } + } + + OCCQueryEngine::instance()->get_intersections(curve1, vt2, p21, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv1->u_from_position (int_pt); + if(u >= u11-tol && u <= u12+tol) //found intersection point + int_pt2 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve1, vt2, p22, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv1->u_from_position (int_pt); + if(u >= u11-tol && u <= u12+tol) + int_pt2 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } + } + + OCCQueryEngine::instance()->get_intersections(curve2, vt3, p31, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv2->u_from_position (int_pt); + if(u >= u21-tol && u <= u22+tol) //found intersection point + int_pt3 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve2, vt3, p32, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv2->u_from_position (int_pt); + if(u >= u21-tol && u <= u22+tol) + int_pt3 = int_pt; + else + { + PRINT_ERROR("Can't find the intesection point to create circle.\n"); + return (Curve*) NULL; + } + } + //4. use the 3 intersection points to find the arc or circle. + OCCPoint occ_p1(int_pt1); + OCCPoint occ_p2(int_pt2); + OCCPoint occ_p3(int_pt3); + return create_arc_three(&occ_p1, &occ_p2, &occ_p3, full); +} + +//=============================================================================== +// Function : create_arc_center_edge +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_center_edge( Point* /*ref_vertex1*/, + Point* /*ref_vertex2*/, + Point* /*ref_vertex3*/, + const CubitVector& /*normal*/, + double /*radius*/, + bool /*full*/ ) +{ + return NULL; +} + +CubitStatus +OCCModifyEngine::create_curve_combine( DLIList<Curve*>& curve_list, + Curve *&new_curve_ptr ) +{ + PRINT_ERROR("Curve combine is not implemented for facet based models\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_gqe +// Member Type: PUBLIC +// Description: get the facet geometry query engince instance pointer +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +GeometryQueryEngine *OCCModifyEngine::get_gqe() +{ + return OCCQueryEngine::instance(); +} + +//=============================================================================== +// Function : is_modify_engine +// Member Type: PUBLIC +// Description: return CUBIT_TRUE if the tb_ptr belongs to this modify engine +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitBoolean OCCModifyEngine::is_modify_engine(const TopologyBridge *tb_ptr) const +{ + return tb_ptr->get_geometry_query_engine() == OCCQueryEngine::instance(); +} + +//=============================================================================== +// Function : get_offset_intersections +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_offset_intersections( Curve* /*ref_edge1*/, + Curve* /*ref_edge2*/, + DLIList<CubitVector*>& /*intersection_list*/, + double /*offset*/, + CubitBoolean /*ext_first*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_offset_intersections +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_offset_intersections( Curve* /*ref_edge_ptr*/, + Surface* /*ref_face_ptr*/, + DLIList<CubitVector*> & /*intersection_list*/, + double /*offset*/, + CubitBoolean /*ext_surf*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : surface_intersection +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::surface_intersection( Surface * /*surface1_ptr*/, + Surface * /*surface2_ptr*/, + DLIList<Curve*> &/*inter_graph*/, + const double /*tol*/) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_mid_plane +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_mid_plane( const CubitVector & /*point_1*/, + const CubitVector & /*point_2*/, + const CubitVector & /*point_3*/, + BodySM * /*body_to_trim_to*/, + BodySM *& /*midplane_body*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_spheric_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_conic_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_toric_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_chamfer +// Member Type: PUBLIC +// Description: Chamfer curves on solid bodies. The left and right offsets are +// with respect to the curve direction. If the given right offset +// is negative, the left offset is used. Users can preview to +// clarify the meaning of left and right. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_chamfer( DLIList<Curve*> & /*curve_list*/, + double /*left_offset*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + double /*right_offset*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_chamfer +// Member Type: PUBLIC +// Description: Chamfer vertices on solid or sheet bodies. On a solid body +// there can be up to 3 offsets; on a sheet body up to 2 offsets. +// The offsets are in the direction of the supplied edges. If +// multiple vertices are supplied, only one offset value is +// allowed and the edges are not used. +// Author : +// Date : +//============================================================================= +CubitStatus +OCCModifyEngine::tweak_chamfer( DLIList<Point*> & /*point_list*/, + double /*offset1*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + Curve * /*edge1*/, + double /*offset2*/, + Curve * /*edge2*/, + double /*offset3*/, + Curve * /*edge3*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given curves on solid +// bodies. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_fillet( DLIList<Curve*> & /*curve_list*/, + double /*radius*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given curves on a solid +// body. The fillet has a variable radius from the start to the +// end of the curve. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_fillet( Curve * /*curve_ptr*/, + double /*start_radius*/, + double /*end_radius*/, + BodySM *& /*new_bodysm_ptr*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given vertices on sheet +// bodies. +// Author : +// Date : +//============================================================================= +CubitStatus +OCCModifyEngine::tweak_fillet( DLIList<Point*> & /*ref_vertex_list*/, + double /*radius*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_move +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes along a vector. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_move( DLIList<Surface*> & /*surface_list*/, + const CubitVector & /*delta*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/ , + CubitBoolean show_preview) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_move +// Member Type: PUBLIC +// Description: Tweak specified curves of a sheet body along a vector. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_move( DLIList<Curve*> & /*curve_list*/, + const CubitVector & /*delta*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_offset +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes by offsetting +// those faces by the offset distance. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_offset( DLIList<Surface*> & /*surface_list*/, + double /*offset_distance*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_offset +// Member Type: PUBLIC +// Description: Tweak specified curves of a sheet body or bodies by offsetting +// those curves by the offset distance. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_offset( DLIList<Curve*> & /*curve_list*/, + double /*offset_distance*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_remove +// Member Type: PUBLIC +// Description: Function to remove surfaces from a body and then extend the +// remaining surfaces to fill the gap or hole. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_remove( DLIList<Surface*> & /*surface_list*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*extend_adjoining*/, + CubitBoolean /*keep_surface*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_remove +// Member Type: PUBLIC +// Description: Function to remove curves from a sheet body and then extend the +// remaining curves or fill the gap or hole. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_remove( DLIList<Curve*> & /*curve_list*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes up to a target +// surface. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Surface*> & /*surface_list*/, + DLIList<Surface*> & , + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*reverse_flg*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified edges of a surface or set of surfaces (in sheet +// bodies) up to a target surface. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/, + DLIList<Surface*> & /*target_surfs*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean , + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified edges of a sheet body or bodies up to a target +// curve that is part of a sheet body. The target is a surface +// created by thickening the owning surface of the target curve. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/, + DLIList<Curve*> & /*target_curve_ptr*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::remove_curve_slivers( BodySM* /*body*/, + double /*lengthlimit*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a net surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_net_surface( DLIList<Surface*>& /*ref_face_list*/, + BodySM *& /*new_body*/, + DLIList<DLIList<CubitVector*>*> & /*vec_lists_u*/, + DLIList<DLIList<CubitVector*>*> & /*vec_lists_v*/, + double /*net_tol*/, + CubitBoolean /*heal*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a net surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_net_surface( DLIList<Curve*>& /*u_curves*/, + DLIList<Curve*>& /*v_curves*/, + BodySM *& /*new_body*/, + double /*net_tol*/, + CubitBoolean /*heal*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates an offset surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_offset_surface( Surface* /*ref_face_ptr*/, + BodySM*& /*new_body*/, + double /*offset_distance*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates an offset body. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_offset_body( BodySM* body_ptr, + BodySM*& new_bodysm, + double offset_distance ) const +{ + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a skin surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_skin_surface( DLIList<Curve*>& /*curves*/, + BodySM*& /*new_body*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a body from lofting surfaces. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::loft_surfaces( Surface * /*face1*/, + const double & /*takeoff1*/, + Surface * /*face2*/, + const double & /*takeoff2*/, + BodySM*& /*new_body*/, + CubitBoolean /*arc_length_option*/, + CubitBoolean /*twist_option*/, + CubitBoolean /*align_direction*/, + CubitBoolean /*perpendicular*/, + CubitBoolean /*simplify_option*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a body by lofting surfaces between bodies. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::loft_surfaces_to_body( Surface * /*face1*/, + const double & /*takeoff1*/, + Surface * /*face2*/, + const double & /*takeoff2*/, + BodySM*& /*new_body*/, + CubitBoolean /*arc_length_option*/, + CubitBoolean /*twist_option*/, + CubitBoolean /*align_direction*/, + CubitBoolean /*perpendicular*/, + CubitBoolean /*simplify_option*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_surface( DLIList<CubitVector*>& /*vec_list*/, + BodySM *& /*new_body*/, + Surface * /*ref_face_ptr*/, + CubitBoolean /*project_points*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a weld surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_weld_surface( CubitVector & /*root*/, + Surface * /*ref_face1*/, + double /*leg1*/, + Surface * /*ref_face2*/, + double /*leg2*/, + BodySM *& /*new_body*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_surfaces( + DLIList<BodySM*> &blank_bodies, + DLIList<Surface*> &surfaces, + const CubitVector& sweep_vector, + bool sweep_perp, + bool through_all, + bool outward, + bool up_to_next, + Surface *stop_surf, + Curve *curve_to_sweep_along, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_curves( + DLIList<BodySM*> &blank_bodies, + DLIList<Curve*> &curves, + const CubitVector& sweep_vector, + bool through_all, + Surface *stop_surf, + Curve *curve_to_sweep_along, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_surfaces_rotated( + DLIList<BodySM*> &blank_bodies, + DLIList<Surface*> &surfaces, + const CubitVector &point, + const CubitVector &sweep_axis, + double angle, + Surface *stop_surf, + bool up_to_next, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_curves_rotated( + DLIList<BodySM*> &blank_bodies, + DLIList<Curve*> &curves, + const CubitVector &point, + const CubitVector &sweep_axis, + double angle, + Surface *stop_surf, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::scale( BodySM *&body, const CubitVector& factors ) +{ + return OCCQueryEngine::instance()->scale( body, factors ); +} + +CubitStatus OCCModifyEngine::tolerant_imprint( DLIList<BodySM*> &bodies_in, + DLIList<BodySM*> &new_bodies, + DLIList<TopologyBridge*>*, + DLIList<TopologyBridge*>* ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +// EOF Copied: cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2494 (from rev 2494, cgm/trunk/geom/OCC/OCCModifyEngine.cpp) =================================================================== --- cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2494 (rev 0) +++ cgm/trunk/geom/OCC/OCCModifyEngine.cpp_2494 2008-12-23 20:11:34 UTC (rev 2498) @@ -0,0 +1,5631 @@ +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- + +// Filename : OCCModifyEngine.cpp +// +// Purpose : ModifyEngine for OCC geometry +// +// Special Notes : Modeled after GeometryModifyEngine and AcisModifyEngine. +// +// Author : Jane Hu +// +// Creation Date : 1/08 +// +//------------------------------------------------------------------------- +#include "gp_Pnt.hxx" +#include "gp_Ax2.hxx" +#include "gp_Dir.hxx" +#include "gp_Hypr.hxx" +#include "gp_Parab.hxx" +#include "gp_Elips.hxx" +#include "gp_Pln.hxx" +#include "gp_Cylinder.hxx" +#include "gp_Cone.hxx" +#include "gp_Sphere.hxx" +#include "gp_Torus.hxx" +#include "BRepBuilderAPI_MakeShell.hxx" +#include "BRepBuilderAPI_MakeSolid.hxx" +#include "BRepOffsetAPI_MakeDraft.hxx" +#include "BRepBuilderAPI_TransitionMode.hxx" +#include "BRepBuilderAPI_MakeWire.hxx" +#include "BRepPrimAPI_MakeHalfSpace.hxx" +#include "BRepBndLib.hxx" +#include "TopoDS_Shape.hxx" +#include "TopAbs_Orientation.hxx" +#include "TColgp_Array1OfPnt.hxx" +#include "GC_MakeArcOfCircle.hxx" +#include "GC_MakeCircle.hxx" +#include "GC_MakeArcOfHyperbola.hxx" +#include "GC_MakeArcOfParabola.hxx" +#include "GC_MakeArcOfEllipse.hxx" +#include "GC_MakeSegment.hxx" +#include "GC_MakeTrimmedCone.hxx" +#include "GC_MakeTrimmedCylinder.hxx" +#include "gce_MakeElips.hxx" +#include "Geom_BezierCurve.hxx" +#include "BndLib_AddSurface.hxx" +#include "Handle_Geom_Plane.hxx" +#include "BRepExtrema_DistShapeShape.hxx" +#include "Extrema_ExtPC.hxx" +#include "BRepPrimAPI_MakePrism.hxx" +#include "BRepSweep_Revol.hxx" +#include "BRepPrimAPI_MakeCone.hxx" +#include "BRepOffsetAPI_ThruSections.hxx" +#include "BRepLib_FuseEdges.hxx" +#include "BRepOffsetAPI_MakePipe.hxx" +#include "BRepPrimAPI_MakeTorus.hxx" +#include "BRepPrimAPI_MakeCylinder.hxx" +#include "BRepBuilderAPI_Transform.hxx" +#include "BRepAdaptor_Curve.hxx" +#include "GC_MakeEllipse.hxx" +#include "BRepBuilderAPI_MakeEdge.hxx" +#include "BRepAdaptor_Surface.hxx" +#include "BRepBuilderAPI_MakeFace.hxx" +#include "BRepOffsetAPI_MakeThickSolid.hxx" +#include "BRepBuilderAPI_Sewing.hxx" +#include "BRepBuilderAPI_Copy.hxx" +#include "LocOpe_SplitShape.hxx" +#include "BRep_Tool.hxx" +#include "BRep_Builder.hxx" +#include "GProp_GProps.hxx" +#include "BRepGProp.hxx" +#include "TopoDS.hxx" +#include "TopologyBridge.hpp" +#include "ProgressTool.hpp" +#include "BRepAlgoAPI_Fuse.hxx" +#include "BRepAlgoAPI_Cut.hxx" +#include "BRepAlgoAPI_Section.hxx" +#include "BRepAlgoAPI_Common.hxx" +#include "BRepPrimAPI_MakeSphere.hxx" +#include "BRepPrimAPI_MakeBox.hxx" +#include "BRepPrimAPI_MakeWedge.hxx" +#include "BRepTools_WireExplorer.hxx" +#include "Handle_Geom_TrimmedCurve.hxx" +#include "Handle_Geom_RectangularTrimmedSurface.hxx" +#include "BndLib_Add3dCurve.hxx" +#include "TopOpeBRep_EdgesIntersector.hxx" +#include "TopExp_Explorer.hxx" +#include "TopExp.hxx" +#include "OCCModifyEngine.hpp" +#include "OCCQueryEngine.hpp" +#include "OCCCoFace.hpp" +#include "CubitMessage.hpp" +#include "CubitDefines.h" +#include "TopTools_DataMapOfShapeInteger.hxx" +#include "BRepFeat_SplitShape.hxx" +#include "TopOpeBRep_ShapeIntersector.hxx" +#include "TopTools_ListIteratorOfListOfShape.hxx" +#include "CubitUtil.hpp" +#include "CubitPoint.hpp" +#include "CubitPointData.hpp" +#include "CubitFacet.hpp" +#include "CubitQuadFacet.hpp" +#include "CubitFacetData.hpp" +#include "CubitFacetEdge.hpp" +#include "CubitFacetEdgeData.hpp" +#include "GeometryQueryTool.hpp" +#include "GeometryModifyTool.hpp" +#include "ChollaSurface.hpp" +#include "ChollaCurve.hpp" +#include "ChollaPoint.hpp" +#include "OCCPoint.hpp" +#include "OCCCurve.hpp" +#include "CurveFacetEvalTool.hpp" +#include "FacetEvalTool.hpp" +#include "OCCCoEdge.hpp" +#include "OCCLoop.hpp" +#include "OCCSurface.hpp" +#include "OCCShell.hpp" +#include "OCCLump.hpp" +#include "OCCBody.hpp" +#include "ChollaEngine.hpp" +#include "TDGeomFacet.hpp" +#include "CubitFileIOWrapper.hpp" +#include "TDFacetBoundaryPoint.hpp" +#include "Cholla.h" +#include "Body.hpp" +#include "GfxDebug.hpp" +#include "RefFace.hpp" +#include "FacetDataUtil.hpp" +#include "FBDataUtil.hpp" +#include "FBIntersect.hpp" +#include "IntegerHash.hpp" +#include "CpuTimer.hpp" +#include "AppUtil.hpp" +#include "SphereEvaluator.hpp" +#include "CylinderEvaluator.hpp" +#include <vector> +OCCModifyEngine* OCCModifyEngine::instance_ = 0; +#define DEBUG +//=============================================================================== +// Function : OCCModifyEngine +// Member Type: PUBLIC +// Description: constructor +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +OCCModifyEngine::OCCModifyEngine() +{ +// assert( !instance_ ); + + // add this modify engine to geometrymodifytool + GeometryModifyTool::instance()->add_gme(this); +} + + +//=============================================================================== +// Function : ~OCCModifyEngine +// Member Type: PUBLIC +// Description: destructor +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +OCCModifyEngine::~OCCModifyEngine() +{ + instance_ = 0; +} + +//=============================================================================== +// Function : make_Point +// Member Type: PUBLIC +// Description: make a geometric entity point +// Author : Jane Hu +// Date : 10/07 +//=============================================================================== +Point* OCCModifyEngine::make_Point( CubitVector const& point) const +{ + gp_Pnt pt = gp_Pnt( point.x(), point.y(), point.z()); + TopoDS_Vertex theVertex = BRepBuilderAPI_MakeVertex(pt); + + // Create a new PointACIS object + return OCCQueryEngine::instance()->populate_topology_bridge( theVertex ); +} + +//=============================================================================== +// Function : make_Curve +// This function creates a curve given an existing curve, copy. +// Member Type: PUBLIC +// Description: make a curve +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve(Curve * curve_ptr) const +{ + OCCCurve* occ_curve = CAST_TO(curve_ptr, OCCCurve); + if (!occ_curve) + { + PRINT_ERROR("Cannot create an OCC curve from the given curve.\n" + "Possible incompatible geometry engines.\n"); + return (Curve *)NULL; + } + + TopoDS_Edge *theEdge = occ_curve->get_TopoDS_Edge(); + + BRepBuilderAPI_Copy api_copy(*theEdge); + + TopoDS_Shape newShape = api_copy.ModifiedShape(*theEdge); + + TopoDS_Edge newEdge = TopoDS::Edge(newShape); + + return OCCQueryEngine::instance()->populate_topology_bridge(newEdge); +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a curve by projecting a straight line defined by +// point1_ptr, and point2_ptr onto face_ptr, third_point +// is used for curves that could be periodic to dertermine +// the correct direction. +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( Point const* point1_ptr, + Point const* point2_ptr, + Surface* face_ptr, + const CubitVector * third_point) const +{ + assert (point1_ptr != NULL && point2_ptr != NULL); + GeometryType type = STRAIGHT_CURVE_TYPE; + CubitBoolean closed = CUBIT_FALSE; + DLIList<CubitVector*> mid_points; + Curve* curve = NULL; + if (point1_ptr != point2_ptr) + curve = make_Curve(type, point1_ptr, point2_ptr, mid_points); + else //could be a closed shape + { + if(third_point != NULL && face_ptr != NULL) + { + closed = CUBIT_TRUE; + Point * Pnt = make_Point(*third_point); + curve = make_Curve(type, point1_ptr, Pnt, mid_points); + } + else + { + PRINT_ERROR("Cannot create an OCC curve from the given duplicated points.\n"); + return (Curve *)NULL; + } + } + + Curve* new_curve = NULL; + if(face_ptr == NULL) + return curve; + + DLIList<Point*> points; + new_curve = + CAST_TO(curve, OCCCurve)->project_curve(face_ptr, points, closed, third_point); + + delete curve; + return new_curve; +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a spline curve by using the points on surface. +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( GeometryType curve_type, + Point const* point1_ptr, + Point const* point2_ptr, + DLIList<CubitVector*>& vector_list, + Surface* face_ptr) const +{ + assert(point1_ptr != NULL && point2_ptr != NULL); + + if (curve_type != SPLINE_CURVE_TYPE + && curve_type != STRAIGHT_CURVE_TYPE) + { + PRINT_ERROR("Cannot create an OCC curve from the given curve_type.\n" + "Candidates are SPLINE_CURVE_TYPE and STRAIGHT_CURVE_TYPE.\n"); + return (Curve *)NULL; + } + + if (curve_type == STRAIGHT_CURVE_TYPE) + return make_Curve(curve_type, point1_ptr, point2_ptr, NULL, CUBIT_FORWARD); + + OCCPoint* occ_point1 = CAST_TO(const_cast<Point*>(point1_ptr), OCCPoint); + OCCPoint* occ_point2 = CAST_TO(const_cast<Point*>(point2_ptr), OCCPoint); + + if (occ_point1 == NULL || occ_point2 == NULL) + { + PRINT_ERROR("Cannot create an OCC curve from the given points.\n" + "Possible incompatible geometry engines.\n"); + return (Curve *)NULL; + } + + //project all points on the surface if possible + OCCSurface* occ_face = NULL; + if (face_ptr != NULL) + occ_face = CAST_TO(face_ptr, OCCSurface); + + gp_Pnt pt; + int size = 2+vector_list.size(); + TColgp_Array1OfPnt points(1, size); + CubitVector* vector = NULL; + CubitVector closest_location; + for(int i = 1; i <= size; i++) + { + if (i == 1) + { + TopoDS_Vertex *point = occ_point1->get_TopoDS_Vertex(); + pt = BRep_Tool::Pnt(*point); + vector = new CubitVector(point1_ptr->coordinates()); + } + else if (i == size) + { + TopoDS_Vertex *point = occ_point2->get_TopoDS_Vertex(); + pt = BRep_Tool::Pnt(*point); + vector = new CubitVector(point2_ptr->coordinates()); + } + else + { + vector = vector_list.get_and_step(); + pt.SetCoord(vector->x(), vector->y(), vector->z()); + } + + if (occ_face != NULL) + { + occ_face->closest_point(*vector, &closest_location); + pt.SetCoord(closest_location.x(), closest_location.y(), closest_location.z()) ; + } + + points.SetValue(i, pt); + } + + //make curve according to the curve type. + if(curve_type == SPLINE_CURVE_TYPE) + { + Geom_BezierCurve BezierCurve(points); + Geom_BezierCurve* curve = new Geom_BezierCurve(BezierCurve); + Handle(Geom_BoundedCurve) curve_ptr(curve); + TopoDS_Vertex * vt1 = occ_point1->get_TopoDS_Vertex(); + TopoDS_Vertex * vt2 = occ_point2->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt2); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); + } + + return (Curve*) NULL; +} + +//=============================================================================== +// Function : make_Curve +// Member Type: PUBLIC +// Description: make a curve +// For STRAIGHT_CURVE_TYPE: +// intermediate_point_ptr is not used +// +// For PARABOLA_CURVE_TYPE +// intermediate_point_ptr is the tip of the parabola +// +// For HYPERBOLA_CURVE_TYPE +// intermediate_point_ptr is the center of its two foci +// +// For ELLIPSE_CURVE_TYPE +// intermediate_point_ptr is the center of the ellipse +// the two points are vertices, one gives the major radius, +// the other point gives the minor radius. +// sense is used to determine which part of the ellipse is required +// +// For ARC_CURVE_TYPE +// arc passes three points +// +// Author : Jane Hu +// Date : 01/08 +//=============================================================================== +Curve* OCCModifyEngine::make_Curve( GeometryType curve_type, + Point const* point1_ptr, + Point const* point2_ptr, + CubitVector const* intermediate_point_ptr, + CubitSense sense) const +{ + assert (point1_ptr != NULL && point2_ptr != NULL); + DLIList<CubitVector*> mid_points; + if (intermediate_point_ptr) + { + CubitVector mid_point = *intermediate_point_ptr; + mid_points.append(&mid_point); + } + + CubitVector v1(point1_ptr->coordinates()); + CubitVector v2(point2_ptr->coordinates()); + + gp_Pnt pt1(v1.x(),v1.y(), v1.z()); + gp_Pnt pt2(v2.x(),v2.y(), v2.z()); + + CubitVector v3; + gp_Pnt pt3; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + + Handle(Geom_TrimmedCurve) curve_ptr; + if(intermediate_point_ptr != NULL) + { + v3 = *intermediate_point_ptr; + pt3.SetCoord(v3.x(),v3.y(), v3.z()); + } + + if (curve_type == STRAIGHT_CURVE_TYPE) + curve_ptr = GC_MakeSegment(pt1,pt2); + + else if (curve_type == ARC_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + curve_ptr = GC_MakeArcOfCircle(pt1, pt3, pt2); + } + + else if (curve_type == ELLIPSE_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + + gp_Pnt center(v3.x(), v3.y(), v3.z()); + + gp_Elips ellipse; + gce_MakeElips ellipse1(pt1 , pt2 , center); + if(ellipse1.IsDone()) + ellipse = ellipse1.Value(); + else if(!ellipse1.IsDone() && ellipse1.Status() == gce_InvertRadius) + { + gce_MakeElips ellipse2(pt2, pt1, center); + if(ellipse2.IsDone()) + ellipse = ellipse2.Value(); + else + { + PRINT_ERROR("Can't create an ellipse from give 3 points.\n"); + return (Curve *)NULL; + } + } + else + { + PRINT_ERROR("Can't create an ellipse from give 3 points.\n"); + return (Curve *)NULL; + } + CubitBoolean use_sense = (sense == CUBIT_FORWARD ? CUBIT_TRUE : CUBIT_FALSE); + curve_ptr = GC_MakeArcOfEllipse(ellipse, pt1, pt2, use_sense); + } + + else if(curve_type == PARABOLA_CURVE_TYPE || + curve_type == HYPERBOLA_CURVE_TYPE) + { + assert(intermediate_point_ptr != NULL); + + //find the directrix and focus of the parabola + //or the axis, major radius and minor radius of the hyperbola + CubitVector width_vec = v2 - v1; + if(width_vec.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "2 end points are the same.\n"); + return (Curve *)NULL; + } + + CubitVector midpoint_vec = (v1 + v2)/2.0; + CubitVector height_vec = midpoint_vec - v3; + gp_Pnt center(v3.x(), v3.y(), v3.z()); + + if (height_vec.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "3 points are in the same line.\n"); + return (Curve *)NULL; + } + CubitVector x = height_vec; + x.normalize(); + gp_Dir x_dir(x.x(), x.y(), x.z()); + + CubitVector N = x * (v2 - v1); + if (N.length_squared() < tol * tol) + { + PRINT_ERROR("Cannot create a parabola or hyperbola curve from the given points.\n" + "3 points are in the same line.\n"); + return (Curve *)NULL; + } + N.normalize(); + gp_Dir N_dir(N.x(), N.y(), N.z()); + + gp_Ax2 axis(center, N_dir, x_dir); + + if(curve_type == HYPERBOLA_CURVE_TYPE) + { + // (focus2) (v3) . (v2) + // . . . (midpoint = focus1) + // . (v1) + CubitVector focus2 = 2 * v3 - midpoint_vec; + + //according to the definition of hyperbola, + //2 * a = length(v2 - focus2)-length(v2 - focus1) + + double major = (v2 - focus2).length()/2.0 - (v2 - midpoint_vec).length()/2.0; + + // if a = 1/2 length major axis, b = 1/2 length minor axis and + // c = distance center to focus, then a*a + b*b = c*c + + double c_squared = (midpoint_vec - v3).length_squared(); + double minor = sqrt(c_squared - major*major ); + gp_Hypr hypt(axis, major, minor); + curve_ptr = + GC_MakeArcOfHyperbola(hypt, pt1, pt2, CUBIT_TRUE); + } + + else + { + // Find the focus of this parabola. + // Since for a parabola with its peak at the origin, y = (1/(4*a))*x^2, + // and since we have restricted this parabola to be symmetric (per the + // FastQ method, see the FastQ file getwt.f), we can use the following + // relationship to + // determine "a", the distance the focus lies from the peak on the line + // formed by the peak and the midpoint of the start and end points` + double a = width_vec.length_squared()/(16. * height_vec.length()); + gp_Parab parab(axis, a); + curve_ptr = + GC_MakeArcOfParabola(parab, pt1, pt2, CUBIT_TRUE); + } + } + + else + { + PRINT_ERROR("In OCCModifyEngine::make_Curve\n" + " Invalid curve type.\n"); + return (Curve *)NULL; + } + + OCCPoint* occ_pt1 = CAST_TO(const_cast<Point*>(point1_ptr),OCCPoint); + OCCPoint* occ_pt2 = CAST_TO(const_cast<Point*>(point2_ptr),OCCPoint); + TopoDS_Vertex * vt1 = occ_pt1->get_TopoDS_Vertex(); + TopoDS_Vertex * vt2 = occ_pt2->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt2); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); +} + +//=============================================================================== +// Function : make_Surface +// This function creates a surface given an existing surface, copy. +// Member Type: PUBLIC +// Description: make a surface, OCC allows to create a stand along surface, +// however the CGM has a design of making all surfaces in a (sheet) +// body. This will add complexity on all free surface related +// calculation and modification, and adding potential bugs too. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Surface* OCCModifyEngine::make_Surface( Surface * surface_ptr, + CubitBoolean extended_from) const +{ + OCCSurface* occ_surface = CAST_TO(surface_ptr, OCCSurface); + if (!occ_surface) + { + PRINT_ERROR("Cannot create an OCC surface from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (Surface *)NULL; + } + + //Start of the codes + double UMax, VMax, UMin, VMin; + occ_surface->get_param_range_U(UMin, UMax); + occ_surface->get_param_range_V(VMin, VMax); + + TopoDS_Face *theFace = occ_surface->get_TopoDS_Face(); + if( !theFace) + { + PRINT_ERROR("Cannot create an OCC surface from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (Surface *)NULL; + } + + TopoDS_Face newFace; + BRepAdaptor_Surface asurface(*theFace); + + CubitBox bounding_box = GeometryQueryTool::instance()->model_bounding_box(); + double const height = 2*(bounding_box.diagonal()).length(); + CubitBox box = occ_surface->bounding_box(); + double ratio = height/(box.diagonal().length()); + + double middleU = (UMin + UMax)/2.0; + double middleV = (VMin + VMax)/2.0; + double U1 = middleU - (UMax-UMin)/2.0 * ratio; + double U2 = middleU + (UMax-UMin)/2.0 * ratio; + double V1 = middleV - (VMax - VMin)/2.0 * ratio; + double V2 = middleV + (VMax - VMin)/2.0 * ratio; + + if (extended_from == CUBIT_TRUE) + { + // We need to get the type of surface. + GeometryType type = occ_surface->geometry_type(); + if (type == PLANE_SURFACE_TYPE) + { + gp_Pln plane = asurface.Plane(); + newFace = BRepBuilderAPI_MakeFace(plane, U1, U2, V1, V2); + } + else if(type == CONE_SURFACE_TYPE) + { + //make an infinite cone. + //Given this lets create another face that is extended from it. + if(asurface.GetType() == GeomAbs_Cone) + { + gp_Cone cone = asurface.Cone(); + gp_Pnt Apex = cone.Apex(); + double semi_angle = cone.SemiAngle(); + gp_Pnt p2; + double radius2; + gp_XYZ xyz; + if (semi_angle > 0) + xyz = Apex.XYZ() + cone.Position().Direction().XYZ()*height; + + else + xyz = Apex.XYZ() - cone.Position().Direction().XYZ()*height; + + p2.SetXYZ(xyz); + radius2 = height * tan(fabs(semi_angle)); + Handle(Geom_RectangularTrimmedSurface) trimmed_cone; + trimmed_cone = GC_MakeTrimmedCone(Apex, p2, 0, radius2); + newFace = BRepBuilderAPI_MakeFace(trimmed_cone); + } + else + { + gp_Cylinder cylinder = asurface.Cylinder(); + //gp_Pnt pnt = asurface.Value(UMin,V1); + double radius = cylinder.Radius(); + gp_Ax1 axis = cylinder.Axis(); + Handle(Geom_RectangularTrimmedSurface) trimmed_cyl; + trimmed_cyl = GC_MakeTrimmedCylinder(axis, radius, height); + newFace = BRepBuilderAPI_MakeFace(trimmed_cyl); + } + } + else if(type == SPHERE_SURFACE_TYPE) + { + //make a whole sphere. + gp_Sphere sphere = asurface.Sphere(); + newFace = BRepBuilderAPI_MakeFace(sphere); + } + else if(type == TORUS_SURFACE_TYPE) + { + //make a whole torus + gp_Torus torus = asurface.Torus(); + newFace = BRepBuilderAPI_MakeFace(torus); + } + else if(type == SPLINE_SURFACE_TYPE ) + { + //extend the surfaces using the equation if possible. + Handle(Geom_BezierSurface) bezier = asurface.Bezier(); + newFace = BRepBuilderAPI_MakeFace(bezier, U1, U2, V1, V2); + } + } + + else + { + BRepBuilderAPI_Copy api_copy(*theFace); + TopoDS_Shape newShape = api_copy.ModifiedShape(*theFace); + newFace = TopoDS::Face(newShape); + } + + Surface *surface = OCCQueryEngine::instance()->populate_topology_bridge( + newFace, CUBIT_TRUE); + + return surface; +} + +//=============================================================================== +// Function : make_Surface +// Member Type: PUBLIC +// Description: make a surface of type surface_type, given the list of curves. +// check edges option is done in GeometryModifyTool level, so +// disregard this option. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Surface* OCCModifyEngine::make_Surface( GeometryType surface_type, + DLIList<Curve*>& curve_list, + Surface * old_surface_ptr, + bool check_edges) const +{ + //Create TopoDS_Edge list to make a surface. + DLIList<DLIList<TopoDS_Edge*>*> topo_edges_loops; + curve_list.reset() ; + + //check no intersections of the TopoDS_Edge's. + //need to check that no intersection in the middle of the curves, not at + //vertices or out of boundary. + + int count = 0; //intersection point should be the same as curve_list size. + for ( int i = 0 ; i < curve_list.size()-1 ; i++ ) + { + for(int j = i+1; j < curve_list.size(); j ++) + { + DLIList<CubitVector*> intscts; + CubitBoolean bounded = CUBIT_TRUE;//dummy arg. + CubitBoolean closest = CUBIT_TRUE;//dummy arg. + CubitStatus yes_int = + OCCQueryEngine::instance()->get_intersections(curve_list[i], + curve_list[j], intscts, bounded, closest); + if(yes_int) + { + //check intscts point should be vertex or outside boundary. + if (intscts.size() > 2 ) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + else + { + for(int k = 0; k < intscts.size(); k++) + { + CubitVector *v = intscts.get_and_step(); + CubitPointContainment is_on = CAST_TO(curve_list[i],OCCCurve)-> + point_containment(*v); + if (is_on == CUBIT_PNT_BOUNDARY) + { + is_on = CAST_TO(curve_list[j],OCCCurve)-> + point_containment(*v); + if (is_on == CUBIT_PNT_BOUNDARY) + count++; + } + else if(is_on == CUBIT_PNT_INSIDE) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + } + } + } + } + } + + if (count > curve_list.size()) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface with intersecting curves.\n"); + return (Surface *)NULL; + } + + CubitStatus stat = sort_curves(curve_list, topo_edges_loops); + if( stat == CUBIT_FAILURE ) //case of one disconnected curve + return (Surface*) NULL; + + // Use the topo_edges to make a topo_face + TopoDS_Face* topo_face; + topo_face = make_TopoDS_Face(surface_type,topo_edges_loops, old_surface_ptr); + + for (int i = 0; i < topo_edges_loops.size(); i++) + { + DLIList<TopoDS_Edge*>* topo_edges = topo_edges_loops.get_and_step(); + for(int j = 0; j < topo_edges->size(); j++) + topo_edges->pop(); + delete topo_edges; + } + + if(!topo_face) + { + PRINT_ERROR("In OCCModifyEngine::make_Surface\n" + " Cannot make Surface object.\n"); + return (Surface *)NULL; + } + + // make the topology bridges for the face + Surface *surface = OCCQueryEngine::instance()->populate_topology_bridge( + *topo_face, CUBIT_TRUE); + topo_face->Nullify(); + delete topo_face; + return surface ; +} + +//=============================================================================== +// Function : sort_curves +// Member Type: PROTECTED +// Description: sort the curves so they are in order and make closed loop +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::sort_curves(DLIList<Curve*> curve_list, + DLIList<DLIList<TopoDS_Edge*>*>& topo_edges_loops)const +{ + topo_edges_loops.clean_out(); + CubitStatus stat = CUBIT_SUCCESS; + std::vector< DLIList<TopoDS_Edge*>* > topo_edges(curve_list.size()); + int size_in = curve_list.size(); + for(int i = 0; i < size_in; i++) + topo_edges[i] = new DLIList<TopoDS_Edge*>; + + curve_list.reset() ; + Curve const* curve_ptr = NULL ; + OCCCurve* occ_curve = NULL; + TopoDS_Edge* topo_edge = NULL; + + OCCPoint* start = NULL; + OCCPoint* end = NULL; + DLIList<OCCPoint*> point_list; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + CubitBoolean new_end; + int size = curve_list.size(); + + int count = 0; + for ( int i = 0 ; i < size ; i++ ) + { + if (i == 0) + new_end = CUBIT_TRUE; + for(int j = 0; j < curve_list.size(); j ++) + { + curve_ptr = curve_list.get() ; + occ_curve = CAST_TO(const_cast<Curve*>(curve_ptr), OCCCurve); + + if(occ_curve == NULL) + { + PRINT_ERROR("In OCCModifyEngine::sort_curves\n" + " Got a NULL pointer to OCCCurve\n") ; + return CUBIT_FAILURE; + } + + point_list.clean_out(); + occ_curve->get_points(point_list); + //assert(point_list.size()==2); + + if (i == 0) + { + start = point_list.get(); + end = point_list.pop(); + break; + } + + if(end->is_equal(*(point_list.get()), tol) || + end->is_equal(*(point_list.step_and_get()),tol)) + { + end = point_list.step_and_get(); + new_end = CUBIT_TRUE; + break; + } + + else if(start->is_equal(*(point_list.get()), tol) || + start->is_equal(*(point_list.step_and_get()),tol)) + { + start = end; + end = point_list.step_and_get(); + new_end = CUBIT_TRUE; + break; + } + curve_list.step(); + } + + if (new_end)//found next curve + { + topo_edge = occ_curve->get_TopoDS_Edge(); + topo_edges[count]->append(topo_edge); + curve_list.remove(); + if(start->is_equal( *end, tol)) //formed a closed loop + { + i = -1; + size = curve_list.size() ; + topo_edges_loops.append(topo_edges[count]); + count++; + } + else + new_end = CUBIT_FALSE; + } + else + { + stat = CUBIT_FAILURE; + i = -1; + size = curve_list.size(); + topo_edges_loops.append(topo_edges[count]); + count++; + } + } + + if( new_end == CUBIT_FALSE ) //case of one disconnected curve + { + topo_edges_loops.append(topo_edges[count]); + stat = CUBIT_FAILURE; + } + + for(int i = 0; i < size_in; i++) + { + if(topo_edges[i]->size() == 0) + delete topo_edges[i]; + } + return stat; +} +//=============================================================================== +// Function : make_TopoDS_Face +// Member Type: PROTECTED +// Description: make a opoDS_Face of type surface_type, given the list of +// TopoDS_Edge. the TopoDS_Edge's should be in order in loops. +// check edges option is done in GeometryModifyTool level, so +// disregard this option. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +TopoDS_Face* OCCModifyEngine::make_TopoDS_Face(GeometryType surface_type, + DLIList<DLIList<TopoDS_Edge*>*> topo_edges_list, + Surface * old_surface_ptr)const +{ + TopoDS_Face* topo_face = NULL; + // Make sure a supported type of surface is being requested. + if ( surface_type != PLANE_SURFACE_TYPE && + surface_type != BEST_FIT_SURFACE_TYPE) + { + PRINT_WARNING("In OCCGeometryEngine::make_TopoDS_Face\n" + " At this time, cannot make a TopoDS_Face that isn't" + " planar or best fit.\n"); + return topo_face; + } + + // Set the TopoDS_Face pointer, if requested. + TopoDS_Face *fit_Face = NULL; + Handle_Geom_Surface S; + if ( old_surface_ptr != NULL ) + { + OCCSurface *surf = CAST_TO(old_surface_ptr, OCCSurface ); + fit_Face = surf->get_TopoDS_Face(); + S = BRep_Tool::Surface(*fit_Face); + } + + // Make a wire from the topo_edges. + // Coincident TopoDS_Vertex will be deleted by OCC. + if(topo_edges_list.size() == 0) + return topo_face; + + DLIList<TopoDS_Wire*> wires; + GProp_GProps myProps; + double max_area = 0.0; + TopoDS_Wire* out_Wire = NULL; + TopoDS_Wire test_Wire; + DLIList<TopoDS_Edge*>* topo_edges; + //check and make sure the outer loop is in the first + for(int i = 0; i < topo_edges_list.size() ; i++) + { + topo_edges = topo_edges_list.get_and_step(); + BRepBuilderAPI_MakeWire aWire(*(topo_edges->get())); + for(int j = 1; j < topo_edges->size(); j++) + aWire.Add(*(topo_edges->step_and_get())); + + test_Wire = aWire.Wire(); + wires.append(&test_Wire); + + if (topo_edges_list.size() == 1) + break; + + BRepBuilderAPI_MakeFace made_face(test_Wire); + + if (!made_face.IsDone()) + { + PRINT_ERROR("In OCCModifyEngine::make_TopoDS_Face\n" + " Cannot find the best fit surface for given curves.\n"); + return topo_face; + } + TopoDS_Face test_face = made_face.Face(); + BRepGProp::SurfaceProperties(test_face, myProps); + double area = myProps.Mass(); + out_Wire = max_area > area ? out_Wire : &test_Wire; + max_area = max_area > area ? max_area : area; + } + + if (out_Wire) + { + wires.remove(out_Wire); + wires.insert_first(out_Wire); + } + + //create the TopoDS_Face + CubitBoolean error = CUBIT_FALSE; + + for(int i = 0; i < topo_edges_list.size() ; i++) + { + TopoDS_Wire *the_wire = wires.get_and_step(); + if (i == 0) + { + if( old_surface_ptr != NULL ) + { + BRepBuilderAPI_MakeFace made_face(S, *the_wire); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + topo_face = new TopoDS_Face(made_face.Face()); + } + else + { + CubitBoolean is_planar = (surface_type == PLANE_SURFACE_TYPE ? + CUBIT_TRUE : CUBIT_FALSE); + BRepBuilderAPI_MakeFace made_face(*the_wire, is_planar); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + + topo_face = new TopoDS_Face(made_face.Face()); + } + } + else + { + BRepBuilderAPI_MakeFace made_face(*topo_face, *the_wire); + if (!made_face.IsDone()) + { + error = CUBIT_TRUE; + break; + } + delete topo_face; + topo_face = new TopoDS_Face(made_face.Face()); + } + } + + if(error) + { + PRINT_ERROR("In OCCModifyEngine::make_TopoDS_Face\n" + " Cannot find the best fit surface for given curves.\n"); + return (TopoDS_Face*) NULL; + } + + return topo_face; +} +//=============================================================================== +// Function : make_Lump +// Member Type: PUBLIC +// Description: make a lump of one shell +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +Lump* OCCModifyEngine::make_Lump( DLIList<Surface*>& surface_list ) const +{ + if (surface_list.size() < 2) + return (Lump*) NULL; + + //all surfaces should be stand along surface bodies or shell bodies' surface + DLIList<BodySM*> body_list; + for(int i = 0; i < surface_list.size(); i++) + { + OCCSurface* occ_surface = CAST_TO(surface_list.get_and_step(), OCCSurface); + if (occ_surface == NULL) + { + PRINT_ERROR("Cannot create an OCC lump from the given surfaces.\n" + "Possible incompatible geometry engines.\n"); + return (Lump *)NULL; + } + OCCBody* occ_body = occ_surface->my_body(); + if(occ_body && occ_body->my_sheet_surface() == NULL) + { + PRINT_ERROR("Cannot create an OCC lump from the given surfaces.\n" + "The surfaces are not free.\n"); + return (Lump *)NULL; + } + else if(!occ_body) + { + OCCShell* shell = occ_surface->my_shell(); + if(!shell) + { + PRINT_ERROR("This is a bug, please report it. \n"); + return (Lump*)NULL; + } + occ_body = shell->my_body(); + } + body_list.append_unique(occ_body); + } + + TopoDS_Shape aShape; + CubitStatus stat = stitch_surfs(body_list, aShape); + if(!stat) + { + PRINT_ERROR("The surfaces are not all connected, can't make a lump. \n"); + return (Lump*)NULL; + } + + TopExp_Explorer Ex, Ex2; + TopoDS_Shell aShell ; + for (Ex.Init(aShape, TopAbs_SHELL, TopAbs_SOLID); Ex.More()&& stat; Ex.Next()) + aShell = TopoDS::Shell(Ex.Current()); + + //check to make sure the aShell is closed. + int num_edges = 0; + int pairs = 0; + //sometimes there's duplicate TopoDS_Edges in the shell. + DLIList<TopoDS_Edge*> edge_list; + for (Ex.Init(aShell, TopAbs_EDGE); Ex.More()&& stat; Ex.Next()) + { + TopoDS_Edge edge1 = TopoDS::Edge(Ex.Current()); + TopoDS_Edge* new_edge = new TopoDS_Edge(edge1); + edge_list.append(new_edge); + } + + int size = edge_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Edge edge1 = *edge_list[i]; + int same = 0; + for (int j = i+1; j < edge_list.size(); j++) + { + TopoDS_Edge edge2 = *edge_list[j]; + if(edge1.IsEqual(edge2)) + { + same ++; + edge_list.remove(&edge1); + i--; + size--; + break; + } + } + if(same > 0) + continue; + + else + num_edges++; + + for (int j = 0; j < size; j++) + { + TopoDS_Edge edge2 = *edge_list[j]; + if (!edge1.IsEqual(edge2)&& edge1.IsSame(edge2)) + { + pairs++; + break; + } + } + } + + for (int k = 0; k < edge_list.size(); k++) + { + TopoDS_Edge* edge = edge_list.get_and_step(); + edge->Nullify(); + delete edge; + } + + if (num_edges == pairs ) + aShell.Closed(CUBIT_TRUE); + + else + PRINT_ERROR("Surfaces must make a water-tight shape to make a lump.\n"); + + if(aShell.Closed()) + { + BRepBuilderAPI_MakeSolid aMakeSolid(aShell); + if (!aMakeSolid.IsDone()) + { + PRINT_ERROR("Cannot create an OCC Lump from the given surfaces.\n" + "OCC internal error.\n"); + return (Lump *)NULL; + } + + TopoDS_Solid aSolid = aMakeSolid.Solid(); + + return + OCCQueryEngine::instance()->populate_topology_bridge(aSolid, CUBIT_TRUE); + } + + return (Lump*) NULL; +} + +//=============================================================================== +// Function : make_BodySM +// Member Type: PUBLIC +// Description: make a BodySM from a surface +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +BodySM* OCCModifyEngine::make_BodySM( Surface *surface ) const +{ + OCCSurface* occ_surface = CAST_TO(surface, OCCSurface); + if(!occ_surface) + { + PRINT_ERROR("Cannot create an OCC body from the given surface.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + + OCCBody* occ_body = occ_surface->my_body(); + if(occ_body) + return occ_body; + + TopoDS_Face* face = occ_surface->get_TopoDS_Face(); + surface = OCCQueryEngine::instance()->populate_topology_bridge(*face, CUBIT_TRUE); + + return CAST_TO(surface, OCCSurface)->my_body(); +} + + + +//=============================================================================== +// Function : make_BodySM +// Member Type: PUBLIC +// Description: make a BodySM given a list of Lumps. +// Author : Jane Hu +// Date : 02/08 +//=============================================================================== +BodySM* OCCModifyEngine::make_BodySM( DLIList<Lump*>& lump_list ) const +{ + if (lump_list.size() == 0) + return (BodySM*) NULL; + + //Create a compsolid shape, copy all BodySM's solids to create new compbody + DLIList<BodySM*> bodysm_list; + TopoDS_CompSolid CS; + BRep_Builder B; + B.MakeCompSolid(CS); + + //Add every shape to the CompSolid + for(int i = 0; i < lump_list.size(); i++) + { + Lump* lump = lump_list.get_and_step(); + OCCLump* occ_lump = CAST_TO(lump, OCCLump); + if(!occ_lump) + { + PRINT_ERROR("Cannot create an OCC BodySM from the given lumps.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + TopoDS_Solid* solid = occ_lump->get_TopoDS_Solid(); + BRepBuilderAPI_Copy api_copy(*solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(*solid); + B.Add(CS, newShape); + } + + BodySM* bodysm = OCCQueryEngine::instance()->populate_topology_bridge(CS); + + return bodysm; + +} + + +//=============================================================================== +// Function : sphere +// Member Type: PUBLIC +// Description: build an OCC sphere +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::sphere(double radius) const +{ + if (radius <= 0) + return (BodySM*) NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeSphere(radius); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + return CAST_TO(lump, OCCLump)->get_body(); +} + + +//=============================================================================== +// Function : brick +// Member Type: PUBLIC +// Description: build an OCC brick +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::brick( double wid, double dep, double hi ) const +{ + if (wid <= 0 || dep <=0 || hi <= 0) + return (BodySM*)NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeBox(wid, dep, hi); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + return (BodySM*)NULL; + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body,OCCBody)->move(-wid/2.0, -dep/2.0, -hi/2.0); + return body; +} + + +//=============================================================================== +// Function : brick +// Member Type: PUBLIC +// Description: create an OCC brick given center axes and extension +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::brick( const CubitVector& center, + const CubitVector axes[3], + const CubitVector &extension) const +{ + CubitVector left_corner = center - 0.5 * extension; + gp_Pnt left_point(left_corner.x(), left_corner.y(), left_corner.z()); + gp_Dir main_dir(axes[2].x(), axes[2].y(), axes[2].z()); + gp_Dir x_dir(axes[0].x(), axes[0].y(), axes[0].z()); + gp_Ax2 Axis(left_point, main_dir, x_dir); + TopoDS_Solid S = BRepPrimAPI_MakeBox( Axis, extension.x(), extension.y(), + extension.z()); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : prism +// Member Type: PUBLIC +// Description: create an OCC prism +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::prism( double height, int sides, double major, + double minor) const +{ + //currently OCC only support 4 sided prism + if (sides != 4) + { + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return (BodySM*) NULL; + } + + return brick(2 * major, 2 * minor, height); +} + +//=============================================================================== +// Function : pyramid +// Member Type: PUBLIC +// Description: create an OCC pyramid +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::pyramid( double height, int sides, double major, + double minor, double top) const +{ + //currently OCC only support 4 sided pyramid + if (sides != 4) + { + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return (BodySM*) NULL; + } + + TopoDS_Solid S = BRepPrimAPI_MakeWedge( 2 * major, 2* minor, height, + 2 * top); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + if (lump == NULL) + return (BodySM*)NULL; + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body, OCCBody)->move(-major, -minor, -height/2.0); + return body; + +} + +//=============================================================================== +// Function : cylinder +// Member Type: PUBLIC +// Description: create an OCC cylinder, its base shape can be ellipse with +// r1, r2 while r3 = 0; or it can be a cone with r1, +// r3 while r2 = 0. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::cylinder( double hi, double r1, double r2, double r3 ) const +{ + TopoDS_Solid S; + if(r2 != r1)//elliptical based cylinder + { + gp_Pnt center(0.0, 0.0, 0.0); + gp_Dir main_dir(0.0, 0.0, 1.0); + gp_Dir x_dir(1.0, 0.0, 0.0); + gp_Ax2 Axis(center, main_dir, x_dir); + Handle(Geom_Curve) curve_ptr = GC_MakeEllipse(Axis, r1, r2); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr); + BRepBuilderAPI_MakeWire aWire(new_edge); + + TopoDS_Wire test_Wire = aWire.Wire(); + + BRepOffsetAPI_ThruSections builder(CUBIT_TRUE, CUBIT_TRUE); + builder.AddWire(test_Wire); + if (r3 == 0) + { + gp_Pnt pt = gp_Pnt( 0.0, 0.0, hi); + TopoDS_Vertex theVertex = BRepBuilderAPI_MakeVertex(pt); + builder.AddVertex(theVertex); + } + else + { + gp_Pnt center2(0.0, 0.0,hi); + gp_Ax2 Axis2(center2, main_dir, x_dir); + Handle(Geom_Curve) curve_ptr = GC_MakeEllipse(Axis2, r3, r3*r2/r1); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr); + BRepBuilderAPI_MakeWire aWire(new_edge); + TopoDS_Wire test_Wire = aWire.Wire(); + builder.AddWire(test_Wire); + } + builder.Build() ; + S = TopoDS::Solid(builder.Shape()); + } + + else // cone + { + if(r1 == r3) //cylinder + S = BRepPrimAPI_MakeCylinder(r1, hi); + else + S = BRepPrimAPI_MakeCone(r1, r3, hi); + } + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + { + PRINT_ERROR("In OCCModifyEngine::cylinder\n" + " Cannot create a cylinder for given radii.\n"); + return (BodySM*)NULL; + } + + BodySM* body = CAST_TO(lump, OCCLump)->get_body(); + if(body) + CAST_TO(body, OCCBody)->move(0, 0, -hi/2.0); + return body; +} + +//=============================================================================== +// Function : torus +// Member Type: PUBLIC +// Description: create an OCC torus +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::torus( double r1, double r2 ) const +{ + if (r1 <= 0 || r2 <= 0) + return (BodySM*) NULL; + + TopoDS_Solid S = BRepPrimAPI_MakeTorus(r1, r2); + + Lump* lump = OCCQueryEngine::instance()->populate_topology_bridge(S, + CUBIT_TRUE); + + if (lump == NULL) + { + PRINT_ERROR("In OCCModifyEngine::torus\n" + " Cannot create a torus for given radii.\n"); + return (BodySM*)NULL; + } + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : planar_sheet +// Member Type: PUBLIC +// Description: create an OCC planar_sheet with four vectors. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::planar_sheet ( const CubitVector& p1, + const CubitVector& p2, + const CubitVector& p3, + const CubitVector& p4) const +{ + Point* point1 = make_Point(p1); + Point* point2 = make_Point(p2); + Point* point3 = make_Point(p3); + Point* point4 = make_Point(p4); + Curve * curve1 = make_Curve( point1, point2); + if (curve1 == NULL) + return (BodySM*) NULL; + Curve * curve2 = make_Curve( point2, point3); + if (curve2 == NULL) + return (BodySM*) NULL; + Curve * curve3 = make_Curve( point3, point4); + if (curve3 == NULL) + return (BodySM*) NULL; + Curve * curve4 = make_Curve( point4, point1); + if (curve4 == NULL) + return (BodySM*) NULL; + DLIList<Curve*> curves; + curves.append(curve1); + curves.append(curve2); + curves.append(curve3); + curves.append(curve4); + Surface* surface = make_Surface(PLANE_SURFACE_TYPE, curves); + if (surface == NULL) + return (BodySM*) NULL; + return CAST_TO(surface,OCCSurface)->my_body(); +} + +//=============================================================================== +// Function : copy_body +// Member Type: PUBLIC +// Description: copy an OCC-based body +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +BodySM* OCCModifyEngine::copy_body ( BodySM* bodyPtr ) const +{ + OCCBody* occ_body = CAST_TO(bodyPtr, OCCBody); + if (!occ_body) + { + PRINT_ERROR("Cannot create an OCC bodySM from the given bodySM.\n" + "Possible incompatible geometry engines.\n"); + return (BodySM *)NULL; + } + + TopoDS_CompSolid *theCS = occ_body->get_TopoDS_Shape(); + + if (theCS == NULL) //sheet body + { + OCCShell* occ_shell = occ_body->shell(); + if (occ_shell != NULL) + { + TopoDS_Shell* shell = occ_shell->get_TopoDS_Shell(); + BRepBuilderAPI_Copy api_copy(*shell); + TopoDS_Shape newShape = api_copy.ModifiedShape(*shell); + TopoDS_Shell newShell = TopoDS::Shell(newShape); + return OCCQueryEngine::instance()->populate_topology_bridge(newShell, CUBIT_TRUE)->my_body(); + } + + Surface* surface = make_Surface(occ_body->my_sheet_surface()); + if (surface == NULL) + { + PRINT_ERROR("Cannot create an OCC sheet bodySM from the given bodySM.\n"); + return (BodySM *)NULL; + } + + return CAST_TO(surface,OCCSurface)->my_body(); + } + + if(OCCQueryEngine::instance()->OCCMap->IsBound(*theCS)) + { + BRepBuilderAPI_Copy api_copy(*theCS); + + TopoDS_Shape newShape = api_copy.ModifiedShape(*theCS); + + TopoDS_CompSolid newCS = TopoDS::CompSolid(newShape); + + return OCCQueryEngine::instance()->populate_topology_bridge(newCS); + } + + //single lump body + Lump *lump = occ_body->lumps().get(); + TopoDS_Solid solid = *(CAST_TO(lump, OCCLump)->get_TopoDS_Solid()); + BRepBuilderAPI_Copy api_copy(solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(solid); + TopoDS_Solid newSolid = TopoDS::Solid(newShape); + lump = OCCQueryEngine::instance()->populate_topology_bridge(newSolid, + CUBIT_TRUE); + + return CAST_TO(lump, OCCLump)->get_body(); +} + +//=============================================================================== +// Function : stitch_surfs +// Member Type: PUBLIC +// Description: stitch all surfs and try to make a shell body. +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::stitch_surfs( + DLIList<BodySM*>& surf_bodies, + BodySM*& new_body) const +{ + new_body = NULL; + if (surf_bodies.size()==0) + return CUBIT_SUCCESS; + + if (surf_bodies.size()==1) + { + new_body = surf_bodies.get(); + return CUBIT_SUCCESS; + } + + TopoDS_Shape fuse; + CubitStatus stat = stitch_surfs(surf_bodies, fuse); + + DLIList<TopologyBridge*> tbs = OCCQueryEngine::instance()-> + populate_topology_bridge(fuse); + + if (stat) + { + OCCBody* body = CAST_TO(tbs.get(), OCCBody); + + if (body) + new_body = body ; + } + + else + { + surf_bodies.clean_out(); + for(int i= 0; i<tbs.size(); i++) + surf_bodies.append(CAST_TO(tbs.get_and_step(), OCCBody)); + } + + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : stitch_surfs +// Member Type: PUBLIC +// Description: stitch all surfs and try to make a TopoDS_Shell . +// called by stitch into surface body +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::stitch_surfs( + DLIList<BodySM*>& surf_bodies, + TopoDS_Shape& fuse) const +{ + if (surf_bodies.size() < 2) + return CUBIT_SUCCESS; + + DLIList<TopoDS_Shape*> faces_to_stitch; + for (int i = 0; i < surf_bodies.size(); i++) + { + BodySM * tool_body = surf_bodies.get_and_step(); + OCCBody* occ_body = CAST_TO(tool_body, OCCBody); + OCCSurface* surface = occ_body->my_sheet_surface(); + OCCShell* shell = occ_body->shell(); + if (surface == NULL && shell == NULL) + { + PRINT_ERROR("Can't stitch non-sheet bodySM's. \n"); + return CUBIT_FAILURE; + } + + delete occ_body; + if (surface) + { + delete surface->my_shell(); + delete surface->my_lump(); + surface->set_shell(NULL); + surface->set_lump(NULL); + surface->set_body(NULL); + + TopoDS_Face* topods_face = surface->get_TopoDS_Face(); + if (topods_face != NULL) + faces_to_stitch.append(topods_face); + } + else + { + delete shell->my_lump(); + shell->set_body(NULL); + shell->set_lump(NULL); + + TopoDS_Shell* topods_shell = shell->get_TopoDS_Shell(); + if(topods_shell) + faces_to_stitch.append(topods_shell); + } + } + + faces_to_stitch.reset(); + surf_bodies.reset(); + TopoDS_Shape* first_face = faces_to_stitch.pop(); + + TopoDS_Shape* second_face = NULL; + for( int i = faces_to_stitch.size()-1; i >= 0; i --) + { + second_face = faces_to_stitch[i]; + BRepAlgoAPI_Fuse fuser(*second_face, *first_face); + + TopoDS_Shape new_shape ; + for(int j = 0; j < 2; j++) + { + TopTools_IndexedMapOfShape M; + if(j == 0) + TopExp::MapShapes(*second_face, TopAbs_FACE, M); + else + TopExp::MapShapes(*first_face, TopAbs_FACE, M); + for(int ii=1; ii<=M.Extent(); ii++) + { + TopoDS_Face face = TopoDS::Face(M(ii)); + TopTools_ListOfShape shapes; + shapes.Assign(fuser.Modified(face)); + if (shapes.Extent() == 1) + { + new_shape = shapes.First(); + OCCSurface::update_OCC_entity(face, TopoDS::Face(new_shape), &fuser); + } + else if(fuser.IsDeleted(face) || shapes.Extent() > 1) + { + TopoDS_Face null_face; + OCCSurface::update_OCC_entity(face, null_face, &fuser); + } + } + } + + fuse = fuser.Shape(); + first_face = &fuse; + } + + TopExp_Explorer Ex; + int count_shell = 0; + for (Ex.Init(fuse, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next()) + count_shell++; + + if ( count_shell != 1) + { + PRINT_ERROR("Can't stitch all surfaces into one BodySM's. \n"); + return CUBIT_FAILURE; + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : subtract +// Member Type: PUBLIC +// Description: subtract boolean operation on OCC-based bodies +// Author : Jane Hu +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::subtract(DLIList<BodySM*> &tool_body_list, + DLIList<BodySM*> &from_bodies, + DLIList<BodySM*> &new_bodies, + bool imprint, + bool keep_old) const +{ + // copy the bodies in case keep_old is true + DLIList<TopoDS_Shape*> tool_bodies_copy; + + //for subtract function, tool-body has to be solid, + //otherwise it's just imprint + DLIList<CubitBox*>* tool_boxes = new DLIList<CubitBox*>(); + DLIList<CubitBoolean> is_tool_volume; + //keep the tool_body untouched + CubitStatus stat = + get_shape_list(tool_body_list, tool_bodies_copy, is_tool_volume, CUBIT_TRUE, tool_boxes); + + if(!stat) + return stat; + + //check that tool_bodies are all solid, shell and surface body can't be used + //for subtracting purpose. + if(is_tool_volume.is_in_list(CUBIT_FALSE)) + { + PRINT_WARNING("Surfaces or Shells can't be used to cut a body.\n"); + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + return CUBIT_FAILURE; + } + + stat = do_subtract(from_bodies, tool_bodies_copy, is_tool_volume, + tool_boxes, new_bodies, keep_old, imprint) ; + + //ok, we're done wih all cuts, delete unnecessaries. + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + if(!keep_old) //delete tool_bodies + OCCQueryEngine::instance()->delete_solid_model_entities(tool_body_list); + return stat; +} + +CubitStatus OCCModifyEngine::do_subtract(DLIList<BodySM*> &from_bodies, + DLIList<TopoDS_Shape*> &tool_bodies_copy, + DLIList<CubitBoolean> &is_tool_volume, + DLIList<CubitBox*>* tool_boxes, + DLIList<BodySM*> &new_bodies, + bool keep_old, + bool imprint) const +{ + DLIList<TopoDS_Shape*> from_bodies_copy; + DLIList<CubitBoolean> is_volume; + //get the from_bodies underling shapes + CubitStatus stat = get_shape_list(from_bodies, from_bodies_copy, is_volume, keep_old); + if(!stat) + { + for (int i = 0; i < tool_bodies_copy.size(); i++) + { + TopoDS_Shape* shape = tool_bodies_copy.get_and_step(); + delete shape; + } + tool_bodies_copy.clean_out(); + return CUBIT_FAILURE; + } + + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + int fraction_remaining = 100; + + // subtract the tool body from each body in the list + + CubitMessage* cmi = CubitMessage::instance(); + TopoDS_Shape* from_shape = from_bodies_copy.get(); + DLIList<TopologyBridge*> tbs; + for (int i = 0; i < from_bodies_copy.size(); i++) + { + BodySM* from_body = from_bodies.get(); + CubitBox box1 = CAST_TO(from_body, OCCBody)->get_bounding_box(); + int count = 0; //count for not preforming cut + for(int j = 0; j < tool_bodies_copy.size(); j ++) + { + if (cmi->Interrupt()) + { + PRINT_ERROR("Subtraction interrupted. Aborting...\n"); + while (tool_boxes->size()) + delete tool_boxes->pop(); + delete tool_boxes; + while (tool_bodies_copy.size()) + delete tool_bodies_copy.pop(); + while (from_bodies_copy.size()) + delete from_bodies_copy.pop(); + return CUBIT_FAILURE; + } + CubitBox tool_box = *tool_boxes->get_and_step(); + if(!tool_box.overlap(tol,box1)) + { + count++; + continue; + } + TopoDS_Shape* tool_shape = tool_bodies_copy.get_and_step(); + + //bodies overlap, proceed with the subtract + BRepAlgoAPI_Cut cutter(*from_shape, *tool_shape); + TopoDS_Shape cut_shape = cutter.Shape(); + + //compare to see if the from_shape has gotten cut. + CubitBoolean has_changed; + check_operation(cut_shape, from_shape, is_volume[i], has_changed, &cutter, keep_old); + + CubitStatus stat; + if(!has_changed && !from_shape->IsNull()) + { + stat = CUBIT_FAILURE; + //Add imprint code here + if(imprint) + stat = imprint_toposhapes(from_shape, tool_shape); + if(!stat) + { + PRINT_ERROR("Can't do imprint operation on the body. \n"); + count++; + } + continue; + } + } + + //ok, we're done with all cuts, construct new Body' + if (count < tool_bodies_copy.size() ) + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*from_shape); + else + { + PRINT_INFO("The %d body did not change because cutting tools are not interscting with it.\n", i+1); + from_bodies.change_to(NULL); + } + from_bodies.step(); + from_shape = from_bodies_copy.step_and_get(); + + // done with this j iteration; write out count, if necessary + if (from_bodies.size() * tool_bodies_copy.size() > 1) + { + int frac_done = (100 * (i+1)) / (from_bodies.size()); + if ((100 - frac_done) < fraction_remaining) + { + fraction_remaining = 100 - frac_done; + PRINT_INFO("%d%% remaining.\n ", fraction_remaining+1); + } + } + } + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + //ok, we're done wih all cuts, delete unnecessaries. + if(keep_old) + { + int size = from_bodies_copy.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = from_bodies_copy.pop(); + shape->Nullify(); + delete shape; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : imprint_toposhapes +// Member Type: PROTECTED +// Description: imprint boolean operation on OCC-based bodies. +// from_shape must be TopoDS_Face or above, tool_shape can be +// TopoDS_Edge or above. +// on_faces works only when tool_shape is an Edge, indicates that +// those edges only imprint on the on_faces. +// Author : Jane HU +// Date : 03/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint_toposhapes(TopoDS_Shape*& from_shape, + TopoDS_Shape* tool_shape, + DLIList<TopoDS_Face*>*on_faces)const +{ + int count = 0; //number of imprinting + + //indicate if there's more faces to be imprinted + CubitBoolean more_face = CUBIT_TRUE; + DLIList<TopoDS_Face*> list_for_delete; + + //list of face on from_shape that has been imprinted + DLIList<TopoDS_Face*> from_faces; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + while( more_face) + { + TopoDS_Face from_face,tool_face; + TopoDS_Edge* common_edge = NULL; + DLIList<TopoDS_Shape*> tool_faces_edges; + TopTools_ListOfShape list_of_edges; + BRepFeat_SplitShape splitor(*from_shape); + CubitBoolean qualified = CUBIT_TRUE; + if (tool_shape->TShape()->ShapeType() == TopAbs_EDGE) + { + if(count == 1) + break; + + DLIList<TopoDS_Face*> faces; + //need to delete TopoDS_Face* in faces + common_edge = find_imprinting_edge(*from_shape, TopoDS::Edge(*tool_shape),faces); + if (common_edge) + { + if (on_faces) + qualified = CUBIT_FALSE; + for(int j = 0; j < faces.size(); j++) + { + from_face = *faces.get(); + for (int i = 0; on_faces && i < on_faces->size(); i++) + { + if (from_face.IsSame(*(on_faces->get_and_step()))) + { + qualified = CUBIT_TRUE; + break; + } + } + faces.get()->Nullify(); + delete faces.get(); + faces.step(); + } + if (qualified && (from_faces.size() == 0 || (from_faces.size() && !from_face.IsSame(*from_faces.get()))) ) + list_of_edges.Append(*common_edge); + else + from_face.Nullify(); + common_edge->Nullify(); + delete common_edge; + } + } + else + { + TopOpeBRep_ShapeIntersector intersector; + intersector.InitIntersection(*from_shape, *tool_shape); + + //find the intersecting edges and faces. + int max_edge = 0; + for(; intersector.MoreIntersection(); intersector.NextIntersection()) + { + TopoDS_Shape face1; + face1 = intersector.ChangeFacesIntersector().Face(1); + CubitBoolean has_imprinted = CUBIT_FALSE; + for (int j = 0; j < from_faces.size(); j++) + { + TopoDS_Face* topo_face = from_faces.get_and_step(); + if(face1.IsSame(*topo_face)) + { + has_imprinted = CUBIT_TRUE; + break; + } + } + + if (has_imprinted) + continue; + + TopoDS_Shape edge_face; + + edge_face = intersector.ChangeFacesIntersector().Face(2); + BRepAlgoAPI_Section section(face1, edge_face); + + //intersection edges between face1 and edge_face + TopTools_ListOfShape temp_list_of_edges; + temp_list_of_edges.Assign(section.SectionEdges()); + int num_edges = temp_list_of_edges.Extent(); + + CubitBoolean is_same = face1.IsSame(from_face); + CubitBoolean is_same_tool = CUBIT_FALSE; + for (int j = 0; j < tool_faces_edges.size(); j++) + { + TopoDS_Shape* topo_face_edge = tool_faces_edges.get_and_step(); + if(edge_face.IsSame(*topo_face_edge)) + { + is_same_tool = CUBIT_TRUE; + break; + } + } + if (max_edge < num_edges ) + { + list_of_edges.Assign(temp_list_of_edges); + max_edge = num_edges ; + from_face = TopoDS::Face(face1); + TopoDS_Shape* topo_shape = new TopoDS_Shape(edge_face); + DLIList<TopoDS_Shape*> shape_list; + for(int iii = 0; iii < tool_faces_edges.size(); iii++) + { + int size = shape_list.size(); + shape_list.append_unique(tool_faces_edges.get_and_step()); + if (size < shape_list.size()) + { + shape_list.last(); + shape_list.get()->Nullify(); + delete shape_list.get(); + } + } + tool_faces_edges.clean_out(); + for(int i = 0 ; i < num_edges; i++) + //later has to use it num_edges times + tool_faces_edges.append(topo_shape); + } + else if(num_edges == max_edge && is_same && !is_same_tool) + //multi tool faces cut the same face + { + TopTools_ListIteratorOfListOfShape Itor, temp_Itor; + temp_Itor.Initialize(temp_list_of_edges); + for(; temp_Itor.More(); temp_Itor.Next()) + { + TopoDS_Edge temp_edge = TopoDS::Edge(temp_Itor.Value()); + Itor.Initialize(list_of_edges); + CubitBoolean same_edge = CUBIT_FALSE; + + GProp_GProps myProps1; + BRepGProp::LinearProperties(temp_edge, myProps1); + gp_Pnt center1 = myProps1.CentreOfMass(); + for(; Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + GProp_GProps myProps2; + BRepGProp::LinearProperties(edge, myProps2); + gp_Pnt center2 = myProps2.CentreOfMass(); + if(center1.IsEqual(center2, tol)) + { + same_edge = CUBIT_TRUE; + break; + } + } + if(!same_edge) + { + list_of_edges.Append(temp_edge); + TopoDS_Shape* topo_shape = new TopoDS_Shape(edge_face); + tool_faces_edges.append(topo_shape); + } + } + } + } + } + if (from_face.IsNull()) + { + more_face = CUBIT_FALSE; + DLIList<TopoDS_Shape*> shape_list; + for(int iii = 0; iii < tool_faces_edges.size(); iii++) + { + int size = shape_list.size(); + shape_list.append_unique(tool_faces_edges.get_and_step()); + if (size < shape_list.size()) + { + shape_list.last(); + shape_list.get()->Nullify(); + delete shape_list.get(); + } + } + tool_faces_edges.clean_out(); + + for (int iii=0; iii < from_faces.size(); iii++) + { + TopoDS_Face* topo_face = from_faces.get_and_step(); + topo_face->Nullify(); + delete topo_face; + } + + for (int iii=0; iii < list_for_delete.size(); iii++) + { + TopoDS_Face* topo_face = list_for_delete.get_and_step(); + topo_face->Nullify(); + delete topo_face; + } + continue; + } + + TopTools_ListIteratorOfListOfShape Itor; + + //list_of_edges is the intersection edges on tool_faces_edges + Itor.Initialize(list_of_edges); + int total_edges = list_of_edges.Extent(); + DLIList<Curve*> curve_list; + CubitBoolean topo_changed = CUBIT_FALSE; + tool_faces_edges.reset(); + + //check to see if the intersection edge is: + //1. on from_face: if not, skip it + //2. overlap with from_edges : if not, add the edge for splitting face + //3. if overlap, is it the same edge:if not add it for splitting edge + // if yes, skip it too + + Surface* face = NULL; + if (OCCQueryEngine::instance()->OCCMap->IsBound(from_face)) + { + int i = OCCQueryEngine::instance()->OCCMap->Find(from_face); + face = (OCCSurface*)(OCCQueryEngine::instance()->OccToCGM->find(i))->second; + } + else + face = OCCQueryEngine::instance()->populate_topology_bridge(from_face); + OCCSurface* occ_face = CAST_TO(face, OCCSurface); + + DLIList<Curve*> common_curves; + for(; Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + //copy the edge for imprinting. + BRepBuilderAPI_Copy api_copy(edge); + TopoDS_Shape newShape = api_copy.ModifiedShape(edge); + edge = TopoDS::Edge(newShape); + Curve* curve = NULL; + curve = OCCQueryEngine::instance()->populate_topology_bridge(edge); + if(curve) + common_curves.append(curve); + } + + DLIList<DLIList<TopoDS_Edge*>*> temp_edge_lists; + list_of_edges.Clear(); + if (common_curves.size() >= 1) + { + sort_curves(common_curves, temp_edge_lists); + DLIList<TopoDS_Edge*>* edge_list; + int size = temp_edge_lists.size(); + for(int i = 0; i < size; i++) + { + edge_list = temp_edge_lists.pop(); + //make sure the copied edges are sharing vertices. + BRepBuilderAPI_MakeWire myWire; + edge_list->reset(); + for(int i = 0; i < edge_list->size(); i++) + { + TopoDS_Edge e = *(edge_list->get_and_step()); + myWire.Add(e); + } + TopoDS_Wire wire = myWire.Wire(); + BRepTools_WireExplorer Ex(wire); + for(; Ex.More(); Ex.Next()) + list_of_edges.Append(Ex.Current()); + } + } + for(Itor.Initialize(list_of_edges); Itor.More(); Itor.Next()) + { + TopoDS_Edge edge = TopoDS::Edge(Itor.Value()); + //check to see if the intersection edge is on from_face + TopExp_Explorer Ex; + CubitBoolean added = CUBIT_FALSE; + CubitBoolean skipped = CUBIT_FALSE; + GProp_GProps myProps1; + BRepGProp::LinearProperties(edge, myProps1); + double d1 = myProps1.Mass(); + gp_Pnt pt = myProps1.CentreOfMass(); + CubitVector p(pt.X(), pt.Y(), pt.Z()); + + CubitVector point_on_surf; + occ_face->closest_point_trimmed(p, point_on_surf); + if(p.distance_between(point_on_surf) > tol) //edge not on from_face + { + skipped = CUBIT_TRUE; + total_edges--; + } + + else + { + for (Ex.Init(from_face, TopAbs_EDGE); Ex.More(); Ex.Next()) + { + //check if the edge is on from_face edges, add such edge on existing + //edge to split it. + TopoDS_Edge from_edge = TopoDS::Edge(Ex.Current()); + + GProp_GProps myProps2; + BRepGProp::LinearProperties(from_edge, myProps2); + double d2 = myProps2.Mass(); + Curve* curve = NULL; + if (OCCQueryEngine::instance()->OCCMap->IsBound(from_edge)) + { + int i = OCCQueryEngine::instance()->OCCMap->Find(from_edge); + curve = (OCCCurve*)(OCCQueryEngine::instance()->OccToCGM->find(i))->second; + } + else + curve = OCCQueryEngine::instance()->populate_topology_bridge(from_edge); + OCCCurve* occ_curve = CAST_TO(curve, OCCCurve); + CubitPointContainment pc = occ_curve->point_containment(p); + + if(pc == CUBIT_PNT_ON) //overlap + { + //check if they are the same edge, so don't need to be split + //the overlapped edges are considered the same if they have the + //same length + if((d2 - d1) > tol) + { + added = CUBIT_TRUE; + splitor.Add(edge, from_edge); + } + else + skipped = CUBIT_TRUE; + total_edges--; + break; + } + } + } + if(added) + { + topo_changed = CUBIT_TRUE; + continue; + } + if (!skipped) + { + //check if edge's inside from_face by checking bounding boxes + BRepAdaptor_Curve acurve(edge); + BRepAdaptor_Surface asurface( from_face); + Bnd_Box aBox_edge, aBox_face; + BndLib_Add3dCurve::Add(acurve, Precision::Approximation(), aBox_edge); + BndLib_AddSurface::Add(asurface, Precision::Approximation(), aBox_face); + double min[3], max[3]; + aBox_edge.Get( min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox aBox_e(min, max); + aBox_face.Get( min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox aBox_f(min, max); + if (aBox_e <= aBox_f) + { + Curve* curve = OCCQueryEngine::instance()->populate_topology_bridge(edge); + curve_list.append(curve); + } + } + } + + DLIList<DLIList<TopoDS_Edge*>*> edge_lists; + if (total_edges >= 1) + { + CubitStatus stat = sort_curves(curve_list, edge_lists); + DLIList<TopoDS_Edge*>* edge_list; + int size = edge_lists.size(); + for (int iii = 0; iii < size; iii++) + { + edge_list = edge_lists.pop(); + + //check if the edges make a split of the surface, error out if it's + //just a scar on the surface + int count_intersection = 0; + if (stat == CUBIT_FAILURE) //Open wire + { + count_intersection = check_intersection(edge_list, from_face); + + if (count_intersection < 2) + PRINT_WARNING("Cant make a scar on existing face without splitting it. \n"); + } + if (stat || count_intersection == 2) + { + BRepBuilderAPI_MakeWire myWire; + edge_list->reset(); + for(int i = 0; i < edge_list->size(); i++) + { + TopoDS_Edge e = *(edge_list->get_and_step()); + myWire.Add(e); + } + splitor.Add(myWire.Wire(),from_face); + topo_changed = CUBIT_TRUE; + break; + } + for(int iii = 0; iii < edge_list->size(); iii++) + edge_list->pop(); + delete edge_list; + } + } + if(topo_changed) + { + splitor.Build(); + topo_changed = CUBIT_FALSE; + if(splitor.IsDone()) + { + //take care of on_faces list first:after operation, the on_faces + // will have at least one face changed, update the pointer. + if (on_faces) + { + for(int k = 0; k < on_faces->size(); k++) + { + TopoDS_Face* compare_face = on_faces->get_and_step(); + if(from_face.IsSame(*compare_face)) + { + on_faces->remove(compare_face); + TopTools_ListOfShape shapes; + shapes.Assign(splitor.Modified(from_face)); + while(shapes.Extent() > 0) + { + TopoDS_Face* face = + new TopoDS_Face(TopoDS::Face(shapes.First())); + shapes.RemoveFirst(); + on_faces->append(face); + list_for_delete.append(face); + } + } + } + } + + TopoDS_Shape new_from_shape = splitor.Shape(); + if(from_shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + TopoDS_CompSolid old_csolid = TopoDS::CompSolid(*from_shape); + OCCBody::update_OCC_entity(old_csolid, new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + + else if(from_shape->TShape()->ShapeType() == TopAbs_SOLID) + { + TopoDS_Solid old_solid = TopoDS::Solid(*from_shape); + OCCLump::update_OCC_entity(old_solid, new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + else if(from_shape->TShape()->ShapeType() == TopAbs_SHELL) + { + TopoDS_Shell old_shell = TopoDS::Shell(*from_shape); + OCCShell::update_OCC_entity(old_shell,new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + else if(from_shape->TShape()->ShapeType() == TopAbs_FACE) + { + TopoDS_Face old_face = TopoDS::Face(*from_shape); + OCCSurface::update_OCC_entity(old_face,new_from_shape, &splitor); + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(new_from_shape); + } + + TopTools_ListOfShape shapes; + for(int i = 0; i < from_faces.size(); i++) + { + TopoDS_Face* topo_face = from_faces.get(); + shapes.Assign(splitor.Modified(*topo_face)); + topo_face = new TopoDS_Face(TopoDS::Face(shapes.First())); + from_faces.get()->Nullify(); + delete from_faces.get(); + from_faces.change_to(topo_face); + from_faces.step(); + } + count++; + } + } + else + { + TopoDS_Face* topo_face = new TopoDS_Face(from_face); + from_faces.append(topo_face); + } + } + + + TopExp_Explorer Ex; + int num_face = 0; + for (Ex.Init(*from_shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + TopoDS_Face face = TopoDS::Face(Ex.Current()); + num_face++; + } + +#ifdef DEBUG + PRINT_INFO("Total %d cuts performed, with from_shape having %d faces.\n", count, num_face); +#endif + + if (count > 0) + return CUBIT_SUCCESS; + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : find_imprinting_edge +// Member Type: PROTECTED +// Description: imprint boolean operation on OCC-based bodies. +// from_shape must be TopoDS_Face or above, tool_shape must be +// TopoDS_Edge. +// Author : Jane HU +// Date : 05/08 +//=============================================================================== +TopoDS_Edge* OCCModifyEngine::find_imprinting_edge(TopoDS_Shape& from_shape, + TopoDS_Edge& tool_shape, + DLIList<TopoDS_Face*>& from_faces)const +{ + TopoDS_Edge* edge = NULL; + //list of face on from_shape that has been imprinted + from_faces.clean_out(); + TopExp_Explorer Ex; + for (Ex.Init(from_shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + TopoDS_Face face = TopoDS::Face(Ex.Current()); + BRepAlgoAPI_Common intersector(face, tool_shape); + TopTools_ListOfShape shapes; + shapes.Assign(intersector.Modified(tool_shape)); + if (shapes.IsEmpty()) + continue; + if ( shapes.Extent() > 1) + { + PRINT_ERROR("Edge has multiple intersection with the shape, make it simpler. \n"); + continue; + } + if (shapes.First().TShape()->ShapeType() != TopAbs_EDGE) + continue; + if(edge == NULL) + { + TopoDS_Edge common_edge = TopoDS::Edge(shapes.First()); + BRepBuilderAPI_Copy api_copy(common_edge); + TopoDS_Shape newShape = api_copy.ModifiedShape(common_edge); + edge = new TopoDS_Edge(TopoDS::Edge(newShape)); + } + from_faces.append(new TopoDS_Face(face)); + } + return edge; +} + +int OCCModifyEngine::check_intersection(DLIList<TopoDS_Edge*>* edge_list, + TopoDS_Face from_face)const +{ + int count_intersection = 0; + //Consider if edge_list has only one edge, and it intersects the from_face + //at two different places. + CubitBoolean double_check = CUBIT_FALSE; + if (edge_list->size() == 1) + double_check = CUBIT_TRUE; + + gp_Pnt intsec_pnt[2]; + for(int j = 0; j < edge_list->size(); j++) + { + TopoDS_Edge* edge = edge_list->get_and_step(); + BRepAdaptor_Curve acurve(*edge); + double lower_bound = acurve.FirstParameter(); + double upper_bound = acurve.LastParameter(); + TopExp_Explorer Ex; + gp_Pnt newP[2]; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + for (Ex.Init(from_face, TopAbs_EDGE); Ex.More(); Ex.Next()) + { + TopoDS_Edge from_edge = TopoDS::Edge(Ex.Current()); + BRepAdaptor_Curve acurve2(from_edge); + double lower_bound2 = acurve2.FirstParameter(); + double upper_bound2 = acurve2.LastParameter(); + BRepExtrema_DistShapeShape distShapeShape(*edge, from_edge); + CubitBoolean qualified[2] = {CUBIT_FALSE, CUBIT_FALSE}; + if (distShapeShape.IsDone() && distShapeShape.Value() < tol) + { + newP[0] = distShapeShape.PointOnShape1(1); + if (double_check && distShapeShape.NbSolution() == 2) + newP[1] = distShapeShape.PointOnShape1(2); + double newVal[2]; + for(int j =0; j < distShapeShape.NbSolution(); j++) + { + Extrema_ExtPC ext(newP[j], acurve, Precision::Approximation()); + if (ext.IsDone() && (ext.NbExt() > 0)) { + for ( int i = 1 ; i <= ext.NbExt() ; i++ ) { + if ( ext.IsMin(i) ) { + newVal[j] = ext.Point(i).Parameter(); + if ((newVal[j]-lower_bound) >= -tol && + (upper_bound - newVal[j]) >= -tol) + { + qualified[j] = CUBIT_TRUE; + break; + } + } + } + } + } + for(int j = 0; j < distShapeShape.NbSolution(); j++) + { + if (qualified[j]) + { + qualified[j] = CUBIT_FALSE; + Extrema_ExtPC ext(newP[j], acurve2, Precision::Approximation()); + double newVal; + if (ext.IsDone() && (ext.NbExt() > 0)) { + for ( int i = 1 ; i <= ext.NbExt() ; i++ ) { + if ( ext.IsMin(i) ) { + newVal = ext.Point(i).Parameter(); + if ((newVal-lower_bound2) >= -tol && + (upper_bound2 - newVal) >= -tol) + { + qualified[j] = CUBIT_TRUE; + break; + } + } + } + } + } + } + for(int k = 0; k < distShapeShape.NbSolution(); k++) + { + if (qualified[k]) + count_intersection++; + intsec_pnt[count_intersection-1] = newP[k]; + if (count_intersection == 2) + { + //make sure the two intersect point are not the same one + if (intsec_pnt[0].IsEqual(intsec_pnt[1], tol)) + count_intersection--; + } + } + } + if (count_intersection == 2) + break; + } //for loop + } + return count_intersection; +} +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: imprint boolean operation on OCC-based bodies +// Author : Jane Hu +// Date : 04/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint(BodySM* BodyPtr1, BodySM* BodyPtr2, + BodySM*& newBody1, BodySM*& newBody2, + bool keep_old) const +{ + newBody1 = NULL; + newBody2 = NULL; + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + + DLIList<BodySM*> bodysm_list; + bodysm_list.append(BodyPtr1); + bodysm_list.append(BodyPtr2); + + CubitStatus stat = get_shape_list(bodysm_list,shape_list,is_volume,keep_old); + + if(!stat) + return stat; + + TopoDS_Shape* shape1 = shape_list.get(); + TopoDS_Shape* shape2 = shape_list.step_and_get(); + DLIList<TopologyBridge*> tbs; + stat = imprint_toposhapes(shape1, shape2); + if(stat) + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape1); + newBody1 = CAST_TO(tbs.get(),BodySM); + } + + else if(!stat && keep_old) + { + delete shape1; + PRINT_INFO("There's no imprint on the first body.\n"); + newBody1 = BodyPtr1; + } + + tbs.clean_out(); + stat = imprint_toposhapes(shape2, shape1); + if(stat) + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape2); + newBody2 = CAST_TO(tbs.get(),BodySM); + } + + else if(!stat && keep_old) + { + delete shape2; + PRINT_INFO("There's no imprint on the second body.\n"); + newBody2 = BodyPtr2; + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : get_the_shape_list +// Member Type: PRIVATE +// Description: get the TopoDS_Shape list for imprinting use. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::get_shape_list(DLIList<BodySM*>& BodySM_list, + DLIList<TopoDS_Shape*>& shape_list, + DLIList<CubitBoolean>& is_volume, + bool keep_old, + DLIList<CubitBox*>* b_boxes) const +{ + OCCBody* occ_body = NULL; + shape_list.clean_out(); + is_volume.clean_out(); + CubitStatus stat = CUBIT_SUCCESS; + for(int i = 0; i <BodySM_list.size(); i++) + { + occ_body = CAST_TO(BodySM_list.get_and_step(), OCCBody); + if (!occ_body) + continue; + + OCCSurface* surface = occ_body->my_sheet_surface(); + OCCShell* shell = occ_body->shell(); + is_volume.append( CUBIT_TRUE); + + if(b_boxes) + { + CubitBox *tool_box = new CubitBox(occ_body->get_bounding_box()); + b_boxes->append(tool_box); + } + + if(surface) + { + TopoDS_Face* topo_face = surface->get_TopoDS_Face(); + if(!topo_face) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*topo_face); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topo_face); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(topo_face); + is_volume.change_to( CUBIT_FALSE); + } + else if(shell) + { + TopoDS_Shell* topo_shell = shell->get_TopoDS_Shell(); + if(!topo_shell) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*topo_shell); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topo_shell); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(topo_shell); + is_volume.change_to( CUBIT_FALSE); + } + + else + { + DLIList<Lump*> lumps = occ_body->lumps(); + if (lumps.size() > 1) + { + PRINT_ERROR("Can't do boolean operation on CompSolid types. \n"); + stat = CUBIT_FAILURE; + break; + } + + TopoDS_Solid* solid = CAST_TO(lumps.get(), OCCLump)->get_TopoDS_Solid(); + if(!solid) + { + stat = CUBIT_FAILURE; + break; + } + if(keep_old) + { + BRepBuilderAPI_Copy api_copy(*solid); + TopoDS_Shape newShape = api_copy.ModifiedShape(*solid); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + shape_list.append(Shape1); + } + else + shape_list.append(solid); + } + } + if(!stat) + { + for (int i = 0; keep_old && i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + delete shape; + } + shape_list.clean_out(); + return CUBIT_FAILURE; + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Function : imprint multiple bodies at once +// Member Type: PUBLIC +// Description: imprint boolean operation on OCC-based bodies +// Author : Jane HU +// Date : 04/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint(DLIList<BodySM*> &from_body_list , + DLIList<BodySM*> &new_from_body_list, + bool keep_old, + DLIList<TopologyBridge*>* new_tbs, + DLIList<TopologyBridge*>* att_tbs) const +{ + CubitStatus success = CUBIT_SUCCESS; + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(from_body_list, shape_list, is_vo,keep_old); + + if(!stat) + return stat; + + int size = shape_list.size(); + // total number of imprints to be done + int total_imprints = (size * (size -1))/2; + + if( size > 2 ) + { + char message[128]; + sprintf(message, "Imprinting %d OCC Bodies", from_body_list.size() ); + AppUtil::instance()->progress_tool()->start(0, total_imprints, message); + } + + for(int i = 0; i < size; i++) + { + TopoDS_Shape* shape1 = shape_list[i]; + CubitBoolean modified = CUBIT_FALSE; + for(int j = i+1; j < size+i; j ++) + { + if (CubitMessage::instance()->Interrupt()) + { + success = CUBIT_FAILURE; + break; + } + + TopoDS_Shape* shape2 = shape_list[j%size]; + DLIList<TopologyBridge*> tbs; + CubitStatus stat = imprint_toposhapes(shape1, shape2); + if(stat) + modified = CUBIT_TRUE; + } + if(modified) + { + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape1); + new_from_body_list.append(CAST_TO(tbs.get(),BodySM)); + } + shape_list.reset(); + if( size > 2 ) + AppUtil::instance()->progress_tool()->step(); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->end(); + + if( CubitMessage::instance()->Interrupt() ) + PRINT_INFO("Imprint aborted.\n"); + + return success; +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: imprint curves onto body_list +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<BodySM*> &body_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + bool show_messages) const +{ + CubitStatus success = CUBIT_SUCCESS; + DLIList<TopoDS_Shape*> shape_list, tool_shapes; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(body_list, shape_list, is_vo, keep_old); + if (!stat) + return stat; + + int size = ref_edge_list.size(); + // total number of imprints to be done + + if( size > 2 && show_messages) + { + char message[128]; + sprintf(message, "Imprinting %d OCC Bodies", body_list.size() ); + AppUtil::instance()->progress_tool()->start(0, size, message); + } + for (int i = 0; i < ref_edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(ref_edge_list.get_and_step(), OCCCurve) ; + if (!curve) + continue; + + TopoDS_Edge* edge = curve->get_TopoDS_Edge(); + if (edge->IsNull()) + continue; + + if (CubitMessage::instance()->Interrupt()) + { + success = CUBIT_FAILURE; + break; + } + + for(int j = 0; j < shape_list.size(); j ++) + { + TopoDS_Shape* shape = shape_list.get(); + + stat = imprint_toposhapes(shape, (TopoDS_Shape*)edge); + if (stat) + shape_list.change_to(shape); + shape_list.step(); + body_list.step(); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->step(); + } + + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append(CAST_TO(tbs.get(),BodySM)); + } + + if( size > 2 ) + AppUtil::instance()->progress_tool()->end(); + + if( CubitMessage::instance()->Interrupt() ) + PRINT_INFO("Imprint aborted.\n"); + return success; +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: to be consistante with Acis imprint. +// The surfaces must be part of a body, but the curves +// just have to be valid OCC edge. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old ) const +{ + DLIList<TopoDS_Face*> face_list; + DLIList<TopoDS_Shape*> shape_list; + + face_edge_imprint(ref_face_list, edge_list, face_list, shape_list, keep_old); + + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + if (shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + if(!OCCQueryEngine::instance()->OCCMap->IsBound(*shape)) + { + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_SOLID);Ex.More(); Ex.Next()) + { + TopoDS_Shape subshape = Ex.Current(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(subshape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + } + else + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + + if (keep_old) + { + for(int i = 0; i < face_list.size(); i++) + { + TopoDS_Face* face = face_list.get(); + face->Nullify(); + delete face; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : face_edge_imprint +// Member Type: PRIVATE +// Description: to be consistante with Acis imprint. +// The surfaces must be part of a body, but the curves +// just have to be valid OCC edge. +// Author : Jane Hu +// Date : 05/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::face_edge_imprint( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &edge_list, + DLIList<TopoDS_Face*>& face_list, + DLIList<TopoDS_Shape*>& shape_list, + bool keep_old ) const +{ + for(int i = 0; i <ref_face_list.size(); i++) + { + OCCSurface* surface = CAST_TO(ref_face_list.get_and_step(), OCCSurface); + if(!surface) + continue; + + TopoDS_Face* topo_face = surface->get_TopoDS_Face(); + face_list.append(topo_face); + + if(surface->my_shell() && !surface->my_body())//shell body + shape_list.append(surface->my_shell()->get_TopoDS_Shell()); + else if(surface->my_body()) //a sheet body + shape_list.append(topo_face); + else + { + //int size = shape_list.size(); + OCCQueryEngine* oqe = OCCQueryEngine::instance(); + DLIList <OCCBody* > *bodies = oqe->BodyList; + TopTools_IndexedDataMapOfShapeListOfShape M; + OCCBody * body = NULL; + for(int j = 0; j < bodies->size(); j++) + { + body = bodies->get_and_step(); + TopExp_Explorer Ex; + TopoDS_Face the_face; + TopoDS_Shape ashape = *(body->get_TopoDS_Shape()); + M.Clear(); + TopExp::MapShapesAndAncestors(ashape, TopAbs_FACE, TopAbs_COMPSOLID, M); + if(!M.Contains(*topo_face)) + continue; + shape_list.append_unique(body->get_TopoDS_Shape()); + } + } + } + + if(keep_old) + { + for(int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get(); + BRepBuilderAPI_Copy api_copy(*shape); + TopoDS_Shape newShape = api_copy.ModifiedShape(*shape); + TopoDS_Shape* Shape1 = new TopoDS_Shape(newShape); + for(int j = 0; j < face_list.size(); j++) + { + TopoDS_Face* face = face_list.get(); + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_FACE); Ex.More(); Ex.Next()) + { + if(face->IsSame(Ex.Current())) + { + face = new TopoDS_Face(TopoDS::Face(api_copy.ModifiedShape(*face))); + face_list.change_to(face); + } + } + face_list.step(); + } + shape_list.change_to(Shape1); + shape_list.step(); + } + } + + for (int i = 0; i < edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(edge_list.get_and_step(), OCCCurve) ; + if (!curve) + continue; + + TopoDS_Edge* edge = curve->get_TopoDS_Edge(); + if (edge->IsNull()) + continue; + + for(int j = 0; j < shape_list.size(); j ++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + imprint_toposhapes(shape, (TopoDS_Shape*)edge, &face_list); + } + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: To be consistent with AcisModifyEngine, althought it's hard +// to have a GUI interface for users to input. All surface must +// on the same body. +// Author : Jane HU +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<Surface*>& surface_list, + DLIList<DLIList<Curve*>*>& curve_lists_list, + BodySM*& new_body, + bool keep_old ) const +{ + DLIList<TopoDS_Face*> face_list; + DLIList<TopoDS_Shape*> shape_list; + DLIList<TopoDS_Shape*> shape_list_all; + + assert (surface_list.size() == curve_lists_list.size()); + + for(int j = 0; j < surface_list.size(); j++) + { + Surface* surface = surface_list.get_and_step(); + DLIList<Surface*> ref_face_list; + ref_face_list.append(surface); + DLIList<Curve*> *edge_list = curve_lists_list.get_and_step(); + face_edge_imprint(ref_face_list, *edge_list, face_list, shape_list, keep_old); + + for(int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* shape = shape_list.get_and_step(); + shape_list_all.append_unique(shape); + } + shape_list.clean_out(); + + if (keep_old) + { + for(int i = 0; i < face_list.size(); i++) + { + TopoDS_Face* face = face_list.get(); + face->Nullify(); + delete face; + } + } + + face_list.clean_out(); + } + + DLIList<BodySM*> new_body_list; + shape_to_bodySM(shape_list, new_body_list); + + if (new_body_list.size() == 1) + { + new_body = new_body_list.get(); + return CUBIT_SUCCESS; + } + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : shape_to_bodySM +// Member Type: PRIVATE +// Description: After imprint, update shape list to bodySM_list +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +void OCCModifyEngine::shape_to_bodySM( DLIList<TopoDS_Shape*> shape_list, + DLIList<BodySM*>& new_body_list)const +{ + for(int j = 0; j < shape_list.size(); j ++) + { + DLIList<TopologyBridge*> tbs; + TopoDS_Shape* shape = shape_list.get_and_step(); + if (shape->TShape()->ShapeType() == TopAbs_COMPSOLID) + { + if(!OCCQueryEngine::instance()->OCCMap->IsBound(*shape)) + { + TopExp_Explorer Ex; + for (Ex.Init(*shape, TopAbs_SOLID);Ex.More(); Ex.Next()) + { + TopoDS_Shape subshape = Ex.Current(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(subshape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } + } + else + { + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*shape); + new_body_list.append_unique(CAST_TO(tbs.get(),BodySM)); + } + } +} + +//=============================================================================== +// Function : imprint +// Member Type: PUBLIC +// Description: Imprints locations to bodies (for splitting curves, there's +// no known ways to put hard points on surfaces in OCC, so I just +// add free_vertex on OCCSurface definition, mesh should look on +// this structure). +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::imprint( DLIList<BodySM*> &body_list, + DLIList<CubitVector*> &vector_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + DLIList<TopologyBridge*>*, + DLIList<TopologyBridge*>* ) const +{ + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_vo; + CubitStatus stat = get_shape_list(body_list, shape_list, is_vo, keep_old); + if(!stat) + return stat; + + for (int i = 0; i < body_list.size(); i++) + { + OCCBody* body = CAST_TO(body_list.get_and_step(), OCCBody); + TopoDS_Shape* from_shape = shape_list.get_and_step(); + if (!body) + continue; + DLIList<OCCSurface*> surfaces; + DLIList<OCCCurve*> curves; + + body->get_all_surfaces(surfaces); + body->get_all_curves(curves); + + CubitBoolean on_vertex = CUBIT_FALSE; + CubitBoolean on_curve = CUBIT_FALSE; + for (int j = 0; j < vector_list.size(); j ++) + { + CubitVector* v = vector_list[j]; + if(v == NULL) + continue; + for (int k = 0; k < curves.size(); k ++) + { + OCCCurve* curve = curves.get_and_step(); + CubitPointContainment pc = curve->point_containment(*v); + if(pc == CUBIT_PNT_BOUNDARY) + { + on_vertex = CUBIT_TRUE; + break; + } + + else if( pc == CUBIT_PNT_INSIDE) + { + LocOpe_SplitShape splitor(*from_shape); + on_curve = CUBIT_TRUE; + TopoDS_Edge edge = *curve->get_TopoDS_Edge(); + gp_Pnt pt = gp_Pnt(v->x(), v->y(), v->z()); + TopoDS_Vertex vertex = BRepBuilderAPI_MakeVertex(pt); + double param = curve->u_from_position(*v); + splitor.Add(vertex, param, edge); + + //update the curve_list + TopTools_ListOfShape edge_shapes; + edge_shapes.Assign(splitor.DescendantShapes(edge)); + while(edge_shapes.Extent()) + { + TopoDS_Shape edge_shape = edge_shapes.First(); + TopoDS_Edge occ_edge = TopoDS::Edge(edge_shape); + OCCCurve* test_curve; + test_curve = CAST_TO(OCCQueryEngine::instance()->populate_topology_bridge(occ_edge), OCCCurve); + if(test_curve) + curves.append(test_curve); + edge_shapes.RemoveFirst(); + } + curves.remove(curve); + + TopTools_ListOfShape shapes; + shapes.Assign(splitor.DescendantShapes(*from_shape)); + if(from_shape->TShape()->ShapeType() ==TopAbs_COMPSOLID) + OCCBody::update_OCC_entity(*from_shape, shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + else if(shapes.First().TShape()->ShapeType() == TopAbs_SOLID) + OCCLump::update_OCC_entity(TopoDS::Solid(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + else if(shapes.First().TShape()->ShapeType() == TopAbs_SHELL) + OCCShell::update_OCC_entity(TopoDS::Shell(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + else if(shapes.First().TShape()->ShapeType() == TopAbs_FACE) + OCCSurface::update_OCC_entity(TopoDS::Face(*from_shape), + shapes.First(), + (BRepBuilderAPI_MakeShape*) NULL, &splitor); + + from_shape->Nullify(); + delete from_shape; + from_shape = new TopoDS_Shape(shapes.First()); + break; + } + } + if(on_vertex || on_curve) + continue; + + //check possible on surface + for(int n = 0; n < surfaces.size(); n ++) + { + OCCSurface* surface = surfaces.get_and_step(); + if(!surface->is_position_on(*v)) + continue; + + CubitPointContainment ps = surface->point_containment(*v); + if(ps == CUBIT_PNT_INSIDE) + { + Point* p = make_Point(*v); + if(p) + surface->add_hardpoint(CAST_TO(p, OCCPoint)); + break; + } + } + } + } + + shape_to_bodySM(shape_list, new_body_list); + + return stat; +} + +//=============================================================================== +// Function : imprint_projected_edges +// Member Type: PUBLIC +// Description: Projects a list of Curves on to a list of Surfaces +// and imprint the faces with the new Curves +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::imprint_projected_edges( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old_body, + bool keep_free_edges) const +{ + DLIList<Curve*> projected_curves; + CubitStatus + stat = project_edges(ref_face_list, ref_edge_list, projected_curves); + if(!stat) + return stat; + + // imprint Surface with curves + stat = imprint(ref_face_list, projected_curves, new_body_list, keep_old_body ); + + if(keep_free_edges) + return stat; + + PRINT_INFO( "Removing projected curves \n"); + for(int i=0; i< projected_curves.size();i++) + { + // Now delete this Curve and its underlying solid model entities + + Curve* curve = projected_curves.get_and_step(); + stat = OCCQueryEngine::instance()->delete_solid_model_entities( curve ); + if (stat == CUBIT_FAILURE) + { + PRINT_ERROR("In OCCQueryEngine::delete_geometry\n" + " Could not delete OCCCurve.\n" + " The Model database is likely corrupted " + "due to\n this unsuccessful deletion.\n" ); + } + } + return stat; +} +//=============================================================================== +// Function : project_edges +// Member Type: PUBLIC +// Description: Projects a list of Curves on to a list of Surfaces +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::project_edges( DLIList<Surface*> &ref_face_list, + DLIList<Curve*> &ref_edge_list, + DLIList<Curve*> &projected_curves, + bool print_error ) const + +{ + CubitVector* v = NULL; + Curve* projected_curve = NULL; + DLIList<Point*> points; + //project curves onto surfaces. + for(int i = 0; i < ref_edge_list.size(); i++) + { + OCCCurve* curve = CAST_TO(ref_edge_list.get_and_step(), OCCCurve); + if(!curve) + continue; + + for (int j = 0; j < ref_face_list.size(); j++) + { + OCCSurface* surface = CAST_TO(ref_face_list.get_and_step(), OCCSurface); + if(!surface) + continue; + if(surface->is_closed_in_U() || surface->is_closed_in_V()) + { + if(print_error) + PRINT_ERROR("This function can't project curves on closed surfaces.\n"); + return CUBIT_FAILURE; + } + + projected_curve = NULL; + projected_curve = curve->project_curve(surface, points, CUBIT_FALSE, v); + if(projected_curve) + projected_curves.append_unique(projected_curve); + } + } + while(points.size() > 0) + delete points.pop(); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : imprint_projected_edges +// Member Type: PUBLIC +// Description: Projects a list of curves on to a list of surfaces +// and imprint the bodies with the new curves +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus +OCCModifyEngine::imprint_projected_edges(DLIList<Surface*> &ref_face_list, + DLIList<BodySM*> &body_list, + DLIList<Curve*> &ref_edge_list, + DLIList<BodySM*>& new_body_list, + bool keep_old, + bool keep_free_edges) const +{ + DLIList<Curve*> projected_curves; + CubitStatus + stat = project_edges(ref_face_list, ref_edge_list, projected_curves); + if(!stat) + return stat; + return CUBIT_FAILURE; + + // imprint bodies with curves + stat = imprint(body_list,projected_curves, new_body_list, keep_old); + + if (keep_free_edges) + return stat; + + PRINT_INFO( "Removing projected curves \n"); + for(int i=0; i< projected_curves.size();i++) + { + // Now delete this Curve + Curve* curve = projected_curves.get_and_step(); + stat = OCCQueryEngine::instance()-> + delete_solid_model_entities( curve ); + if (stat == CUBIT_FAILURE) + { + PRINT_ERROR("In OCCModifyEngine::delete_geometry\n" + " Could not delete Curve.\n" + " The Model database is likely corrupted " + "due to\n this unsuccessful deletion.\n" ); + } + } + return stat; +} + +//=============================================================================== +// Function : intersect +// Member Type: PUBLIC +// Description: intersect boolean operation of body with list of bodies. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::intersect(BodySM* tool_body_ptr, + DLIList<BodySM*> &from_bodies, + DLIList<BodySM*> &new_bodies, + bool keep_old) const +{ + DLIList<BodySM*> tool_bodies; + DLIList<TopoDS_Shape*> tool_shapes; + DLIList<CubitBoolean> is_tool_volume, is_volume; + + tool_bodies.append(tool_body_ptr); + //get tool_body's underlying shape, copy it, so boolean wouldn't touch it. + CubitStatus stat = + get_shape_list(tool_bodies, tool_shapes, is_tool_volume, CUBIT_TRUE); + if(!stat) + return stat; + + DLIList<TopoDS_Shape*> shape_list; + stat = get_shape_list(from_bodies, shape_list, is_volume, keep_old); + if(!stat) + { + for (int i = 0; i < tool_shapes.size(); i++) + { + TopoDS_Shape* shape = tool_shapes.get_and_step(); + delete shape; + } + tool_shapes.clean_out(); + return CUBIT_FAILURE; + } + + TopoDS_Shape* tool_shape = tool_shapes.get(); + CubitBoolean has_changed; + DLIList<TopologyBridge*> tbs; + for (int i = 0; i < shape_list.size(); i++) + { + TopoDS_Shape* from_shape = shape_list.get_and_step(); + //BodySM* from_body = from_bodies.get_and_step(); + BRepAlgoAPI_Common intersector(*from_shape, *tool_shape); + TopoDS_Shape common_shape = intersector.Shape(); + check_operation(common_shape, from_shape, is_volume[i], has_changed, + &intersector, keep_old); + + if(from_shape->IsNull()) + { + PRINT_INFO("The %d body did not have common part with the tool_body.\n", i+1); + continue; + } + else + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*from_shape); + } + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + //ok, we're done wih all cuts, delete unnecessaries. + if(!keep_old) + OCCQueryEngine::instance()->delete_solid_model_entities(tool_body_ptr); + + for(int i = 0; i < tool_shapes.size(); i++) + { + TopoDS_Shape* shape = tool_shapes.get_and_step(); + shape->Nullify(); + delete shape; + } + + if(keep_old) + { + int size = shape_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = shape_list.pop(); + shape->Nullify(); + delete shape; + } + } + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : check_operation +// Member Type: PRIVATE +// Description: check and update the from_shape according to type of the body. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +void OCCModifyEngine::check_operation(TopoDS_Shape& cut_shape, + TopoDS_Shape*& from_shape, //output + CubitBoolean is_volume, + CubitBoolean& has_changed, //output + BRepAlgoAPI_BooleanOperation* op, + CubitBoolean keep_old) const +{ + //compare to see if the from_shape has gotten cut. + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + if(is_volume) + { + GProp_GProps myProps; + BRepGProp::VolumeProperties(*from_shape, myProps); + double orig_mass = myProps.Mass(); + BRepGProp::VolumeProperties(cut_shape, myProps); + double after_mass = myProps.Mass(); + if(fabs(-after_mass + orig_mass) <= tol) + { + has_changed= CUBIT_FALSE; //common is itself + return; + } + + //got cut. Update the entities + if(after_mass < tol) //no common section + cut_shape.Nullify(); + has_changed = CUBIT_TRUE; + TopExp_Explorer Ex; + Ex.Init(*from_shape, TopAbs_SOLID); + TopoDS_Solid old_solid = TopoDS::Solid(Ex.Current()); + OCCLump::update_OCC_entity(old_solid , cut_shape, op); + } + else + { + GProp_GProps myProps; + BRepGProp::SurfaceProperties(*from_shape, myProps); + double orig_mass = myProps.Mass(); + BRepGProp::SurfaceProperties(cut_shape, myProps); + double after_mass = myProps.Mass(); + if(fabs(-after_mass + orig_mass) <= tol) + { + has_changed= CUBIT_FALSE; //common is itself, or not cut + return; + } + //got cut. Update the entities + if(after_mass < tol)//no common section + cut_shape.Nullify(); + has_changed = CUBIT_TRUE; + if(from_shape->TShape()->ShapeType() == TopAbs_SHELL) + { + TopoDS_Shell old_shell = TopoDS::Shell(*from_shape); + OCCShell::update_OCC_entity(old_shell,cut_shape, op); + } + else + { + TopoDS_Face old_face = TopoDS::Face(*from_shape); + OCCSurface::update_OCC_entity(old_face,cut_shape, op); + } + } + if(keep_old) + delete from_shape; + from_shape = new TopoDS_Shape(cut_shape); +} + +//=============================================================================== +// Function : chop +// Member Type: PUBLIC +// Description: chop boolean operation between OCC-based bodies +// bodies has a size() = 2, a blank body and a tool body. +// chops the blank with the tool, returing the body formed +// by subtracting the tool from the blank, and the body formed +// by intersecting the tool with the blank, simultaneously. +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::chop(DLIList<BodySM*>& bodies, + DLIList<BodySM*> &intersectBodies, + DLIList<BodySM*> &outsideBodies, + BodySM*& leftoversBody, + bool keep_old , + bool nonreg) const +{ + //according to Acis chop function, leftoverBody = 0; + leftoversBody = 0; + + //there's no effect of nonreg. keep_old mean if to keep the tool_body + if(bodies.size() != 2) + { + PRINT_WARNING("Chop operation works only on two bodies. Nothing modified\n"); + return CUBIT_FAILURE; + } + + //outsideBodies keeps the surface, curve ids if keep_old is false. + BodySM* blank_body = bodies.get(); + + //copy blank_body for intersect operation, because it will get changed. + DLIList<BodySM*> tool_bodies, from_bodies; + from_bodies.append(blank_body); + BodySM* tool_body = bodies.step_and_get(); + tool_bodies.append(tool_body); + + CubitStatus stat = intersect(tool_body, from_bodies, + intersectBodies, CUBIT_TRUE); + + if(!stat) + return CUBIT_FAILURE; + + stat = subtract(tool_bodies, from_bodies, outsideBodies, + CUBIT_FALSE, keep_old); + + return stat; +} + +//=============================================================================== +// Function : unite +// Member Type: PUBLIC +// Description: unite boolean operation between OCC-based bodies +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::unite(DLIList<BodySM*> &bodies, + DLIList<BodySM*> &newBodies, + bool keep_old) const +{ + if(bodies.size() < 2) + { + newBodies = bodies; + return CUBIT_SUCCESS; + } + //all bodies must have only one lump in order for boolean operation to work. + DLIList<Lump*> lumps; + for (int i = 0; i < bodies.size(); i++) + { + lumps = CAST_TO(bodies.get_and_step(), OCCBody)->lumps(); + if (lumps.size() > 1) + { + PRINT_WARNING("All bodies must have only one lump for boolean operations to work.\n"); + return CUBIT_FAILURE; + } + } + + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + CubitStatus stat = + get_shape_list(bodies, shape_list, is_volume, keep_old); + + if(!stat) + return stat; + + //find a non-sheet body to be the first shape + TopoDS_Shape* first_shape; + CubitBoolean first_is_volume; + if((first_is_volume = is_volume.move_to(CUBIT_TRUE))) + { + int index = is_volume.get_index(); + first_shape = shape_list[index]; + shape_list.remove(first_shape); + is_volume.step(index); + is_volume.remove(); + bodies.step(index); + bodies.remove(); + } + + else + { + first_shape = shape_list.pop(); + bodies.pop(); + } + + int size = shape_list.size(); + for(int i = 0; i < size; i++) + { + TopoDS_Shape* second_shape = shape_list.get_and_step(); + + BRepAlgoAPI_Fuse fuser(*first_shape, *second_shape); + TopoDS_Shape new_shape = fuser.Shape(); + + CubitBoolean has_changed; + check_operation(new_shape, first_shape, first_is_volume, has_changed, &fuser, keep_old); + + check_operation(new_shape,second_shape, is_volume[i], has_changed, &fuser, keep_old); + } + + //ok, we're done with all unites, construct new Body' + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(*first_shape); + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + newBodies.append(bodysm); + } + + //ok, we're done with all unites, delete unnecessaries. + if(keep_old) + { + shape_list.append(first_shape); + int size = shape_list.size(); + for (int i = 0; i < size; i++) + { + TopoDS_Shape* shape = shape_list.pop(); + shape->Nullify(); + delete shape; + } + } + + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::thicken( DLIList<BodySM*>& bodies, + DLIList<BodySM*>& new_bodies, + double depth, + CubitBoolean both) const +{ + PRINT_ERROR("Option not supported for OCC based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : hollow +// Member Type: PUBLIC +// Description: Hollow existing solid body by remove one or several surfaces +// Can only take one body at a time. +// depth > 0, thick body going outside bodies +// depth < 0, thick body going inside bodies +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine::hollow( DLIList<BodySM*>& bodies, + DLIList<Surface*>& surfs_to_remove, + DLIList<BodySM*>& new_bodies, + double depth) const +{ + if(bodies.size() != 1 || surfs_to_remove.size() < 1) + { + PRINT_ERROR("Making thick solid in OCC will take one body and at least one surface at a time.\n"); + return CUBIT_FAILURE; + } + + DLIList<TopoDS_Shape*> shape_list; + DLIList<CubitBoolean> is_volume; + CubitStatus stat = get_shape_list(bodies, shape_list, is_volume, CUBIT_FALSE); + + if(!stat) + return stat; + + if(!is_volume.get())//sheet body + { + PRINT_ERROR("Making thick solid in OCC needs an initial solid body to hollow with.\n"); + return CUBIT_FAILURE; + } + + //make sure the body to be hollowed has only one lump + OCCBody* occ_body = CAST_TO(bodies.get(), OCCBody); + DLIList<Lump*> lumps; + lumps = occ_body->lumps(); + if(lumps.size()!=1) + { + PRINT_ERROR("bodies with more than one lump can't be hollowed to make a thick body.\n"); + return CUBIT_FAILURE; + } + + //make sure surfs_to_remove are all in bodies + DLIList<OCCSurface*> surfaces; + TopTools_ListOfShape face_shapes; + occ_body->get_all_surfaces(surfaces); + for(int i = 0; i < surfs_to_remove.size(); i++) + { + OCCSurface* occ_surf = CAST_TO(surfs_to_remove.get(), OCCSurface); + if(!occ_surf) + continue; + if(!surfaces.is_in_list(occ_surf)) + continue; + TopoDS_Face * face = occ_surf->get_TopoDS_Face(); + face_shapes.Append(*face); + } + + if(face_shapes.IsEmpty()) + { + PRINT_ERROR("The surfaces provided should be from the body to be hollowed.\n"); + return CUBIT_FAILURE; + } + + double tol = 1.e-3; //hard coded for now, can be changed by application + TopoDS_Shape* solid = shape_list.get(); + BRepOffsetAPI_MakeThickSolid hollower(*solid, face_shapes, depth, tol, + BRepOffset_Skin, Standard_False, + Standard_False, GeomAbs_Intersection); + TopoDS_Shape new_shape = hollower.Shape(); + TopoDS_Solid old_solid = TopoDS::Solid(*solid); + OCCLump::update_OCC_entity(old_solid , new_shape, &hollower); + + //ok, we're done with all hollowing, construct new Body' + DLIList<TopologyBridge*> tbs; + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + + for (int i = 0; i< tbs.size(); i++) + { + BodySM* bodysm = CAST_TO(tbs.get_and_step(), BodySM); + if (bodysm) + new_bodies.append(bodysm); + } + + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : flip_normals +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 06/08 +//=============================================================================== +CubitStatus OCCModifyEngine :: flip_normals( DLIList<Surface*>& face_list ) const +{ + DLIList<Surface*> surface_list; + while (face_list.size()) + { + OCCSurface* occ_surface = CAST_TO(face_list.pop(), OCCSurface); + OCCShell* occ_shell = occ_surface->my_shell(); + DLIList<OCCSurface*> surfaces; + surfaces.append(occ_surface); + if(occ_shell) //find all surfaces in face_list that belong to this shell + { + int size = face_list.size(); + for ( int i = 0; i < size; i++) + { + occ_surface = CAST_TO(face_list.get(), OCCSurface); + if(occ_shell == occ_surface->my_shell()) + surfaces.append(CAST_TO(face_list.remove(),OCCSurface)); + else + face_list.step(); + } + + if (!occ_shell->is_sheet()) + { + DLIList<OCCCoFace*> cofaces; + cofaces = occ_shell->cofaces(); + for(int i = 0; i < cofaces.size(); i++) + { + OCCCoFace* coface =cofaces.get_and_step(); + occ_surface = coface->surface(); + if(surfaces.is_in_list(occ_surface)) + { + TopoDS_Face* topoface = occ_surface->get_TopoDS_Face(); + TopAbs_Orientation ori = topoface->Orientation(); + topoface->Orientation(ori == TopAbs_FORWARD ? TopAbs_REVERSED : + TopAbs_FORWARD); + occ_surface->set_TopoDS_Face(*topoface); + coface->set_sense(coface->sense() == CUBIT_FORWARD ? + CUBIT_REVERSED : CUBIT_FORWARD); + surface_list.append(occ_surface); + } + } + } + else //sheet body + { + TopoDS_Face* topoface = occ_surface->get_TopoDS_Face(); + TopAbs_Orientation ori = topoface->Orientation(); + topoface->Orientation(ori == TopAbs_FORWARD ? TopAbs_REVERSED : + TopAbs_FORWARD); + occ_surface->set_TopoDS_Face(*topoface); + surface_list.append(occ_surface); + } + PRINT_INFO( "Modified volume\n" ); + } + else + PRINT_WARNING( "Volume was not modified\n" ); + } + face_list = surface_list; + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : sweep_translational +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 09/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_translational( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + const CubitVector& sweep_vector, + double draft_angle, //in Radius + int draft_type, //RightCorner=1 or RoundCorner =2 + bool switchside,//not used, shell and surfaces are one sided, not like Acis + bool rigid, //not used here, in Acis, it means whether the end surface is + // parallel to the starting surface, or perpendicular to the path + Surface* stop_surf, + BodySM* to_body) const +{ + //in OCC, there's no sweep surface with draft option, this can be done by + //creating draft shell then make solid to achieve. + //while if draft_angle is 0, and stop_surf = 0, to_body = 0 + // directly use sweep functions. + TopoDS_Shape *stop_shape = NULL; + if(stop_surf) + { + OCCSurface* occ_surface = CAST_TO(stop_surf, OCCSurface); + stop_shape = occ_surface->get_TopoDS_Face(); + } + else if(to_body) + { + OCCBody* occ_body = CAST_TO(to_body, OCCBody); + if(occ_body->is_sheet_body()) + stop_shape = occ_body->my_sheet_surface()->get_TopoDS_Face(); + else if(occ_body->shell()) + stop_shape = occ_body->shell()->get_TopoDS_Shell(); + else + stop_shape = occ_body->get_TopoDS_Shape(); + } + + gp_Dir adir(sweep_vector.x(), sweep_vector.y(), sweep_vector.z()); + gp_Vec aVec(sweep_vector.x(), sweep_vector.y(), sweep_vector.z()); + + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, &sweep_vector, toposhape); + if(!stat) + continue; + } + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + } + + DLIList<TopologyBridge*> tbs; + //create the draft or the sweep + if(stop_shape == NULL && draft_angle == 0.) + { + BRepSweep_Prism swept(toposhape, aVec); + TopoDS_Shape new_shape = swept.Shape(); + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + + BRepOffsetAPI_MakeDraft draft(toposhape, adir, draft_angle); + BRepBuilderAPI_TransitionMode Cornertype; + if(draft_type == 1) + Cornertype = BRepBuilderAPI_RightCorner; + else if(draft_type == 2) + Cornertype = BRepBuilderAPI_RoundCorner; + + draft.SetOptions(Cornertype); + if(stop_shape) + draft.Perform(*stop_shape); + else + draft.Perform(sweep_vector.length()); + TopoDS_Shape new_shape = draft.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if(bodysm && surface != NULL) //only gets swept side and original surfaces + { + //get surfaces from the shell body and create a top surface to + //make a swept solid. + OCCShell* occ_shell = CAST_TO(bodysm, OCCBody)->shell(); + if(!occ_shell) + { + PRINT_WARNING("Sweep surface failed inside OCC engine.\n"); + return CUBIT_FAILURE; + } + DLIList<OCCCoFace*> cofaces = occ_shell->cofaces(); + DLIList<Surface*> surface_list; + for(int i = 0; i < cofaces.size(); i++) + surface_list.append(cofaces.get_and_step()->surface()); + + //create the top surface from edges. + DLIList<OCCCoEdge*> coedges; + for(int i = 0; i < surface_list.size(); i++) + CAST_TO(surface_list.get_and_step(), OCCSurface)->get_coedges(coedges); + for(int i = 0; i < coedges.size(); i++) + { + OCCCoEdge* coedge = coedges[i]; + if(coedge == NULL) + continue; + for(int j = i+1; j < coedges.size(); j++) + { + OCCCoEdge* temp_coedge = coedges[j]; + if(temp_coedge == NULL) + continue; + if(coedge->curve() == temp_coedge->curve() && + coedge->sense() != temp_coedge->sense()) + { + coedges.move_to(coedge); + coedges.change_to((OCCCoEdge*)NULL); + coedges.move_to(temp_coedge); + coedges.change_to((OCCCoEdge*)NULL); + } + } + } + coedges.remove_all_with_value(NULL); + assert(coedges.size() > 0); + DLIList<Curve*> curves; + for(int i = 0; i < coedges.size(); i++) + curves.append(coedges.get_and_step()->curve()); + + Surface* surf = make_Surface(PLANE_SURFACE_TYPE, curves); + if(!surf) + surf = make_Surface(BEST_FIT_SURFACE_TYPE, curves); + if(!surf) + { + PRINT_ERROR("Can't calculate for the top surface.\n"); + continue; + } + surface_list.append(surf); + DLIList<BodySM*> bodies; + create_solid_bodies_from_surfs(surface_list, bodies); + + if(bodies.size() == 1) + bodysm = bodies.get(); + else + { + PRINT_WARNING("Sweep surface failed in creating solid.\n"); + return CUBIT_FAILURE; + } + } + if (bodysm) + result_body_list.append(bodysm); + } + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::get_sweepable_toposhape(OCCCurve*& curve, + TopoDS_Shape& toposhape)const +{ + DLIList<OCCLoop*> loops; + loops = curve->loops(); + if( loops.size()) //not a free curve + { + //copy the curve + Curve* c_curve = make_Curve(curve); + if(c_curve) + curve = CAST_TO(c_curve, OCCCurve); + else + { + PRINT_ERROR("Can't copy the curve for sweep.\n"); + return CUBIT_FAILURE; + } + } + TopoDS_Edge *edge = curve->get_TopoDS_Edge( ); + toposhape = BRepBuilderAPI_MakeWire(*edge); + return CUBIT_SUCCESS; +} + +CubitStatus OCCModifyEngine::get_sweepable_toposhape(OCCSurface*& surface, + const CubitVector* sweep_v_p, + TopoDS_Shape& toposhape)const +{ + GeometryEntity* ref_ent = NULL; + //Make copy of the surface if it's not a sheet surface. + Surface* c_surface = NULL; + if(surface != NULL) + { + //check if the surface is sheet body, if not, copy it. + if(surface->my_body() == NULL) //not a sheet body + { + c_surface = make_Surface(surface); + if (c_surface == NULL) + { + PRINT_ERROR("Cannot copy surface in sweep_translational.\n"); + return CUBIT_FAILURE; + } + surface = CAST_TO(c_surface, OCCSurface); + } + + if(sweep_v_p) + { + CubitVector center = surface->center_point(); + CubitVector normal; + surface->closest_point(center,NULL,&normal); + CubitVector sweep_vector = *sweep_v_p; + if(normal % sweep_vector > 0) + { + DLIList<Surface*> surfaces; + surfaces.append(surface); + flip_normals(surfaces); + surface = CAST_TO(surfaces.get(), OCCSurface); + ref_ent = (GeometryEntity *)surface; + } + + else if(normal % sweep_vector == 0) + { + PRINT_ERROR("Sweeping direction should not be on the surface.\n"); + return CUBIT_FAILURE; + } + } + else + ref_ent = (GeometryEntity *)surface; + + if(surface->my_body() != NULL) //sheet body + { + delete surface->my_body(); + delete surface->my_shell(); + delete surface->my_lump(); + surface->set_shell(NULL); + surface->set_lump(NULL); + surface->set_body(NULL); + } + + TopoDS_Shape* toposhape_prt = + OCCQueryEngine::instance()->get_TopoDS_Shape_of_entity(ref_ent); + + if(!toposhape_prt) + { + PRINT_WARNING("GeometryEntity without TopoDS_Shape found.\n"); + return CUBIT_FAILURE; + } + toposhape = *toposhape_prt; + } + return CUBIT_SUCCESS; +} +//=============================================================================== +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_perpendicular( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + double distance, + double draft_angle, + int draft_type, + bool switchside, //has no effect + bool rigid, //has no effect + Surface* stop_surf, + BodySM* to_body) const +{ + //find the vector perpendicular to the ref_ent normal, and sweep_translate + //the 'distance' along this vector + DLIList<GeometryEntity*> edge_list; + CubitVector vec; + for(int i = 0; i < ref_ent_list.size(); i++) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + Surface *face = CAST_TO(ref_ent, Surface); + Curve* edge = CAST_TO(ref_ent, Curve); + DLIList<GeometryEntity*> face_list; + if(face != NULL) + { + OCCSurface* occ_face = CAST_TO(face, OCCSurface); + CubitVector center = occ_face->center_point(); + CubitVector closest_p, unit_normal; + CubitStatus stat = + occ_face->closest_point(center, &closest_p, &unit_normal); + if(stat) + { + vec = distance * unit_normal; + face_list.append(ref_ent); + stat = sweep_translational(face_list, result_body_list, vec, + draft_angle, draft_type, switchside, + rigid, stop_surf, to_body); + } + } + else if (edge != NULL) + { + edge_list.append(ref_ent); + } + } + if(edge_list.size()) + PRINT_ERROR("Curves cannot be swept perpendicularly, please use the vector sweep.\n"); + + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : sweep_rotational +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine:: sweep_rotational( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + const CubitVector& point, + const CubitVector& direction, + double angle, //in radians + int steps, //not used + double draft_angle, //not used + int draft_type, //not used + bool switchside, //not used + bool make_solid, + bool rigid, //not used + Surface* stop_surf, //not used + BodySM* to_body ) const //not used +{ + gp_Dir adir(direction.x(), direction.y(), direction.z()); + gp_Pnt pt = gp_Pnt( point.x(), point.y(), point.z()); + gp_Ax1 axis = gp_Ax1(pt, adir); + + gp_Lin line = gp_Lin(axis); + TopoDS_Edge edge = BRepBuilderAPI_MakeEdge(line); + OCCCurve* acurve = new OCCCurve(&edge); + assert(acurve); + + CubitVector start; + CubitVector end; + + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface or curve for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, (CubitVector*)NULL, toposhape); + if(!stat) + continue; + //only non-intersecting of surface and axis can be swept. + DLIList<CubitVector*> intersect_pts; + OCCQueryEngine::instance()->get_intersections(acurve, surface, + intersect_pts, CUBIT_TRUE); + if(intersect_pts.size() > 0) + { + PRINT_ERROR("Only surfaces with no intersection point with the axis can be revolve-swept.\n"); + continue; + } + } + else if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + //closed curve can't intersect with the axis, while open curve can only + //intersect the axis at the end points. + //only curve not intersecting with axis in curve's middle locations + //can be revolved + DLIList<CubitVector*> intersect_pts; + OCCQueryEngine::instance()->get_intersections(curve, acurve, + intersect_pts, CUBIT_TRUE, CUBIT_TRUE); + if(!toposhape.Closed()) + { + //get start and end points + DLIList<OCCPoint*> point_list; + curve->get_points(point_list); + assert(2 == point_list.size()); + GeometryType type = curve->geometry_type(); + start = point_list.get_and_step()->coordinates(); + end = point_list.get()->coordinates(); + CubitBoolean start_int = CUBIT_FALSE; + CubitBoolean end_int = CUBIT_FALSE; + if(intersect_pts.size() > 0) + { + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + CubitBoolean non_int = CUBIT_FALSE; + for(int i = 0; i < intersect_pts.size(); i++) + { + CubitVector prt = *(intersect_pts.get_and_step()); + if(prt.distance_between(start) > tol && + prt.distance_between(end) > tol) + { + non_int = CUBIT_TRUE; + PRINT_ERROR("Only curves with no intersection point with the axis can be revolve-swept.\n"); + break; + } + else if(prt.distance_between(start) <= tol) + start_int = CUBIT_TRUE; + else if(prt.distance_between(end) <= tol) + end_int = CUBIT_TRUE; + } + if(non_int) + continue; + if(start_int && end_int && type == STRAIGHT_CURVE_TYPE) + { + PRINT_ERROR("Sweep along curve itself is not allowed.\n"); + continue; + } + } + } + else + { + if(intersect_pts.size() > 0) + { + PRINT_ERROR("Only curves with no intersection point with the axis can be revolve-swept.\n"); + continue; + } + } + } + else + { + PRINT_ERROR("Only surface or curve can be revolve-swept.\n"); + continue; + } + TopoDS_Shape new_shape; + DLIList<TopologyBridge*> tbs; + if(make_solid && curve != NULL ) + //giving an open wire and want a solid + { + if(!toposhape.Closed()) + { + //project the start and end points onto the axis + CubitBoolean start_closed = CUBIT_FALSE; + CubitBoolean end_closed = CUBIT_FALSE; + if(acurve->point_containment(start) != CUBIT_PNT_OFF) + start_closed = CUBIT_TRUE; + if(acurve->point_containment(end) != CUBIT_PNT_OFF) + end_closed = CUBIT_TRUE; + CubitVector start_proj, end_proj; + TopoDS_Edge edge1, edge2; + BRepBuilderAPI_MakeWire m_wire; + if(!start_closed) + { + acurve->closest_point(start, start_proj); + gp_Pnt pt1 = gp_Pnt( start.x(), start.y(), start.z()); + gp_Pnt pt2 = gp_Pnt( start_proj.x(), start_proj.y(), start_proj.z()); + edge1 = BRepBuilderAPI_MakeEdge(pt1, pt2); + m_wire.Add(edge1); + m_wire.Add(TopoDS::Wire(toposhape)); + } + else + { + m_wire.Add(TopoDS::Wire(toposhape)); + start_proj = start; + } + + if(!end_closed) + { + acurve->closest_point(end,end_proj); + gp_Pnt pt1 = gp_Pnt( end.x(), end.y(), end.z()); + gp_Pnt pt2 = gp_Pnt( end_proj.x(), end_proj.y(), end_proj.z()); + edge2 = BRepBuilderAPI_MakeEdge(pt1, pt2); + m_wire.Add(edge2); + } + + else + end_proj = end; + + gp_Pnt pt1 = gp_Pnt( end_proj.x(), end_proj.y(), end_proj.z()); + gp_Pnt pt2 = gp_Pnt( start_proj.x(), start_proj.y(), start_proj.z()); + TopoDS_Edge edge3 = BRepBuilderAPI_MakeEdge(pt2, pt1); + m_wire.Add(edge3); + + TopoDS_Wire wire = m_wire.Wire(); + toposhape = BRepBuilderAPI_MakeFace(wire); + } + else //closed + { + TopoDS_Wire wire = TopoDS::Wire(toposhape); + toposhape = BRepBuilderAPI_MakeFace(wire); + } + } + BRepSweep_Revol revol(toposhape, axis, angle); + new_shape = revol.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(new_shape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + OCCQueryEngine::instance()->delete_solid_model_entities(acurve); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : sweep_along_curve +// Member Type: PUBLIC +// Description: The ref_edge_list must provide a list of curves which are +// connected, and making G1 continuous wire. +// Author : Jane Hu +// Date : 10/08 +//=============================================================================== +CubitStatus OCCModifyEngine::sweep_along_curve( + DLIList<GeometryEntity*>& ref_ent_list, + DLIList<BodySM*>& result_body_list, + DLIList<Curve*>& ref_edge_list, + double draft_angle, //only used for straight curve case + int draft_type, //only used for straight curve case + bool rigid, //not used + Surface* stop_surf, //not used + BodySM* to_body) const //not used +{ + //make wire out of ref_edge_list + BRepBuilderAPI_MakeWire awire; + TopTools_ListOfShape L; + OCCCurve* occ_curve = NULL; + GeometryType type; + int num_curve = 0; + for(int i = 0; i < ref_edge_list.size(); i++) + { + Curve* curve = ref_edge_list.get_and_step(); + occ_curve = CAST_TO(curve, OCCCurve); + if(!occ_curve) + continue; + TopoDS_Edge* topoedge = occ_curve->get_TopoDS_Edge( ); + BRepBuilderAPI_Copy api_copy(*topoedge); + TopoDS_Shape newShape = api_copy.ModifiedShape(*topoedge); + L.Append(newShape); + type = occ_curve->geometry_type(); + num_curve++; + } + if(L.IsEmpty()) + { + PRINT_ERROR("There's no valid sweeping path.\n"); + return CUBIT_FAILURE; + } + + if(num_curve == 1 && type == STRAIGHT_CURVE_TYPE && draft_angle != 0.0) + { + DLIList<OCCPoint*> point_list; + occ_curve->get_points(point_list); + CubitVector v1 = point_list.get_and_step()->coordinates(); + CubitVector v2 = point_list.get()->coordinates(); + CubitVector sweep_vector = v2-v1; + return sweep_translational(ref_ent_list,result_body_list,sweep_vector, + draft_angle, draft_type, CUBIT_FALSE, + rigid, stop_surf, to_body); + } + awire.Add(L); + TopoDS_Wire wire; + wire = awire.Wire(); + + BRepTools_WireExplorer it(wire); + int num_edges = 0; + for(; it.More(); it.Next()) + num_edges++; + + BRepLib_FuseEdges fuser(wire); + fuser.SetConcatBSpl(); + fuser.Perform(); + TopoDS_Shape spline = fuser.Shape(); + wire = TopoDS::Wire(spline); + + DLIList<TopologyBridge*> tbs; + for (int i = ref_ent_list.size(); i > 0; i--) + { + GeometryEntity *ref_ent = ref_ent_list.get_and_step(); + //Make copy of the surface or curve for later to build solid. + OCCSurface* surface = CAST_TO(ref_ent, OCCSurface); + OCCCurve* curve = CAST_TO(ref_ent, OCCCurve); + TopoDS_Shape toposhape ; + if(surface != NULL) + { + CubitStatus stat = get_sweepable_toposhape(surface, (CubitVector*)NULL, toposhape); + if(!stat) + continue; + } + else if(curve != NULL) + { + CubitStatus stat = get_sweepable_toposhape(curve, toposhape); + if(!stat) + continue; + } + + //sweep along the wire + BRepOffsetAPI_MakePipe maker(wire, toposhape); + if(!maker.IsDone()) + { + PRINT_ERROR("Can't sweep along the provided curve(s).\n"); + continue; + } + TopoDS_Shape newShape = maker.Shape(); + + tbs += OCCQueryEngine::instance()->populate_topology_bridge(newShape); + assert(tbs.size() == 1); + + BodySM* bodysm = CAST_TO(tbs.get(), BodySM); + if (bodysm) + result_body_list.append(bodysm); + continue; + } + return CUBIT_SUCCESS; +} + +//HEADER- Webcut-related functions + +//=============================================================================== +// Function : webcut +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut(DLIList<BodySM*>& webcut_body_list, + const CubitVector &v1, + const CubitVector &v2, + const CubitVector &v3, + DLIList<BodySM*>& results_list, + bool imprint ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut(DLIList<BodySM*>& /*webcut_body_list*/, + BodySM const* /*tool_body*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_across_translate +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_across_translate( DLIList<BodySM*>& /*body_list*/, + Surface* /*plane_surf1*/, + Surface* /*plane_surf2*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_sheet +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_sheet(DLIList<BodySM*> & /*webcut_body_list*/, + BodySM * /*sheet_body*/, + DLIList<BodySM*> & /*new_bodies*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_extended_surf +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_extended_surf(DLIList<BodySM*> & /*webcut_body_list*/, + Surface * /*extend_from*/, + DLIList<BodySM*> & /*new_bodies*/, + int & /*num_cut*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_cylinder +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_cylinder(DLIList<BodySM*> &webcut_body_list, + double radius, + const CubitVector &axis, + const CubitVector ¢er, + DLIList<BodySM*>& results_list, + bool imprint ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_brick +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_brick( + DLIList<BodySM*>& /*webcut_body_list*/, + const CubitVector &/*center*/, + const CubitVector* /*axes[3]*/, + const CubitVector &/*extension*/, + DLIList<BodySM*> &/*results_list*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_planar_sheet +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_planar_sheet( + DLIList<BodySM*>& /*webcut_body_list*/, + const CubitVector &/*center*/, + const CubitVector* /*axes[2]*/, + double /*width*/, + double /*height*/, + DLIList<BodySM*> &/*results_list*/, + bool /*imprint*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : webcut_with_curve_loop +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::webcut_with_curve_loop( + DLIList<BodySM*> &/*webcut_body_list*/, + DLIList<Curve*> &/*ref_edge_list*/, + DLIList<BodySM*>& /*results_list*/, + bool /*imprint*/) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : section +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 11/08 +//=============================================================================== +CubitStatus OCCModifyEngine::section( DLIList<BodySM*> §ion_body_list, + const CubitVector &point_1, + const CubitVector &point_2, + const CubitVector &point_3, + DLIList<BodySM*>& new_body_list, + bool keep_normal_side, + bool keep_old, + bool keep_both_sides) +{ + if (keep_both_sides == CUBIT_TRUE ) + { + PRINT_ERROR("keeping both sides of section is not implemented.\n"); + return CUBIT_FAILURE; + } + + //Calculate normal of the section plan + CubitVector v1, v2, normal; + v1 = point_2 - point_1; + v2 = point_3 - point_1; + normal = ~(v1 * v2); + if(normal.length() != 1) + { + PRINT_ERROR("The three points are co-linear, and can't be used as a cutting plane.\n"); + return CUBIT_FAILURE; + } + + if(keep_normal_side) + normal *= -1; + + gp_Pnt pt = gp_Pnt( point_1.x(), point_1.y(), point_1.z()); + gp_Dir normal_dir(normal.x(), normal.y(), normal.z()); + gp_Pln plane(pt, normal_dir); + gp_Vec vec(normal_dir); + pt = pt.Translated(vec); + + TopoDS_Face face = BRepBuilderAPI_MakeFace(plane); + TopoDS_Solid solid = BRepPrimAPI_MakeHalfSpace(face, pt); + + DLIList<CubitBoolean> is_tool_volume; + is_tool_volume.append(CUBIT_TRUE); + DLIList<CubitBox*> tool_boxes ; + Bnd_Box box; + BRepBndLib::Add(solid, box); + double min[3], max[3]; + box.Get(min[0], min[1], min[2], max[0], max[1], max[2]); + CubitBox* cBox = new CubitBox(min, max); + + tool_boxes.append(cBox); + DLIList<TopoDS_Shape*> solids; + solids.append(&solid); + CubitStatus stat = do_subtract(section_body_list, solids, is_tool_volume, + &tool_boxes, new_body_list, keep_old) ; + delete cBox; + return stat; +} + +//=============================================================================== +// Function : split_body +// Member Type: PUBLIC +// Description: Splits multiple lumps in one body into separate bodies +// Author : Corey Ernst +// Date : 08/04 +//=============================================================================== +CubitStatus OCCModifyEngine::split_body( BodySM *body_ptr, + DLIList<BodySM*> &new_bodies ) +{ + return CUBIT_SUCCESS; +} + + +//=============================================================================== +// Function : reverse_body +// Member Type: PUBLIC +// Description: Turn body inside-out +// Author : Jason Kraftcheck +// Date : 05/25/04 +//=============================================================================== +CubitStatus OCCModifyEngine::reverse_body( BodySM* body_ptr ) +{ + return CUBIT_SUCCESS; +} + + + +//=============================================================================== +// Function : split_periodic +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::split_periodic( BodySM * /*body_ptr*/, + BodySM *& /*new_body*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : regularize_body +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::regularize_body( BodySM * /*body_ptr*/, + BodySM *& /*new_body_ptr*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : regularize_refentity +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::regularize_entity( GeometryEntity * /*old_entity_ptr*/, + BodySM *& /*new_body_ptr*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : offset_curves +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::offset_curves( DLIList<Curve*>& /*ref_edge_list*/, + DLIList<Curve*>&, + double /*offset_distance*/, + const CubitVector& /*offset_direction*/, + int /*gap_type*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : trim_curve +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +Curve* OCCModifyEngine::trim_curve( Curve* /*trim_curve*/, + const CubitVector& /*trim_vector*/, + const CubitVector& /*keep_vector*/, + bool ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return 0; +} + +//=============================================================================== +// Function : create_body_from_surfs +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 4/22/08 +//=============================================================================== +CubitStatus OCCModifyEngine::create_solid_bodies_from_surfs(DLIList<Surface*> & ref_face_list, + DLIList<BodySM*>& new_bodies, + bool keep_old, + bool heal) const +{ + //keep_old and heal are ignored, always delete old. + //all surfaces should be stand along surface bodies or shell bodies' surface + Lump* lump = make_Lump(ref_face_list); + if (!lump) + return CUBIT_FAILURE; + + new_bodies.append(CAST_TO(lump, OCCLump)->get_body()); + return CUBIT_SUCCESS; +} + +//=============================================================================== +// Function : create_arc_three +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 12/08 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_three( Point* pt1, + Point* pt2, + Point* pt3, + bool full ) +{ + if(!full) + { + CubitVector v2(pt2->coordinates()); + return make_Curve(ARC_CURVE_TYPE,pt1,pt3, &v2, CUBIT_FORWARD); + } + else + { + CubitVector v1(pt1->coordinates()); + CubitVector v2(pt2->coordinates()); + CubitVector v3(pt3->coordinates()); + + gp_Pnt gp_pt1(v1.x(),v1.y(), v1.z()); + gp_Pnt gp_pt2(v2.x(),v2.y(), v2.z()); + gp_Pnt gp_pt3(v3.x(),v3.y(), v3.z()); + + Handle(Geom_Circle) curve_ptr; + curve_ptr = GC_MakeCircle(gp_pt1,gp_pt2,gp_pt3); + + OCCPoint* occ_pt1 = CAST_TO(const_cast<Point*>(pt1),OCCPoint); + TopoDS_Vertex * vt1 = occ_pt1->get_TopoDS_Vertex(); + TopoDS_Edge new_edge = BRepBuilderAPI_MakeEdge(curve_ptr, *vt1, *vt1); + return OCCQueryEngine::instance()->populate_topology_bridge(new_edge); + } +} + +//=============================================================================== +// Function : create_arc_three +// Member Type: PUBLIC +// Description: +// Author : Jane Hu +// Date : 12/08 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_three( Curve* curve1, + Curve* curve2, + Curve* curve3, + bool full ) +{ + OCCCurve* occ_crv1 = CAST_TO(curve1, OCCCurve); + OCCCurve* occ_crv2 = CAST_TO(curve2, OCCCurve); + OCCCurve* occ_crv3 = CAST_TO(curve3, OCCCurve); + GeometryType type1 = occ_crv1->geometry_type(); + GeometryType type2 = occ_crv2->geometry_type(); + GeometryType type3 = occ_crv3->geometry_type(); + if(type1 != STRAIGHT_CURVE_TYPE || type2 != STRAIGHT_CURVE_TYPE || + type3 != STRAIGHT_CURVE_TYPE) + { + PRINT_WARNING("Need three straight curves to calculate incenter.\n"); + return (Curve*) NULL; + } + + //0.check that non of the curves are parallel of each other. + DLIList<CubitVector*> intscts; + CubitVector vt1, vt2, vt3; + CubitBoolean none = CUBIT_FALSE; + OCCQueryEngine::instance()->get_intersections(curve1, curve2, intscts,none,none); + vt1 = *intscts.get(); + intscts.clean_out(); + OCCQueryEngine::instance()->get_intersections(curve2,curve3, intscts,none,none); + vt2 = *intscts.get(); + intscts.clean_out(); + OCCQueryEngine::instance()->get_intersections(curve3, curve1, intscts,none,none); + vt3 = *intscts.get(); + + double u, u11, u12, u21, u22, u31, u32; + u12 = occ_crv1->u_from_position(vt1); + u11 = occ_crv1->u_from_position(vt3); + if(u12 < u11) + { + u = u12; + u12 = u11; + u11 = u; + } + u22 = occ_crv2->u_from_position(vt1); + u21 = occ_crv2->u_from_position(vt2); + if(u22 < u21) + { + u = u22; + u22 = u21; + u21 = u; + } + u32 = occ_crv3->u_from_position(vt2); + u31 = occ_crv3->u_from_position(vt3); + if(u32 < u31) + { + u = u32; + u32 = u31; + u31 = u; + } + CubitVector tangent1, tangent2, tangent3; + occ_crv1->get_tangent(vt1, tangent1); + occ_crv2->get_tangent(vt2, tangent2); + occ_crv3->get_tangent(vt3, tangent3); + + CubitVector normal1 = tangent1 * tangent2; + CubitVector normal2 = tangent2 * tangent3; + CubitVector normal3 = tangent3 * tangent1; + double tol = OCCQueryEngine::instance()->get_sme_resabs_tolerance(); + if( normal1.length()< tol || normal2.length()< tol || + normal3.length() < tol ) + { + PRINT_WARNING("Three curves must be able to form a triangle.\n"); + return (Curve*) NULL; + } + + //normals must parallel to each other, meaning all curves must be on + //the same plane. + normal1.normalize(); + normal2.normalize(); + normal3.normalize(); + + CubitVector parallel1 = normal1 * normal2; + CubitVector parallel2 = normal2 * normal3; + CubitVector parallel3 = normal3 * normal1; + if(parallel1.length() > tol || parallel2.length() > tol || + parallel3.length() > tol) + { + PRINT_WARNING("Three curves must be able to form a triangle.\n"); + return (Curve*) NULL; + } + //1.find the angle between each of the two curves + double angle1, angle2, angle3; + angle1 = tangent1.interior_angle(tangent2); + angle2 = tangent2.interior_angle(tangent3); + angle3 = tangent3.interior_angle(tangent1); + + //2.create curves to bisection each of the angle passing through the + // vertices of the triangle + CubitVector t_curve11 = + vectorRotate(angle1/2.0, normal1, tangent1); + t_curve11.normalize(); + CubitVector p11 = vt1+t_curve11; + + CubitVector t_curve12 = + vectorRotate(90.0 - angle1/2.0, -normal1, tangent1); + t_curve12.normalize(); + CubitVector p12 = vt1 + t_curve12; + + CubitVector t_curve21 = + vectorRotate(angle2/2.0, normal2, tangent2); + t_curve21.normalize(); + CubitVector p21 = vt2 + t_curve21; + + CubitVector t_curve22 = + vectorRotate(90.0 - angle2/2.0, -normal2, tangent2); + t_curve22.normalize(); + CubitVector p22 = vt2 + t_curve22; + + CubitVector t_curve31 = + vectorRotate(angle3/2.0, normal3, tangent3); + t_curve31.normalize(); + CubitVector p31 = vt3 + t_curve31; + + CubitVector t_curve32 = + vectorRotate(90.0 - angle3/2.0, -normal3, tangent3); + t_curve32.normalize(); + CubitVector p32 = vt3 + t_curve32; + + //3. find the intersection of each of the bisection curve with the third curve + CubitVector int_pt1, int_pt2, int_pt3; + intscts.clean_out(); + OCCQueryEngine::instance()->get_intersections(curve3, vt1, p11, intscts,none,none); + CubitVector int_pt = *intscts.pop(); + u = occ_crv3->u_from_position (int_pt); + if(u >= u31-tol && u <= u32+tol) //found intersection point + int_pt1 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve3, vt1, p12, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv3->u_from_position (int_pt); + assert(u >= u31-tol && u <= u32+tol); + int_pt1 = int_pt; + } + + OCCQueryEngine::instance()->get_intersections(curve1, vt2, p21, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv1->u_from_position (int_pt); + if(u >= u11-tol && u <= u12+tol) //found intersection point + int_pt2 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve1, vt2, p22, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv1->u_from_position (int_pt); + assert(u >= u11-tol && u <= u12+tol); + int_pt2 = int_pt; + } + + OCCQueryEngine::instance()->get_intersections(curve2, vt3, p31, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv2->u_from_position (int_pt); + if(u >= u21-tol && u <= u22+tol) //found intersection point + int_pt3 = int_pt; + else + { + OCCQueryEngine::instance()->get_intersections(curve2, vt3, p32, intscts,none,none); + int_pt = *intscts.pop(); + u = occ_crv2->u_from_position (int_pt); + assert(u >= u21-tol && u <= u22+tol); + int_pt3 = int_pt; + } + //4. use the 3 intersection points to find the arc or circle. + OCCPoint occ_p1(int_pt1); + OCCPoint occ_p2(int_pt2); + OCCPoint occ_p3(int_pt3); + return create_arc_three(&occ_p1, &occ_p2, &occ_p3, full); +} + +//=============================================================================== +// Function : create_arc_center_edge +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +Curve* OCCModifyEngine::create_arc_center_edge( Point* /*ref_vertex1*/, + Point* /*ref_vertex2*/, + Point* /*ref_vertex3*/, + const CubitVector& /*normal*/, + double /*radius*/, + bool /*full*/ ) +{ + return NULL; +} + +CubitStatus +OCCModifyEngine::create_curve_combine( DLIList<Curve*>& curve_list, + Curve *&new_curve_ptr ) +{ + PRINT_ERROR("Curve combine is not implemented for facet based models\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_gqe +// Member Type: PUBLIC +// Description: get the facet geometry query engince instance pointer +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +GeometryQueryEngine *OCCModifyEngine::get_gqe() +{ + return OCCQueryEngine::instance(); +} + +//=============================================================================== +// Function : is_modify_engine +// Member Type: PUBLIC +// Description: return CUBIT_TRUE if the tb_ptr belongs to this modify engine +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitBoolean OCCModifyEngine::is_modify_engine(const TopologyBridge *tb_ptr) const +{ + return tb_ptr->get_geometry_query_engine() == OCCQueryEngine::instance(); +} + +//=============================================================================== +// Function : get_offset_intersections +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_offset_intersections( Curve* /*ref_edge1*/, + Curve* /*ref_edge2*/, + DLIList<CubitVector*>& /*intersection_list*/, + double /*offset*/, + CubitBoolean /*ext_first*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_offset_intersections +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_offset_intersections( Curve* /*ref_edge_ptr*/, + Surface* /*ref_face_ptr*/, + DLIList<CubitVector*> & /*intersection_list*/, + double /*offset*/, + CubitBoolean /*ext_surf*/ ) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : surface_intersection +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::surface_intersection( Surface * /*surface1_ptr*/, + Surface * /*surface2_ptr*/, + DLIList<Curve*> &/*inter_graph*/, + const double /*tol*/) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//=============================================================================== +// Function : get_mid_plane +// Member Type: PUBLIC +// Description: +// Author : John Fowler +// Date : 10/02 +//=============================================================================== +CubitStatus OCCModifyEngine::get_mid_plane( const CubitVector & /*point_1*/, + const CubitVector & /*point_2*/, + const CubitVector & /*point_3*/, + BodySM * /*body_to_trim_to*/, + BodySM *& /*midplane_body*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_spheric_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_conic_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::get_toric_mid_surface( Surface* surface_ptr1, + Surface* surface_ptr2, + BodySM* body_to_trim_to, + BodySM*& midsurface_body ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_chamfer +// Member Type: PUBLIC +// Description: Chamfer curves on solid bodies. The left and right offsets are +// with respect to the curve direction. If the given right offset +// is negative, the left offset is used. Users can preview to +// clarify the meaning of left and right. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_chamfer( DLIList<Curve*> & /*curve_list*/, + double /*left_offset*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + double /*right_offset*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_chamfer +// Member Type: PUBLIC +// Description: Chamfer vertices on solid or sheet bodies. On a solid body +// there can be up to 3 offsets; on a sheet body up to 2 offsets. +// The offsets are in the direction of the supplied edges. If +// multiple vertices are supplied, only one offset value is +// allowed and the edges are not used. +// Author : +// Date : +//============================================================================= +CubitStatus +OCCModifyEngine::tweak_chamfer( DLIList<Point*> & /*point_list*/, + double /*offset1*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + Curve * /*edge1*/, + double /*offset2*/, + Curve * /*edge2*/, + double /*offset3*/, + Curve * /*edge3*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given curves on solid +// bodies. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_fillet( DLIList<Curve*> & /*curve_list*/, + double /*radius*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given curves on a solid +// body. The fillet has a variable radius from the start to the +// end of the curve. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_fillet( Curve * /*curve_ptr*/, + double /*start_radius*/, + double /*end_radius*/, + BodySM *& /*new_bodysm_ptr*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_fillet +// Member Type: PUBLIC +// Description: Create a round fillet (or blend) at the given vertices on sheet +// bodies. +// Author : +// Date : +//============================================================================= +CubitStatus +OCCModifyEngine::tweak_fillet( DLIList<Point*> & /*ref_vertex_list*/, + double /*radius*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean /*preview*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_move +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes along a vector. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_move( DLIList<Surface*> & /*surface_list*/, + const CubitVector & /*delta*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/ , + CubitBoolean show_preview) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_move +// Member Type: PUBLIC +// Description: Tweak specified curves of a sheet body along a vector. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_move( DLIList<Curve*> & /*curve_list*/, + const CubitVector & /*delta*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_offset +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes by offsetting +// those faces by the offset distance. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_offset( DLIList<Surface*> & /*surface_list*/, + double /*offset_distance*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_offset +// Member Type: PUBLIC +// Description: Tweak specified curves of a sheet body or bodies by offsetting +// those curves by the offset distance. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_offset( DLIList<Curve*> & /*curve_list*/, + double /*offset_distance*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_remove +// Member Type: PUBLIC +// Description: Function to remove surfaces from a body and then extend the +// remaining surfaces to fill the gap or hole. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_remove( DLIList<Surface*> & /*surface_list*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*extend_adjoining*/, + CubitBoolean /*keep_surface*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_remove +// Member Type: PUBLIC +// Description: Function to remove curves from a sheet body and then extend the +// remaining curves or fill the gap or hole. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_remove( DLIList<Curve*> & /*curve_list*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified faces of a volume or volumes up to a target +// surface. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Surface*> & /*surface_list*/, + DLIList<Surface*> & , + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean /*reverse_flg*/, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified edges of a surface or set of surfaces (in sheet +// bodies) up to a target surface. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/, + DLIList<Surface*> & /*target_surfs*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean , + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//============================================================================= +// Function : tweak_target +// Member Type: PUBLIC +// Description: Tweak specified edges of a sheet body or bodies up to a target +// curve that is part of a sheet body. The target is a surface +// created by thickening the owning surface of the target curve. +// Author : +// Date : +//============================================================================= +CubitStatus OCCModifyEngine::tweak_target( DLIList<Curve*> & /*curve_list*/, + DLIList<Curve*> & /*target_curve_ptr*/, + DLIList<BodySM*> & /*new_bodysm_list*/, + CubitBoolean, + CubitBoolean /*keep_old_body*/, + CubitBoolean show_preview ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::remove_curve_slivers( BodySM* /*body*/, + double /*lengthlimit*/ ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a net surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_net_surface( DLIList<Surface*>& /*ref_face_list*/, + BodySM *& /*new_body*/, + DLIList<DLIList<CubitVector*>*> & /*vec_lists_u*/, + DLIList<DLIList<CubitVector*>*> & /*vec_lists_v*/, + double /*net_tol*/, + CubitBoolean /*heal*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a net surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_net_surface( DLIList<Curve*>& /*u_curves*/, + DLIList<Curve*>& /*v_curves*/, + BodySM *& /*new_body*/, + double /*net_tol*/, + CubitBoolean /*heal*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates an offset surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_offset_surface( Surface* /*ref_face_ptr*/, + BodySM*& /*new_body*/, + double /*offset_distance*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates an offset body. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_offset_body( BodySM* body_ptr, + BodySM*& new_bodysm, + double offset_distance ) const +{ + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a skin surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_skin_surface( DLIList<Curve*>& /*curves*/, + BodySM*& /*new_body*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a body from lofting surfaces. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::loft_surfaces( Surface * /*face1*/, + const double & /*takeoff1*/, + Surface * /*face2*/, + const double & /*takeoff2*/, + BodySM*& /*new_body*/, + CubitBoolean /*arc_length_option*/, + CubitBoolean /*twist_option*/, + CubitBoolean /*align_direction*/, + CubitBoolean /*perpendicular*/, + CubitBoolean /*simplify_option*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a body by lofting surfaces between bodies. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::loft_surfaces_to_body( Surface * /*face1*/, + const double & /*takeoff1*/, + Surface * /*face2*/, + const double & /*takeoff2*/, + BodySM*& /*new_body*/, + CubitBoolean /*arc_length_option*/, + CubitBoolean /*twist_option*/, + CubitBoolean /*align_direction*/, + CubitBoolean /*perpendicular*/, + CubitBoolean /*simplify_option*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_surface( DLIList<CubitVector*>& /*vec_list*/, + BodySM *& /*new_body*/, + Surface * /*ref_face_ptr*/, + CubitBoolean /*project_points*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +//================================================================================ +// Description: Creates a weld surface. +// Author : Tyronne Lim +// Date : 08/18/03 +//================================================================================ +CubitStatus OCCModifyEngine::create_weld_surface( CubitVector & /*root*/, + Surface * /*ref_face1*/, + double /*leg1*/, + Surface * /*ref_face2*/, + double /*leg2*/, + BodySM *& /*new_body*/ ) const +{ + PRINT_ERROR("Function not implemented in this engine.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_surfaces( + DLIList<BodySM*> &blank_bodies, + DLIList<Surface*> &surfaces, + const CubitVector& sweep_vector, + bool sweep_perp, + bool through_all, + bool outward, + bool up_to_next, + Surface *stop_surf, + Curve *curve_to_sweep_along, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_curves( + DLIList<BodySM*> &blank_bodies, + DLIList<Curve*> &curves, + const CubitVector& sweep_vector, + bool through_all, + Surface *stop_surf, + Curve *curve_to_sweep_along, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_surfaces_rotated( + DLIList<BodySM*> &blank_bodies, + DLIList<Surface*> &surfaces, + const CubitVector &point, + const CubitVector &sweep_axis, + double angle, + Surface *stop_surf, + bool up_to_next, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::webcut_with_sweep_curves_rotated( + DLIList<BodySM*> &blank_bodies, + DLIList<Curve*> &curves, + const CubitVector &point, + const CubitVector &sweep_axis, + double angle, + Surface *stop_surf, + DLIList<BodySM*> &results_list, + CubitBoolean imprint) +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +CubitStatus OCCModifyEngine::scale( BodySM *&body, const CubitVector& factors ) +{ + return OCCQueryEngine::instance()->scale( body, factors ); +} + +CubitStatus OCCModifyEngine::tolerant_imprint( DLIList<BodySM*> &bodies_in, + DLIList<BodySM*> &new_bodies, + DLIList<TopologyBridge*>*, + DLIList<TopologyBridge*>* ) const +{ + PRINT_ERROR("Option not supported for mesh based geometry.\n"); + return CUBIT_FAILURE; +} + +// EOF