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))
