def through_section(sec_a, sec_b, solid_):
generator_sec = BRepOffsetAPI_ThruSections(solid_, False)
generator_sec.AddWire(sec_a)
generator_sec.AddWire(sec_b)
generator_sec.Build()
return generator_sec.Shape()
parser.add_argument("--lxy",
dest="lxy",
default=(0, 10),
type=float,
nargs=2)
parser.add_argument("--rxy",
dest="rxy",
default=(0, 0),
type=float,
nargs=2)
opt = parser.parse_args()
print(opt, argvs)
display, start_display, add_menu, add_function_to_menu = init_display()
api = BRepOffsetAPI_ThruSections()
pt = np.linspace(*opt.lxy, 10)
pr_x = np.tan(np.deg2rad(opt.rxy[0])) * pt + opt.radi[0]
pr_y = np.tan(np.deg2rad(opt.rxy[1])) * pt + opt.radi[1]
for i, d in enumerate(pt):
pnt = gp_Pnt(0, 0, pt[i])
d_z = gp_Dir(0, 0, 1)
wxy = [pr_x[i], pr_y[i]]
obj = wxy_wire(pnt, wxy)
display.DisplayShape(obj)
api.AddWire(obj)
api.Build()
surf = api.Shape()
display.DisplayShape(surf)
def get_aligned_boundingbox_ratio(shape, tol=1e-6, optimal_BB=True, ratio=1):
""" return the bounding box of the TopoDS_Shape `shape`
Parameters
----------
shape : TopoDS_Shape or a subclass such as TopoDS_Face
the shape to compute the bounding box from
tol: float
tolerance of the computed boundingbox
use_triangulation : bool, True by default
This makes the computation more accurate
ratio : float, 1.0 by default.
Returns
-------
if `as_pnt` is True, return a tuple of gp_Pnt instances
for the lower and another for the upper X,Y,Z values representing the bounding box
if `as_pnt` is False, return a tuple of lower and then upper X,Y,Z values
representing the bounding box
"""
bbox = Bnd_Box()
bbox.SetGap(tol)
# note: useTriangulation is True by default, we set it explicitely, but t's not necessary
if optimal_BB:
use_triangulation = True
use_shapetolerance = True
brepbndlib_AddOptimal(shape, bbox, use_triangulation,
use_shapetolerance)
else:
brepbndlib_Add(shape, bbox)
xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
dx, mx = (xmax - xmin) * ratio, (xmax + xmin) / 2
dy, my = (ymax - ymin) * ratio, (ymax + ymin) / 2
dz, mz = (zmax - zmin) * ratio, (zmax + zmin) / 2
x0, x1 = mx - dx / 2, mx + dx / 2
y0, y1 = my - dy / 2, my + dy / 2
z0, z1 = mz - dz / 2, mz + dz / 2
corner1 = gp_Pnt(x0, y0, z0)
corner2 = gp_Pnt(x1, y1, z1)
center = midpoint(corner1, corner2)
rim0 = make_polygon([
gp_Pnt(x0, y0, z0),
gp_Pnt(x1, y0, z0),
gp_Pnt(x1, y1, z0),
gp_Pnt(x0, y1, z0)
],
closed=True)
rim1 = make_polygon([
gp_Pnt(x0, y0, z1),
gp_Pnt(x1, y0, z1),
gp_Pnt(x1, y1, z1),
gp_Pnt(x0, y1, z1)
],
closed=True)
api = BRepOffsetAPI_ThruSections(True, False, 1.0E-9)
api.AddWire(rim0)
api.AddWire(rim1)
box_shp = api.Shape()
#box_shp = BRepPrimAPI_MakeBox(corner1, corner2).Shape()
return center, [dx, dy, dz], box_shp
# 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
bottle = TopoDS_Compound()
aBuilder = BRep_Builder()
aBuilder.MakeCompound(bottle)
aBuilder.Add(bottle, myBody_step3.Shape())
aBuilder.Add(bottle, myThreading)
print("bottle finished")
if __name__ == "__main__":
from OCC.Display.SimpleGui import init_display
def startBottle(complete=False):
"""Build the classic OCC Bottle.
complete=False: minus the neck fillet, shelling & threads.
complete=True: including 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 not complete: # 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)
write_step_file(compound, self.tmpdir + "ThruSurf.stp")
def display_object(self):
self.display.DisplayShape(self.poly)
self.display.DisplayShape(self.circle)
self.show_axs_pln(self.axs, scale=100)
self.show()
if __name__ == '__main__':
obj = plotocc()
obj.SaveMenu()
axis1 = gp_Ax3()
trf_axs(axis1, [0, 0, 10], [10.0, 10.0, 0.0])
star1 = obj.make_StarWire(axs=axis1, skin=None, radi=[10.0, 8.0])
axis2 = gp_Ax3()
trf_axs(axis2, [0, 10, -10], [10.0, 10.0, 5.0])
star2 = obj.make_StarWire(axs=axis2, skin=None, radi=[12.0, 8.0])
api = BRepOffsetAPI_ThruSections()
api.AddWire(star1)
api.AddWire(star2)
api.Build()
obj.export_stp(api.Shape())
obj.display.DisplayShape(star1)
obj.display.DisplayShape(star2)
obj.display.DisplayShape(api.Shape())
obj.show()
