def bisect_lineline(event=None): display.EraseAll() li1 = gp_Lin2d(gp_Pnt2d(), gp_Dir2d(1, 0)) li2 = gp_Lin2d(gp_Pnt2d(), gp_Dir2d(0, 1)) bi = GccAna_Lin2dBisec(li1, li2) bi_li1 = bi.ThisSolution(1) bi_li2 = bi.ThisSolution(2) for i in [li1, li2]: display.DisplayShape(make_edge2d(i)) for i in [bi_li1, bi_li2]: display.DisplayColoredShape(make_edge2d(i), 'BLUE') display.FitAll()
def SetPoints(self, p1: gp_Pnt2d, p2: gp_Pnt2d): if p1.IsEqual(p2, 0) == False: self.SetDirection(gp_Dir2d(gp_Vec2d(p1, p2))) self.SetLocation(p1) self.StartPnt = p1 self.EndPnt = p2 return True else: return False
def bisect_crvcrv(event=None): display.EraseAll() ax = gp_Ax22d(gp_Pnt2d(), gp_Dir2d(1, 0), gp_Dir2d(0, -1)) circ = gp_Circ2d(ax, 5) crv1 = GCE2d_MakeCircle(circ).Value() edg1 = make_edge2d(crv1, -1.0, 1.0) display.DisplayColoredShape(edg1, 'BLUE') p1 = gp_Pnt2d(-10, 0) p2 = gp_Pnt2d(-10, 10) crv2 = GCE2d_MakeLine(p1, p2).Value() edg2 = make_edge2d(crv2, -10.0, 10.0) display.DisplayColoredShape(edg2, 'GREEN') bi = Bisector_BisecCC(crv1, crv2, 50, -5, gp_Pnt2d(0, 0)) crv_bi = bi.Curve(1) edg3 = make_edge2d(crv_bi, -1.0, 1.0) display.DisplayColoredShape(edg3, 'RED') display.FitAll()
def bisect_linecircle(event=None): display.EraseAll() ci1 = gp_Circ2d(gp_Ax22d(), 10000) li1 = gp_Lin2d(gp_Pnt2d(2000000, 20), gp_Dir2d(0, 1)) bi = GccAna_CircLin2dBisec(ci1, li1) assert bi.IsDone() bisec = bi.ThisSolution(1) pb = bisec.Parabola() display.DisplayShape([make_edge2d(ci1), make_edge2d(li1)]) display.DisplayColoredShape(make_edge2d(pb), 'BLUE') display.FitAll()
def test_parabola(self): '''Test: parabola''' # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2., 3.) D = gp_Dir2d(4., 5.) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True)
def test_parabola(self): """Test: parabola""" # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2.0, 3.0) D = gp_Dir2d(4.0, 5.0) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() self.assertIsInstance(gParabola, Geom2d_Parabola) aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) self.assertIsNotNone(aTrimmedCurve) self.assertFalse(aTrimmedCurve is None)
def test_parabola(self): '''Test: parabola''' # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2., 3.) D = gp_Dir2d(4., 5.) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() self.assertIsInstance(gParabola, Geom2d_Parabola) aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) self.assertIsNotNone(aTrimmedCurve) self.assertFalse(aTrimmedCurve.IsNull())
def parabola(event=None): # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola a_pnt = gp_Pnt2d(2, 3) a_dir = gp_Dir2d(4, 5) an_ax = gp_Ax22d(a_pnt, a_dir, True) para = gp_Parab2d(an_ax, 6) display.DisplayShape(a_pnt) display.DisplayMessage(a_pnt, "P") aParabola = GCE2d_MakeParabola(para) gParabola = aParabola.Value() aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) display.DisplayShape(aTrimmedCurve, update=True)
def makeHelixOnCyl(self): bas = BRepAdaptor_Surface(self.face) cyl = bas.Cylinder() delta_v = bas.LastVParameter() - bas.FirstVParameter() v_final = bas.LastVParameter() dv_du = self.pitch / (2*pi) l = delta_v / sin(atan(dv_du)) aLine2d = gp_Lin2d(gp_Pnt2d(bas.FirstUParameter(),bas.FirstVParameter()), gp_Dir2d(1,dv_du)) if not self.reverse_helix: aSegment = GCE2d_MakeSegment(aLine2d, 0.0, l) else: aSegment = GCE2d_MakeSegment(aLine2d, l, 0.0) helix_edge = BRepBuilderAPI_MakeEdge(aSegment.Value(), Geom_CylindricalSurface(cyl)).Edge() #self.aLine2d = aLine2d #self.aSegment = aSegment self.helix_edge = helix_edge return helix_edge
def brepfeat_prism(event=None): box = BRepPrimAPI_MakeBox(400, 250, 300).Shape() faces = TopologyExplorer(box).faces() for i in range(5): face = next(faces) srf = BRep_Tool_Surface(face) c = gp_Circ2d(gp_Ax2d(gp_Pnt2d(200, 130), gp_Dir2d(1, 0)), 75) circle = Geom2d_Circle(c) wire = BRepBuilderAPI_MakeWire() wire.Add(BRepBuilderAPI_MakeEdge(circle, srf, 0., pi).Edge()) wire.Add(BRepBuilderAPI_MakeEdge(circle, srf, pi, 2. * pi).Edge()) wire.Build() display.DisplayShape(wire.Wire()) mkf = BRepBuilderAPI_MakeFace() mkf.Init(srf, False, 1e-6) mkf.Add(wire.Wire()) mkf.Build() new_face = mkf.Face() breplib_BuildCurves3d(new_face) display.DisplayShape(new_face) prism = BRepFeat_MakeDPrism(box, mkf.Face(), face, 100, True, True) prism.Perform(400) assert prism.IsDone() display.EraseAll() display.DisplayShape(prism.Shape()) display.DisplayColoredShape(wire.Wire(), 'RED') display.FitAll()
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()
##the Free Software Foundation, either version 3 of the License, or ##(at your option) any later version. ## ##pythonOCC is distributed in the hope that it will be useful, ##but WITHOUT ANY WARRANTY; without even the implied warranty of ##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ##GNU Lesser General Public License for more details. ## ##You should have received a copy of the GNU Lesser General Public License ##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. from math import pi from OCC.Core.gp import gp_Pnt2d, gp_XOY, gp_Lin2d, gp_Ax3, gp_Dir2d from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeEdge from OCC.Core.Geom import Geom_CylindricalSurface from OCC.Core.GCE2d import GCE2d_MakeSegment from OCC.Display.WebGl import threejs_renderer # First build a helix aCylinder = Geom_CylindricalSurface(gp_Ax3(gp_XOY()), 6.0) aLine2d = gp_Lin2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(1.0, 1.0)) aSegment = GCE2d_MakeSegment(aLine2d, 0.0, pi * 2.0) helix_edge = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCylinder, 0.0, 6.0 * pi).Edge() display = threejs_renderer.ThreejsRenderer() display.DisplayShape(helix_edge, color=(1, 0, 0), line_width=1.) display.render()
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)
facesToRemove = TopTools_ListOfShape() facesToRemove.Append(aFace) myBody_step3 = BRepOffsetAPI_MakeThickSolid(myBody_step2.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)
from OCC.Core.gp import gp_Lin2d, gp_Pnt2d, gp_Dir2d from OCC.Display.SimpleGui import init_display # from core_geometry_utils import make_edge2d from OCC.Extend.ShapeFactory import make_edge2d display, start_display, add_menu, add_function_to_menu = init_display() # Creating 2d points p1 = gp_Pnt2d(2., 3.) p2 = gp_Pnt2d(2., 5.) display.DisplayShape(p1) display.DisplayShape(p2, update=True) # Creating a 2d line requires: a point and a direction d1 = gp_Dir2d(1., 1.) l1 = gp_Lin2d(p1, d1) display.DisplayShape(make_edge2d(l1), update=True)
def MiddlePnt(self): return elclib.Value((self.myLastParam + self.myFirstParam) / 2, gp_Circ2d()) def CheckParam(self): while self.myFirstParam > 2 * M_PI: self.myFirstParam -= 2 * M_PI while self.myLastParam > 2 * M_PI or self.myLastParam - self.myFirstParam > 2 * M_PI: self.myLastParam -= 2 * M_PI while self.myFirstParam > self.myLastParam: self.myLastParam += 2 * M_PI class Circle(Geom_Circle): def __init__(self, circle): super(Circle, self).__init__(circle) circle = gp_Circ2d() circle.SetRadius(10) circle.SetXAxis(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0))) arc = Geom2d_Arc(circle) arc.SetParam(gp_Pnt2d(2, 0), gp_Pnt2d(2, 1), gp_Pnt2d(2, 5)) tempGcc_Circ2d3Tan = Geom2dGcc_Circ2d3Tan(gp_Pnt2d(2, 0), gp_Pnt2d(2, 1), gp_Pnt2d(2, 5), 1.0e-10) geom_circle = Circle(tempGcc_Circ2d3Tan.ThisSolution(1)) ais_circle = AIS_Circle(geom_circle) display, start_display, add_menu, add_function_to_menu = init_display() display.Context.Display(ais_circle, False) start_display()
def build_tooth(): base_center = gp_Pnt2d(pitch_circle_radius + (tooth_radius - roller_radius), 0) base_circle = gp_Circ2d(gp_Ax2d(base_center, gp_Dir2d()), tooth_radius) trimmed_base = GCE2d_MakeArcOfCircle(base_circle, M_PI - (roller_contact_angle / 2.), M_PI).Value() trimmed_base.Reverse() # just a trick p0 = trimmed_base.StartPoint() p1 = trimmed_base.EndPoint() # Determine the center of the profile circle x_distance = cos(roller_contact_angle / 2.) * (profile_radius + tooth_radius) y_distance = sin(roller_contact_angle / 2.) * (profile_radius + tooth_radius) profile_center = gp_Pnt2d(pitch_circle_radius - x_distance, y_distance) # Construct the profile circle gp_Circ2d profile_circle = gp_Circ2d(gp_Ax2d(profile_center, gp_Dir2d()), profile_center.Distance(p1)) geom_profile_circle = GCE2d_MakeCircle(profile_circle).Value() # Construct the outer circle gp_Circ2d outer_circle = gp_Circ2d(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d()), top_radius) geom_outer_circle = GCE2d_MakeCircle(outer_circle).Value() inter = Geom2dAPI_InterCurveCurve(geom_profile_circle, geom_outer_circle) num_points = inter.NbPoints() assert isinstance(p1, gp_Pnt2d) if num_points == 2: if p1.Distance(inter.Point(1)) < p1.Distance(inter.Point(2)): p2 = inter.Point(1) else: p2 = inter.Point(2) elif num_points == 1: p2 = inter.Point(1) else: sys.exit(-1) # Trim the profile circle and mirror trimmed_profile = GCE2d_MakeArcOfCircle(profile_circle, p1, p2).Value() # Calculate the outermost point p3 = gp_Pnt2d(cos(tooth_angle / 2.) * top_radius, sin(tooth_angle / 2.) * top_radius) # and use it to create the third arc trimmed_outer = GCE2d_MakeArcOfCircle(outer_circle, p2, p3).Value() # Mirror and reverse the three arcs mirror_axis = gp_Ax2d(gp_Origin2d(), gp_DX2d().Rotated(tooth_angle / 2.)) mirror_base = Geom2d_TrimmedCurve.DownCast(trimmed_base.Copy()) mirror_profile = Geom2d_TrimmedCurve.DownCast(trimmed_profile.Copy()) mirror_outer = Geom2d_TrimmedCurve.DownCast(trimmed_outer.Copy()) mirror_base.Mirror(mirror_axis) mirror_profile.Mirror(mirror_axis) mirror_outer.Mirror(mirror_axis) mirror_base.Reverse() mirror_profile.Reverse() mirror_outer.Reverse() # Replace the two outer arcs with a single one outer_start = trimmed_outer.StartPoint() outer_mid = trimmed_outer.EndPoint() outer_end = mirror_outer.EndPoint() outer_arc = GCE2d_MakeArcOfCircle(outer_start, outer_mid, outer_end).Value() # Create an arc for the inside of the wedge inner_circle = gp_Circ2d(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d()), top_radius - roller_diameter) inner_start = gp_Pnt2d(top_radius - roller_diameter, 0) inner_arc = GCE2d_MakeArcOfCircle(inner_circle, inner_start, tooth_angle).Value() inner_arc.Reverse() # Convert the 2D arcs and two extra lines to 3D edges plane = gp_Pln(gp_Origin(), gp_DZ()) arc1 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_base, plane)).Edge() arc2 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_profile, plane)).Edge() arc3 = BRepBuilderAPI_MakeEdge(geomapi_To3d(outer_arc, plane)).Edge() arc4 = BRepBuilderAPI_MakeEdge(geomapi_To3d(mirror_profile, plane)).Edge() arc5 = BRepBuilderAPI_MakeEdge(geomapi_To3d(mirror_base, plane)).Edge() p4 = mirror_base.EndPoint() p5 = inner_arc.StartPoint() lin1 = BRepBuilderAPI_MakeEdge(gp_Pnt(p4.X(), p4.Y(), 0), gp_Pnt(p5.X(), p5.Y(), 0)).Edge() arc6 = BRepBuilderAPI_MakeEdge(geomapi_To3d(inner_arc, plane)).Edge() p6 = inner_arc.EndPoint() lin2 = BRepBuilderAPI_MakeEdge(gp_Pnt(p6.X(), p6.Y(), 0), gp_Pnt(p0.X(), p0.Y(), 0)).Edge() wire = BRepBuilderAPI_MakeWire(arc1) wire.Add(arc2) wire.Add(arc3) wire.Add(arc4) wire.Add(arc5) wire.Add(lin1) wire.Add(arc6) wire.Add(lin2) face = BRepBuilderAPI_MakeFace(wire.Wire()) wedge = BRepPrimAPI_MakePrism(face.Shape(), gp_Vec(0.0, 0.0, thickness)) return wedge.Shape()
def convert_circ_to_geom2dCirc(self, circ): (cx, cy), r = circ return Geom2d_Circle( gp_Circ2d(gp_Ax2d(gp_Pnt2d(cx, cy), gp_Dir2d(1, 0)), r))
def _helix(r, h, step=None, pitch=None, angle=0, left=False): radius = r height = h if pitch: pitch = math.sin(pitch) * 2 * math.pi * r else: pitch = step if pitch < precision_Confusion(): raise Exception("Pitch of helix too small") if height < precision_Confusion(): raise Exception("Height of helix too small") cylAx2 = gp_Ax2(gp_Pnt(0.0, 0.0, 0.0), gp_DZ()) if abs(angle) < precision_Confusion(): # Cylindrical helix if radius < precision_Confusion(): raise Exception("Radius of helix too small") surf = Geom_CylindricalSurface(gp_Ax3(cylAx2), radius) isCylinder = True else: # Conical helix if abs(angle) < precision_Confusion(): raise Exception("Angle of helix too small") surf = Geom_ConicalSurface(gp_Ax3(cylAx2), angle, radius) isCylinder = False turns = height / pitch wholeTurns = math.floor(turns) partTurn = turns - wholeTurns aPnt = gp_Pnt2d(0, 0) aDir = gp_Dir2d(2. * math.pi, pitch) coneDir = 1.0 if left: aDir.SetCoord(-2. * math.pi, pitch) coneDir = -1.0 aAx2d = gp_Ax2d(aPnt, aDir) line = Geom2d_Line(aAx2d) beg = line.Value(0) mkWire = BRepBuilderAPI_MakeWire() for i in range(wholeTurns): if isCylinder: end = line.Value( math.sqrt(4.0 * math.pi * math.pi + pitch * pitch) * (i + 1)) else: u = coneDir * (i + 1) * 2.0 * math.pi v = ((i + 1) * pitch) / math.cos(angle) end = gp_Pnt2d(u, v) segm = GCE2d_MakeSegment(beg, end).Value() edgeOnSurf = BRepBuilderAPI_MakeEdge(segm, surf).Edge() mkWire.Add(edgeOnSurf) beg = end if partTurn > precision_Confusion(): if (isCylinder): end = line.Value( math.sqrt(4.0 * math.pi * math.pi + pitch * pitch) * turns) else: u = coneDir * turns * 2.0 * math.pi v = height / math.cos(angle) end = gp_Pnt2d(u, v) segm = GCE2d_MakeSegment(beg, end).Value() edgeOnSurf = BRepBuilderAPI_MakeEdge(segm, surf).Edge() mkWire.Add(edgeOnSurf) shape = mkWire.Wire() breplib.BuildCurves3d(shape) return Shape(shape)
def _ellipse(r1, r2): return Curve2( Geom2d_Ellipse(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0)), r1, r2))