def brep_feat_rib(event=None):
mkw = BRepBuilderAPI_MakeWire()
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(0., 0., 0.), gp_Pnt(200., 0., 0.)).Edge())
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(200., 0., 0.), gp_Pnt(200., 0., 50.)).Edge())
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(200., 0., 50.), gp_Pnt(50., 0., 50.)).Edge())
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(50., 0., 50.), gp_Pnt(50., 0., 200.)).Edge())
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(50., 0., 200.), gp_Pnt(0., 0., 200.)).Edge())
mkw.Add(BRepBuilderAPI_MakeEdge(gp_Pnt(0., 0., 200.), gp_Pnt(0., 0., 0.)).Edge())
S = BRepPrimAPI_MakePrism(BRepBuilderAPI_MakeFace(mkw.Wire()).Face(),
gp_Vec(gp_Pnt(0., 0., 0.),
gp_Pnt(0., 100., 0.)))
display.EraseAll()
# display.DisplayShape(S.Shape())
W = BRepBuilderAPI_MakeWire(BRepBuilderAPI_MakeEdge(gp_Pnt(50., 45., 100.),
gp_Pnt(100., 45., 50.)).Edge())
aplane = Geom_Plane(0., 1., 0., -45.)
aform = BRepFeat_MakeLinearForm(S.Shape(), W.Wire(), aplane,
gp_Vec(0., 10., 0.), gp_Vec(0., 0., 0.),
1, True)
aform.Perform()
display.DisplayShape(aform.Shape())
display.FitAll()
def make_prism(profile, vec):
'''
makes a finite prism
'''
pri = BRepPrimAPI_MakePrism(profile, vec, True)
with assert_isdone(pri, 'failed building prism'):
pri.Build()
return pri.Shape()
def sweep(self, vec: numpy.array, s: float):
# Sweep the face in the vec direction the distance s
svec = vec * s
aVec = OccVector(svec)
if self.face_is_plane(self.face):
mksolid = BRepPrimAPI_MakePrism(self.face, aVec.Value())
if mksolid.IsDone():
self.solid = mksolid.Shape()
self.done = True
else:
OccError('MakeSolidPrism', mksolid)
else:
OccError('MakeSolidPrism', self)
return
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 __init__(self, shape, v):
v = CheckGeom.to_vector(v)
builder = BRepPrimAPI_MakePrism(shape.object, v)
self._shape = Shape.wrap(builder.Shape())
self._s1 = Shape.wrap(builder.FirstShape())
self._s2 = Shape.wrap(builder.LastShape())
def __init__(self, face, v):
v = CheckGeom.to_vector(v)
builder = BRepPrimAPI_MakePrism(face.object, v)
self._solid = Solid(builder.Shape())
self._f1 = Face(builder.FirstShape())
self._f2 = Face(builder.LastShape())
def __init__(self, wire, v):
v = CheckGeom.to_vector(v)
builder = BRepPrimAPI_MakePrism(wire.object, v)
self._shell = Shell(builder.Shape())
self._w1 = Wire(builder.FirstShape())
self._w2 = Wire(builder.LastShape())
def __init__(self, edge, v):
v = CheckGeom.to_vector(v)
builder = BRepPrimAPI_MakePrism(edge.object, v)
self._f = Face(builder.Shape())
self._e1 = Edge(builder.FirstShape())
self._e2 = Edge(builder.LastShape())
def __init__(self, vertex, v):
v = CheckGeom.to_vector(v)
builder = BRepPrimAPI_MakePrism(vertex.object, v)
self._e = Edge(builder.Shape())
self._v1 = Vertex(builder.FirstShape())
self._v2 = Vertex(builder.LastShape())
# 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_step1 = BRepPrimAPI_MakePrism(myFaceProfile.Face(), aPrismVec)
# Add fillets to all edges through the explorer
mkFillet = BRepFilletAPI_MakeFillet(myBody_step1.Shape())
anEdgeExplorer = TopExp_Explorer(myBody_step1.Shape(), TopAbs_EDGE)
while anEdgeExplorer.More():
anEdge = topods.Edge(anEdgeExplorer.Current())
mkFillet.Add(thickness / 12.0, anEdge)
anEdgeExplorer.Next()
# 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
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()
# 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
# Create the neck of the bottle
neckLocation = gp_Pnt(0, 0, height)
neckAxis = gp_DZ()
neckAx2 = gp_Ax2(neckLocation, neckAxis)