def extrusion(event=None): # Make a box Box = BRepPrimAPI_MakeBox(400., 250., 300.) S = Box.Shape() # Choose the first Face of the box F = next(TopologyExplorer(S).faces()) surf = BRep_Tool_Surface(F) # Make a plane from this face Pl = Handle_Geom_Plane_DownCast(surf) Pln = Pl.GetObject() # Get the normal of this plane. This will be the direction of extrusion. D = Pln.Axis().Direction() # Inverse normal D.Reverse() # Create the 2D planar sketch MW = BRepBuilderAPI_MakeWire() p1 = gp_Pnt2d(200., -100.) p2 = gp_Pnt2d(100., -100.) aline = GCE2d_MakeLine(p1, p2).Value() Edge1 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge1.Edge()) p1 = p2 p2 = gp_Pnt2d(100., -200.) aline = GCE2d_MakeLine(p1, p2).Value() Edge2 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge2.Edge()) p1 = p2 p2 = gp_Pnt2d(200., -200.) aline = GCE2d_MakeLine(p1, p2).Value() Edge3 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge3.Edge()) p1 = p2 p2 = gp_Pnt2d(200., -100.) aline = GCE2d_MakeLine(p1, p2).Value() Edge4 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge4.Edge()) # Build Face from Wire. NB: a face is required to generate a solid. MKF = BRepBuilderAPI_MakeFace() MKF.Init(surf, False, 1e-6) MKF.Add(MW.Wire()) FP = MKF.Face() breplib_BuildCurves3d(FP) MKP = BRepFeat_MakePrism(S, FP, F, D, False, True) MKP.Perform(200.) # TODO MKP completes, seeing a split operation but no extrusion assert MKP.IsDone() res1 = MKP.Shape() display.EraseAll() display.DisplayColoredShape(res1, 'BLUE') display.FitAll()
def makeLines(): global aEdge1, aEdge2, aEdge3 # Make type 'Geom_TrimmedCurve' from type 'gp_Pnt' aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4) aSegment1 = GC_MakeSegment(aPnt1, aPnt2) aSegment2 = GC_MakeSegment(aPnt4, aPnt5) # Make type 'TopoDS_Edge' from type 'Geom_TrimmedCurve' aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value()) aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value()) aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value()) return (aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge())
def makeLines(event=None): global aEdge1, aEdge2, aEdge3 aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4) aSegment1 = GC_MakeSegment(aPnt1, aPnt2) aSegment2 = GC_MakeSegment(aPnt4, aPnt5) # Display lines aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value()) aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value()) aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value()) display.DisplayColoredShape(aEdge1.Edge(), 'RED') display.DisplayColoredShape(aEdge2.Edge(), 'RED') display.DisplayColoredShape(aEdge3.Edge(), 'RED') display.Repaint() win.statusBar().showMessage('Make lines complete')
def edge(event=None): # The blud edge BlueEdge = BRepBuilderAPI_MakeEdge(gp_Pnt(-80, -50, -20), gp_Pnt(-30, -60, -60)) V1 = BRepBuilderAPI_MakeVertex(gp_Pnt(-20, 10, -30)) V2 = BRepBuilderAPI_MakeVertex(gp_Pnt(10, 7, -25)) YellowEdge = BRepBuilderAPI_MakeEdge(V1.Vertex(), V2.Vertex()) #The white edge line = gp_Lin(gp_Ax1(gp_Pnt(10, 10, 10), gp_Dir(1, 0, 0))) WhiteEdge = BRepBuilderAPI_MakeEdge(line, -20, 10) #The red edge Elips = gp_Elips(gp_Ax2(gp_Pnt(10, 0, 0), gp_Dir(1, 1, 1)), 60, 30) RedEdge = BRepBuilderAPI_MakeEdge(Elips, 0, math.pi/2) # The green edge and the both extreme vertex P1 = gp_Pnt(-15, 200, 10) P2 = gp_Pnt(5, 204, 0) P3 = gp_Pnt(15, 200, 0) P4 = gp_Pnt(-15, 20, 15) P5 = gp_Pnt(-5, 20, 0) P6 = gp_Pnt(15, 20, 0) P7 = gp_Pnt(24, 120, 0) P8 = gp_Pnt(-24, 120, 12.5) array = TColgp_Array1OfPnt(1, 8) array.SetValue(1, P1) array.SetValue(2, P2) array.SetValue(3, P3) array.SetValue(4, P4) array.SetValue(5, P5) array.SetValue(6, P6) array.SetValue(7, P7) array.SetValue(8, P8) curve = Geom_BezierCurve(array) ME = BRepBuilderAPI_MakeEdge(curve) GreenEdge = ME V3 = ME.Vertex1() V4 = ME.Vertex2() display.DisplayColoredShape(BlueEdge.Edge(), 'BLUE') display.DisplayShape(V1.Vertex()) display.DisplayShape(V2.Vertex()) display.DisplayColoredShape(WhiteEdge.Edge(), 'WHITE') display.DisplayColoredShape(YellowEdge.Edge(), 'YELLOW') display.DisplayColoredShape(RedEdge.Edge(), 'RED') display.DisplayColoredShape(GreenEdge.Edge(), 'GREEN') display.DisplayShape(V3) display.DisplayShape(V4, update=True)
def face_mesh_triangle(comp=TopoDS_Shape(), isR=0.1, thA=0.1): # Mesh the shape BRepMesh_IncrementalMesh(comp, isR, True, thA, True) bild1 = BRep_Builder() comp1 = TopoDS_Compound() bild1.MakeCompound(comp1) bt = BRep_Tool() ex = TopExp_Explorer(comp, TopAbs_FACE) while ex.More(): face = topods_Face(ex.Current()) location = TopLoc_Location() facing = bt.Triangulation(face, location) tab = facing.Nodes() tri = facing.Triangles() print(facing.NbTriangles(), facing.NbNodes()) for i in range(1, facing.NbTriangles() + 1): trian = tri.Value(i) index1, index2, index3 = trian.Get() for j in range(1, 4): if j == 1: m = index1 n = index2 elif j == 2: n = index3 elif j == 3: m = index2 me = BRepBuilderAPI_MakeEdge(tab.Value(m), tab.Value(n)) if me.IsDone(): bild1.Add(comp1, me.Edge()) ex.Next() return comp1
def write_edge(points_edge, topo_edge): """ Method to recreate an Edge associated to a geometric curve after the modification of its points. :param points_edge: the deformed points array. :param topo_edge: the Edge to be modified :return: Edge (Shape) :rtype: TopoDS_Edge """ # convert Edge to Geom B-spline Curve nurbs_converter = BRepBuilderAPI_NurbsConvert(topo_edge) nurbs_converter.Perform(topo_edge) nurbs_curve = nurbs_converter.Shape() topo_curve = topods_Edge(nurbs_curve) h_geomcurve = BRep_Tool.Curve(topo_curve)[0] h_bcurve = geomconvert_CurveToBSplineCurve(h_geomcurve) bspline_edge_curve = h_bcurve # Edge geometric properties nb_cpt = bspline_edge_curve.NbPoles() # check consistency if points_edge.shape[0] != nb_cpt: raise ValueError("Input control points do not have not have the " "same number as the geometric edge!") else: for i in range(1, nb_cpt + 1): cpt = points_edge[i - 1] bspline_edge_curve.SetPole(i, gp_Pnt(cpt[0], cpt[1], cpt[2])) new_edge = BRepBuilderAPI_MakeEdge(bspline_edge_curve) return new_edge.Edge()
def trimedge(lbound, ubound, occedge): """ This function trims the OCCedge according to the specified lower and upper bound. Parameters ---------- lbound : float The lower bound of the OCCedge. ubound : float The upper bound of the OCCedge. occedge : OCCedge The edge to be trimmed. Returns ------- trimmed edge : OCCedge The trimmed OCCedge. """ adaptor = BRepAdaptor_Curve(occedge) tr = Geom_TrimmedCurve(adaptor.Curve().Curve(), lbound, ubound) tr.SetTrim(lbound, ubound) bspline_handle = geomconvert_CurveToBSplineCurve(tr.BasisCurve()) tr_edge = BRepBuilderAPI_MakeEdge(bspline_handle) return tr_edge.Edge()
def CancelEvent(self): if self.myBSplineCurveAction == BSplineCurveAction.Nothing: pass elif self.myBSplineCurveAction == BSplineCurveAction.Input_1Point: pass elif self.myBSplineCurveAction == BSplineCurveAction.Input_2Point: self.bspline.RemoveLabel() del self.bspline elif self.myBSplineCurveAction == BSplineCurveAction.Input_OtherPoints: if len(self.Poles) <= 3: self.bspline.RemoveLabel() del self.bspline self.myContext.Remove(self.myRubberAIS_Shape, True) # remove the last pole del self.Poles2d[-1] del self.Poles[-1] self.Multi, self.Knots = setQuasiUniformKnots( len(self.Poles), self.myDegree) self.CreateBspline() ME = BRepBuilderAPI_MakeEdge(self.myGeom_BSplineCurve) if ME.IsDone(): self.curEdge = ME.Edge() self.closeBSpline() self.IndexCounter -= 1 self.myBSplineCurveAction = BSplineCurveAction.Nothing
def MouseMoveEvent(self, thePnt2d: gp_Pnt2d, buttons, modifiers): self.curPnt2d = self.myAnalyserSnap.MouseMove(thePnt2d) if self.myBSplineCurveAction == BSplineCurveAction.Nothing: pass elif self.myBSplineCurveAction == BSplineCurveAction.Input_1Point: pass elif self.myBSplineCurveAction == BSplineCurveAction.Input_2Point: # self.mySecondPoint.SetPnt(elclib.To3d(self.curCoordinateSystem.Ax2(), self.curPnt2d)) # self.myRubberLine.SetPoints(self.myFirstPoint, self.mySecondPoint) # self.myContext.Redisplay(self.myRubberLine, True) pass elif self.myBSplineCurveAction == BSplineCurveAction.Input_OtherPoints: self.myGeom2d_BSplineCurve.SetPole(self.IndexCounter, self.curPnt2d) self.mySecondPoint.SetPnt( elclib.To3d(self.curCoordinateSystem.Ax2(), self.curPnt2d)) self.myGeom_BSplineCurve.SetPole(self.IndexCounter, self.mySecondPoint.Pnt()) ME = BRepBuilderAPI_MakeEdge(self.myGeom_BSplineCurve) if ME.IsDone(): self.curEdge = ME.Edge() self.myRubberAIS_Shape.Set(self.curEdge) self.myContext.Redisplay(self.myRubberAIS_Shape, True) else: self.IndexCounter -= 1
def occ_triangle_mesh(event=None): # # Mesh the shape # BRepMesh_IncrementalMesh(aShape, 0.1) builder = BRep_Builder() Comp = TopoDS_Compound() builder.MakeCompound(Comp) ex = TopExp_Explorer(aShape, TopAbs_FACE) while ex.More(): F = topods_Face(ex.Current()) L = TopLoc_Location() facing = (BRep_Tool().Triangulation(F, L)) tab = facing.Nodes() tri = facing.Triangles() for i in range(1, facing.NbTriangles() + 1): trian = tri.Value(i) #print trian index1, index2, index3 = trian.Get() for j in range(1, 4): if j == 1: M = index1 N = index2 elif j == 2: N = index3 elif j == 3: M = index2 ME = BRepBuilderAPI_MakeEdge(tab.Value(M), tab.Value(N)) if ME.IsDone(): builder.Add(Comp, ME.Edge()) ex.Next() display.DisplayShape(Comp, update=True)
def __init__(self, controlpoints: numpy, knots: numpy, m: int, degree: int, periodic: bool): super().__init__() self.edge = TopAbs_EDGE array = [] for pnt in controlpoints: p = OccPoint(pnt) array.append(p.Value()) poles = point_list_to_TColgp_Array1OfPnt(array) # Normalise the knots and find multiplicities multp = OCCWrapper.OccMultiplicities(knots) uknots = multp.knots() multiplicity = multp.multiplcity() knotvector = TColStd_Array1OfReal(1, len(uknots)) i = 1 for v in uknots: knotvector.SetValue(i, v) i = i + 1 mult = TColStd_Array1OfInteger(1, len(multiplicity)) i = 1 for m in multiplicity: mult.SetValue(i, int(m)) i = i + 1 mknurbs = Geom_BSplineCurve(poles, knotvector, mult, degree, periodic) mkedge = BRepBuilderAPI_MakeEdge(mknurbs) if not mkedge.IsDone(): OCCWrapper.OccError(type(self), mkedge) else: self.done = True self.edge = mkedge.Edge() return
def generate_tool_targets(self): ba = BRepAdaptor_Curve(self.helix_edge) u_min = ba.FirstParameter() u_max = ba.LastParameter() u_step = 0.1 u_now = u_min while u_now <= u_max: v_contact = gp_Vec(ba.Value(u_now).XYZ()) if self.inside: # cut inside v_contact_to_ball_center = -gp_Vec(v_contact.X(),v_contact.Y(),0).Normalized()*self.ball_radius else: # cut outside v_contact_to_ball_center = gp_Vec(v_contact.X(),v_contact.Y(),0).Normalized()*self.ball_radius trsf = gp_Trsf() trsf.SetRotation(gp_Ax1(gp_Pnt(0,0,0),gp_Dir(0,0,1)),pi/2) v_rotation_axis = v_contact_to_ball_center.Transformed(trsf) trsf.SetRotation(gp_Ax1(gp_Pnt(0,0,0),gp_Dir(v_rotation_axis.XYZ())),radians(self.cutting_angle)) v_ball_center_to_tool_tip = gp_Vec(0,0,-self.ball_radius) v_ball_center_to_tool_tip.Transform(trsf) v_tool_tip = v_contact+v_contact_to_ball_center+v_ball_center_to_tool_tip v_tool_orientation = - v_ball_center_to_tool_tip.Normalized() * (0.500+1e-8) if self.create_target_vis_edges: me = BRepBuilderAPI_MakeEdge(gp_Pnt(v_tool_tip.XYZ()),gp_Pnt((v_tool_tip+v_tool_orientation).XYZ())) self.target_edges.append(me.Edge()) I = v_tool_tip.X() / 1000 J = v_tool_tip.Y() / 1000 K = v_tool_tip.Z() / 1000 U = v_tool_orientation.X() V = v_tool_orientation.Y() W = v_tool_orientation.Z() x,y,z,a,b = self.ikSolver.solve((I,J,K,U,V,W),1e-6,False) x += self.output_offset[0] y += self.output_offset[1] z += self.output_offset[2] a += self.output_offset[3] b += self.output_offset[4] if self.v_previous_contact_point: cut_distance = (v_contact - self.v_previous_contact_point).Magnitude() f = self.feedrate / cut_distance self.gcode += "G01 X{:.6f} Y{:.6f} Z{:.6f} A{:.6f} B{:.6f} F{:.6f}\n".format(x,y,z,a,b,f) else: f = 0 self.gcode += "G0 X{:.6f} Y{:.6f} Z{:.6f} A{:.6f} B{:.6f}\n".format(x,y,z,a,b) self.v_previous_contact_point = v_contact print(x,y,z,a,b) if u_now == u_max: break u_next = u_now + u_step if u_next > u_max: u_next = u_max u_now = u_next
def __init__(self, p1, p2): # Build p1 = CheckGeom.to_point(p1) p2 = CheckGeom.to_point(p2) builder = BRepBuilderAPI_MakeEdge(p1, p2) self._e = Edge(builder.Edge()) self._v1 = Vertex(builder.Vertex1()) self._v2 = Vertex(builder.Vertex2())
def makeSqProfile(self, size): # points and segments need to be in CW sequence to get W pointing along Z p1 = gp_Pnt2d(-size, size) p2 = gp_Pnt2d(size, size) p3 = gp_Pnt2d(size, -size) p4 = gp_Pnt2d(-size, -size) seg1 = GCE2d_MakeSegment(p1, p2) seg2 = GCE2d_MakeSegment(p2, p3) seg3 = GCE2d_MakeSegment(p3, p4) seg4 = GCE2d_MakeSegment(p4, p1) e1 = BRepBuilderAPI_MakeEdge(seg1.Value(), self.plane) e2 = BRepBuilderAPI_MakeEdge(seg2.Value(), self.plane) e3 = BRepBuilderAPI_MakeEdge(seg3.Value(), self.plane) e4 = BRepBuilderAPI_MakeEdge(seg4.Value(), self.plane) aWire = BRepBuilderAPI_MakeWire(e1.Edge(), e2.Edge(), e3.Edge(), e4.Edge()) myWireProfile = aWire.Wire() return myWireProfile # TopoDS_Wire
def holes_in_face(): aPlane = gp_Pln() print(type(gp_Pln())) print(type(gp_XOY())) aCircle1 = gp_Circ(gp_XOY(), 1.0) aCircle2 = gp_Circ(gp_XOY(), 1.0) aCircle3 = gp_Circ(gp_XOY(), 1.0) aCircle1.SetLocation(gp_Pnt(3.0, 3.0, 0.0)) aCircle2.SetLocation(gp_Pnt(7.0, 3.0, 0.0)) aCircle3.SetLocation(gp_Pnt(3.0, 7.0, 0.0)) anEdgeMaker1 = BRepBuilderAPI_MakeEdge(aCircle1) anEdgeMaker2 = BRepBuilderAPI_MakeEdge(aCircle2) anEdgeMaker3 = BRepBuilderAPI_MakeEdge(aCircle3) aWireMaker1 = BRepBuilderAPI_MakeWire(anEdgeMaker1.Edge()) aWireMaker2 = BRepBuilderAPI_MakeWire(anEdgeMaker2.Edge()) aWireMaker3 = BRepBuilderAPI_MakeWire(anEdgeMaker3.Edge()) aFaceMaker = BRepBuilderAPI_MakeFace(aPlane, 0.0, 10.0, 0.0, 10.0) if aWireMaker1.IsDone(): aWire1 = aWireMaker1.Wire() aWire1.Reverse() # Makes this a hole in outer profile aFaceMaker.Add(aWire1) if aWireMaker2.IsDone(): aWire2 = aWireMaker2.Wire() aWire2.Reverse() # Makes this a hole in outer profile aFaceMaker.Add(aWire2) if aWireMaker3.IsDone(): aWire3 = aWireMaker3.Wire() aWire3.Reverse() # Makes this a hole in outer profile aFaceMaker.Add(aWire3) if not aFaceMaker.IsDone(): raise AssertionError("shape not Done.") return aFaceMaker.Shape()
def spline_from_polyline(pol): from OCC.Extend.ShapeFactory import point_list_to_TColgp_Array1OfPnt, make_face from OCC.Core.GeomAPI import GeomAPI_PointsToBSpline array = [] for p in pol: array.append(gp_Pnt(p[0], p[1], p[2])) pt_list1 = point_list_to_TColgp_Array1OfPnt(array) SPL1 = GeomAPI_PointsToBSpline(pt_list1).Curve() SPL1 = GeomAPI_PointsToBSpline(pt_list1) edge = BRepBuilderAPI_MakeEdge(SPL1.Curve()) wire = BRepBuilderAPI_MakeWire(edge.Edge()) return edge.Shape(), wire
def __init__(self, p1: numpy, p2: numpy): super().__init__() self.done = False self.edge = None gp1 = gp_Pnt(p1[0], p1[1], p1[2]) gp2 = gp_Pnt(p2[0], p2[1], p2[2]) edge = BRepBuilderAPI_MakeEdge(gp1, gp2) if not edge.IsDone(): OCCWrapper.OccError('OccEdge', edge) else: self.done = True self.edge = edge.Edge()
def circ(self, cntr, rad, constr=False): """Create a construction circle """ cx, cy = cntr cntrPt = gp_Pnt(cx, cy, 0) ax2 = gp_Ax2(cntrPt, gp_Dir(0, 0, 1)) geomCirc = Geom_Circle(ax2, rad) geomCirc.Transform(self.Trsf) if constr: self.ccircList.append(geomCirc) else: edge = BRepBuilderAPI_MakeEdge(Geom_Curve(geomCirc)) self.wire = BRepBuilderAPI_MakeWire(edge.Edge()).Wire() self.wireList.append(self.wire)
def Compute(self): # self.myGeometry = Geom_SurfaceOfRevolution(self.myCurve, self.myRevolveAxis) # face = BRepBuilderAPI_MakeFace() # face.Init(self.myGeometry, True, 1.0e-6) # face.Build() profile = self.myCurve.GetGeometry() axis = self.myRevolveAxis.GetGeometry().Position() edge = BRepBuilderAPI_MakeEdge(profile) shape = BRepPrimAPI_MakeRevol(edge.Edge(), axis, math.radians(self.myAngle)).Shape() self.myAIS_InteractiveObject = AIS_Shape(shape) self.myContext.Display(self.myAIS_InteractiveObject, True) self.SetCenter(shape) self.InitClippingPlane()
def CancelEvent(self): if self.myBezierCurveAction == BezierCurveAction.Nothing: pass elif self.myBezierCurveAction == BezierCurveAction.Input_1Point: pass elif self.myBezierCurveAction == BezierCurveAction.Input_2Point: # self.myContext.Remove(self.myRubberLine, True) self.bezier_curve.RemoveDisplay() elif self.myBezierCurveAction == BezierCurveAction.Input_OtherPoints: self.myGeom2d_BezierCurve.RemovePole(self.IndexCounter) self.myGeom_BezierCurve.RemovePole(self.IndexCounter) ME = BRepBuilderAPI_MakeEdge(self.myGeom_BezierCurve, self.myFirstgp_Pnt, self.tempPnt) if ME.IsDone(): self.curEdge = ME.Edge() self.IndexCounter -= 1 self.CloseBezierCurve() self.myBezierCurveAction = BezierCurveAction.Nothing
def simple_mesh(): # # Create the shape # theBox = BRepPrimAPI_MakeBox(200, 60, 60).Shape() theSphere = BRepPrimAPI_MakeSphere(gp_Pnt(100, 20, 20), 80).Shape() shape = BRepAlgoAPI_Fuse(theSphere, theBox).Shape() # # Mesh the shape # BRepMesh_IncrementalMesh(shape, 0.8) builder = BRep_Builder() comp = TopoDS_Compound() builder.MakeCompound(comp) bt = BRep_Tool() ex = TopExp_Explorer(shape, TopAbs_FACE) while ex.More(): face = topods_Face(ex.Current()) location = TopLoc_Location() facing = (bt.Triangulation(face, location)).GetObject() tab = facing.Nodes() tri = facing.Triangles() for i in range(1, facing.NbTriangles() + 1): trian = tri.Value(i) index1, index2, index3 = trian.Get() for j in range(1, 4): if j == 1: m = index1 n = index2 elif j == 2: n = index3 elif j == 3: m = index2 me = BRepBuilderAPI_MakeEdge(tab.Value(m), tab.Value(n)) if me.IsDone(): builder.Add(comp, me.Edge()) ex.Next() display.EraseAll() display.DisplayShape(shape) display.DisplayShape(comp, update=True)
def __init__(self, p1: numpy, p2: numpy, p3: numpy): # p1: StartPoint # p2: EndPoint # p3: IntermediatePoint super().__init__() self.edge = TopAbs_EDGE gp1 = OccPoint(p1) gp2 = OccPoint(p2) gp3 = OccPoint(p3) mkarc = GC_MakeArcOfCircle( gp1.Value(), gp3.Value(), gp2.Value()) # Sequence: StartPoint, IntermediatePoint, EndPoint if not mkarc.IsDone(): OCCWrapper.OccError(mkarc.Error()) else: mkedge = BRepBuilderAPI_MakeEdge(mkarc.Value()) if not mkedge.IsDone(): OCCWrapper.OccError(mkedge.Error()) else: self.done = True self.edge = mkedge.Edge() return
def wire_2_bsplinecurve_edge(occwire): """ This function covnerts an OCCwire to a bspline OCCedge. Parameters ---------- occwire : OCCwire The OCCwire to be converted. Returns ------- converted bspline edge : OCCedge The converted OCCedge. """ adaptor = BRepAdaptor_CompCurve(occwire) hadap = BRepAdaptor_HCompCurve(adaptor) from OCC.Core.Approx import Approx_Curve3d from OCC.Core.GeomAbs import GeomAbs_C2 approx = Approx_Curve3d(hadap, 1e-06, GeomAbs_C2, 10000, 12) bspline_handle = approx.Curve() occedge = BRepBuilderAPI_MakeEdge(bspline_handle) return occedge.Edge()
def project_edge_on_face(occedge, occface): """ This function projects an OCCedge towards the OCCface. #TODO: figure out if it is a faceplane or just the face. Parameters ---------- occedge : OCCedge The edge to be projected. occface : OCCface The face to be projected on. Returns ------- Projected edge : OCCedge The projected edge on the face. """ fc = face.Face(occface) projected_curve = fc.project_curve(occedge) curve_edge = BRepBuilderAPI_MakeEdge(projected_curve) return curve_edge.Edge()
def startBottle(startOnly=True): # minus the neck fillet, shelling & threads partName = "Bottle-start" # The points we'll use to create the profile of the bottle's body aPnt1 = gp_Pnt(-width / 2.0, 0, 0) aPnt2 = gp_Pnt(-width / 2.0, -thickness / 4.0, 0) aPnt3 = gp_Pnt(0, -thickness / 2.0, 0) aPnt4 = gp_Pnt(width / 2.0, -thickness / 4.0, 0) aPnt5 = gp_Pnt(width / 2.0, 0, 0) aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4) aSegment1 = GC_MakeSegment(aPnt1, aPnt2) aSegment2 = GC_MakeSegment(aPnt4, aPnt5) # Could also construct the line edges directly using the points # instead of the resulting line. aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value()) aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value()) aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value()) # Create a wire out of the edges aWire = BRepBuilderAPI_MakeWire(aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge()) # Quick way to specify the X axis xAxis = gp_OX() # Set up the mirror aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) # Apply the mirror transformation aBRespTrsf = BRepBuilderAPI_Transform(aWire.Wire(), aTrsf) # Get the mirrored shape back out of the transformation # and convert back to a wire aMirroredShape = aBRespTrsf.Shape() # A wire instead of a generic shape now aMirroredWire = topods.Wire(aMirroredShape) # Combine the two constituent wires mkWire = BRepBuilderAPI_MakeWire() mkWire.Add(aWire.Wire()) mkWire.Add(aMirroredWire) myWireProfile = mkWire.Wire() # The face that we'll sweep to make the prism myFaceProfile = BRepBuilderAPI_MakeFace(myWireProfile) # We want to sweep the face along the Z axis to the height aPrismVec = gp_Vec(0, 0, height) myBody = BRepPrimAPI_MakePrism(myFaceProfile.Face(), aPrismVec) # Add fillets to all edges through the explorer mkFillet = BRepFilletAPI_MakeFillet(myBody.Shape()) anEdgeExplorer = TopExp_Explorer(myBody.Shape(), TopAbs_EDGE) while anEdgeExplorer.More(): anEdge = topods.Edge(anEdgeExplorer.Current()) mkFillet.Add(thickness / 12.0, anEdge) anEdgeExplorer.Next() myBody = mkFillet.Shape() # Create the neck of the bottle neckLocation = gp_Pnt(0, 0, height) neckAxis = gp_DZ() neckAx2 = gp_Ax2(neckLocation, neckAxis) myNeckRadius = thickness / 4.0 myNeckHeight = height / 10.0 mkCylinder = BRepPrimAPI_MakeCylinder(neckAx2, myNeckRadius, myNeckHeight) myBody = BRepAlgoAPI_Fuse(myBody, mkCylinder.Shape()) if startOnly: # quit here uid = win.getNewPartUID(myBody.Shape(), name=partName) win.redraw() return partName = "Bottle-complete" # Our goal is to find the highest Z face and remove it faceToRemove = None zMax = -1 # We have to work our way through all the faces to find the highest Z face aFaceExplorer = TopExp_Explorer(myBody.Shape(), TopAbs_FACE) while aFaceExplorer.More(): aFace = topods.Face(aFaceExplorer.Current()) if face_is_plane(aFace): aPlane = geom_plane_from_face(aFace) # We want the highest Z face, so compare this to the previous faces aPnt = aPlane.Location() aZ = aPnt.Z() if aZ > zMax: zMax = aZ faceToRemove = aFace aFaceExplorer.Next() facesToRemove = TopTools_ListOfShape() facesToRemove.Append(faceToRemove) myBody = BRepOffsetAPI_MakeThickSolid(myBody.Shape(), facesToRemove, -thickness / 50.0, 0.001) # Set up our surfaces for the threading on the neck neckAx2_Ax3 = gp_Ax3(neckLocation, gp_DZ()) aCyl1 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 0.99) aCyl2 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 1.05) # Set up the curves for the threads on the bottle's neck aPnt = gp_Pnt2d(2.0 * math.pi, myNeckHeight / 2.0) aDir = gp_Dir2d(2.0 * math.pi, myNeckHeight / 4.0) anAx2d = gp_Ax2d(aPnt, aDir) aMajor = 2.0 * math.pi aMinor = myNeckHeight / 10.0 anEllipse1 = Geom2d_Ellipse(anAx2d, aMajor, aMinor) anEllipse2 = Geom2d_Ellipse(anAx2d, aMajor, aMinor / 4.0) anArc1 = Geom2d_TrimmedCurve(anEllipse1, 0, math.pi) anArc2 = Geom2d_TrimmedCurve(anEllipse2, 0, math.pi) anEllipsePnt1 = anEllipse1.Value(0) anEllipsePnt2 = anEllipse1.Value(math.pi) aSegment = GCE2d_MakeSegment(anEllipsePnt1, anEllipsePnt2) # Build edges and wires for threading anEdge1OnSurf1 = BRepBuilderAPI_MakeEdge(anArc1, aCyl1) anEdge2OnSurf1 = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCyl1) anEdge1OnSurf2 = BRepBuilderAPI_MakeEdge(anArc2, aCyl2) anEdge2OnSurf2 = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCyl2) threadingWire1 = BRepBuilderAPI_MakeWire(anEdge1OnSurf1.Edge(), anEdge2OnSurf1.Edge()) threadingWire2 = BRepBuilderAPI_MakeWire(anEdge1OnSurf2.Edge(), anEdge2OnSurf2.Edge()) # Compute the 3D representations of the edges/wires breplib.BuildCurves3d(threadingWire1.Shape()) breplib.BuildCurves3d(threadingWire2.Shape()) # Create the surfaces of the threading aTool = BRepOffsetAPI_ThruSections(True) aTool.AddWire(threadingWire1.Wire()) aTool.AddWire(threadingWire2.Wire()) aTool.CheckCompatibility(False) myThreading = aTool.Shape() # Build the resulting compound aRes = TopoDS_Compound() aBuilder = BRep_Builder() aBuilder.MakeCompound(aRes) aBuilder.Add(aRes, myBody.Shape()) aBuilder.Add(aRes, myThreading) uid = win.getNewPartUID(aRes, name=partName) win.redraw()
def face(): p1 = gp_Pnt() p2 = gp_Pnt() p3 = gp_Pnt() p4 = gp_Pnt() p5 = gp_Pnt() p6 = gp_Pnt() # The white Face sphere = gp_Sphere(gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)), 150) green_face = BRepBuilderAPI_MakeFace(sphere, 0.1, 0.7, 0.2, 0.9) # The red face p1.SetCoord(-15, 200, 10) p2.SetCoord(5, 204, 0) p3.SetCoord(15, 200, 0) p4.SetCoord(-15, 20, 15) p5.SetCoord(-5, 20, 0) p6.SetCoord(15, 20, 35) array = TColgp_Array2OfPnt(1, 3, 1, 2) array.SetValue(1, 1, p1) array.SetValue(2, 1, p2) array.SetValue(3, 1, p3) array.SetValue(1, 2, p4) array.SetValue(2, 2, p5) array.SetValue(3, 2, p6) curve = GeomAPI_PointsToBSplineSurface(array, 3, 8, GeomAbs_C2, 0.001).Surface() red_face = BRepBuilderAPI_MakeFace(curve, 1e-6) #The brown face circle = gp_Circ(gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)), 80) Edge1 = BRepBuilderAPI_MakeEdge(circle, 0, math.pi) Edge2 = BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, -80), gp_Pnt(0, -10, 40)) Edge3 = BRepBuilderAPI_MakeEdge(gp_Pnt(0, -10, 40), gp_Pnt(0, 0, 80)) ##TopoDS_Wire YellowWire MW1 = BRepBuilderAPI_MakeWire(Edge1.Edge(), Edge2.Edge(), Edge3.Edge()) assert MW1.IsDone() yellow_wire = MW1.Wire() brown_face = BRepBuilderAPI_MakeFace(yellow_wire) #The pink face p1.SetCoord(35, -200, 40) p2.SetCoord(50, -204, 30) p3.SetCoord(65, -200, 30) p4.SetCoord(35, -20, 45) p5.SetCoord(45, -20, 30) p6.SetCoord(65, -20, 65) array2 = TColgp_Array2OfPnt(1, 3, 1, 2) array2.SetValue(1, 1, p1) array2.SetValue(2, 1, p2) array2.SetValue(3, 1, p3) array2.SetValue(1, 2, p4) array2.SetValue(2, 2, p5) array2.SetValue(3, 2, p6) BSplineSurf = GeomAPI_PointsToBSplineSurface(array2, 3, 8, GeomAbs_C2, 0.001) aFace = BRepBuilderAPI_MakeFace(BSplineSurf.Surface(), 1e-6).Face() ## ##//2d lines P12d = gp_Pnt2d(0.9, 0.1) P22d = gp_Pnt2d(0.2, 0.7) P32d = gp_Pnt2d(0.02, 0.1) ## line1 = Geom2d_Line(P12d, gp_Dir2d((0.2 - 0.9), (0.7 - 0.1))) line2 = Geom2d_Line(P22d, gp_Dir2d((0.02 - 0.2), (0.1 - 0.7))) line3 = Geom2d_Line(P32d, gp_Dir2d((0.9 - 0.02), (0.1 - 0.1))) ## ##//Edges are on the BSpline surface Edge1 = BRepBuilderAPI_MakeEdge(line1, BSplineSurf.Surface(), 0, P12d.Distance(P22d)).Edge() Edge2 = BRepBuilderAPI_MakeEdge(line2, BSplineSurf.Surface(), 0, P22d.Distance(P32d)).Edge() Edge3 = BRepBuilderAPI_MakeEdge(line3, BSplineSurf.Surface(), 0, P32d.Distance(P12d)).Edge() ## Wire1 = BRepBuilderAPI_MakeWire(Edge1, Edge2, Edge3).Wire() Wire1.Reverse() pink_face = BRepBuilderAPI_MakeFace(aFace, Wire1).Face() breplib_BuildCurves3d(pink_face) display.DisplayColoredShape(green_face.Face(), 'GREEN') display.DisplayColoredShape(red_face.Face(), 'RED') display.DisplayColoredShape(pink_face, Quantity_Color(Quantity_NOC_PINK)) display.DisplayColoredShape(brown_face.Face(), 'BLUE') display.DisplayColoredShape(yellow_wire, 'YELLOW', update=True)
def make_edge(*args): edge = BRepBuilderAPI_MakeEdge(*args) result = edge.Edge() return result
def __init__(self, crv): # Build builder = BRepBuilderAPI_MakeEdge(crv.object) self._e = Edge(builder.Edge()) self._v1 = Vertex(builder.Vertex1()) self._v2 = Vertex(builder.Vertex2())
aPnt2 = gp_Pnt(-width / 2.0, -thickness / 4.0, 0) aPnt3 = gp_Pnt(0, -thickness / 2.0, 0) aPnt4 = gp_Pnt(width / 2.0, -thickness / 4.0, 0) aPnt5 = gp_Pnt(width / 2.0, 0, 0) aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4) aSegment1 = GC_MakeSegment(aPnt1, aPnt2) aSegment2 = GC_MakeSegment(aPnt4, aPnt5) # Could also construct the line edges directly using the points instead of the resulting line aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value()) aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value()) aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value()) # Create a wire out of the edges aWire = BRepBuilderAPI_MakeWire(aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge()) # Quick way to specify the X axis xAxis = gp_OX() # Set up the mirror aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) # Apply the mirror transformation aBRespTrsf = BRepBuilderAPI_Transform(aWire.Wire(), aTrsf) # Get the mirrored shape back out of the transformation and convert back to a wire aMirroredShape = aBRespTrsf.Shape() # A wire instead of a generic shape now
def map(self, tcrv): mk = BRepBuilderAPI_MakeEdge(tcrv.Curve2(), self.Surface()) edge = mk.Edge() breplib.BuildCurves3d(edge) return Shape(edge)