def make_wire(*args): # if we get an iterable, than add all edges to wire builder if isinstance(args[0], (list, tuple)): wire = BRepBuilderAPI_MakeWire() for i in args[0]: wire.Add(i) wire.Build() return wire.Wire() wire = BRepBuilderAPI_MakeWire(*args) return wire.Wire()
def _polysegment(pnts, closed=False) -> Shape: if len(pnts) <= 1: raise Exception("Need at least two points for polysegment") mkWire = BRepBuilderAPI_MakeWire() def __make_edge(a, b): try: return BRepBuilderAPI_MakeEdge(to_Pnt(a), to_Pnt(b)).Edge() except: raise Exception(f"Cannot make edge segment from points {a}, {b}") for i in range(len(pnts) - 1): mkWire.Add(__make_edge(pnts[i], pnts[i + 1])) if (closed): mkWire.Add(__make_edge(pnts[len(pnts) - 1], pnts[0])) return Shape(mkWire.Wire())
def wire_from_polyline(pol3d): lines = [] for i, p in enumerate(pol3d[:-1]): gp0 = gp_Pnt(p[0], p[1], p[2]) gp1 = gp_Pnt(pol3d[i + 1][0], pol3d[i + 1][1], pol3d[i + 1][2]) lines.append(BRepBuilderAPI_MakeEdge(gp0, gp1).Edge()) wire = BRepBuilderAPI_MakeWire(lines[0]) for l in lines[1:]: wire.Add(l) return wire
def make_wire(*args): # if we get an iterable, than add all edges to wire builder if isinstance(args[0], (list, tuple)): wire = BRepBuilderAPI_MakeWire() for i in args[0]: wire.Add(i) wire.Build() return wire.Wire() wire = BRepBuilderAPI_MakeWire(*args) assert_isdone(wire, "failed to produce wire") return wire.Wire()
def generate_planar_slices(nozz_dia, sur_nozz_dia): xmin, ymin, zmin, xmax, ymax, zmax = get_boundingbox(part_shape) print(xmax - xmin, ",", ymax - ymin, ",", zmax - zmin) wires = [] slices = [] contours = [] for z in numpy.arange(zmin+(nozz_dia/2)+(sur_nozz_dia/2), \ zmax-(nozz_dia/2)-(sur_nozz_dia/2), nozz_dia): plane = gp_Pln(gp_Pnt(0., 0., z), gp_Dir(0., 0., 1.)) slices.append(Slicing.plane_shape_intersection(plane, part_shape)) for s in range(0, len(slices)): wire = [] wires.append([]) while len(slices[s]) != 0: for i in range(0, len(slices[s])): if len(wire) == 0: wire.append(slices[s][i]) slices[s].remove(slices[s][i]) break elif Slicing.do_edges_connect(slices[s][i], wire[-1]): wire.append(slices[s][i]) slices[s].remove(slices[s][i]) break if Slicing.do_edges_connect(wire[0], wire[-1]): if len(wire) > 2: wires[s].append(wire) wire = [] elif len(wire) == 2 and Slicing.do_edges_loop( wire[0], wire[-1]): wires[s].append(wire) wire = [] for k in range(0, len(wires)): contours.append([]) for l in range(0, len(wires[k])): make_wire = BRepBuilderAPI_MakeWire() for edge in wires[k][l]: make_wire.Add(edge) try: made_wire = make_wire.Wire() contours[k].append(made_wire) except: print("Skipped a contour!") continue contour_faces = [] for contour in contours: if len(contour) == 1: contour_faces.append( BRepBuilderAPI_MakeFace(contour[0]).Face()) else: contour_faces.extend(Slicing.get_layer_faces(contour)) # for l in range(0,len(contour_faces)): # display.DisplayShape(contour_faces[l], color=colour[l%5],\ # transparency=0.95, update=True) return contour_faces
def make_wire(edges, fillets=None): # the wire # print("adding wire") makeWire = BRepBuilderAPI_MakeWire() makeWire.Add(edges[0]) if fillets is None: for edge in edges[1:]: makeWire.Add(edge) else: for fillet, edge in zip(fillets, edges[1:]): makeWire.Add(fillet) makeWire.Add(edge) # print("build wire") makeWire.Build() # print("make wire") try: wire = makeWire.Wire() except RuntimeError as e: print(type(makeWire)) raise e return wire
def face_polyline3d(pol3d): from OCC.Core.TopoDS import topods lines = [] for i, p in enumerate(pol3d[:-1]): gp0 = gp_Pnt(p[0], p[1], p[2]) gp1 = gp_Pnt(pol3d[i + 1][0], pol3d[i + 1][1], pol3d[i + 1][2]) lines.append(BRepBuilderAPI_MakeEdge(gp0, gp1).Edge()) wire = BRepBuilderAPI_MakeWire(lines[0]) for l in lines[1:]: wire.Add(l) face = BRepBuilderAPI_MakeFace(wire.Wire()) return face
def __init__(self, edges): super().__init__() self.wire = None mkwire = BRepBuilderAPI_MakeWire() if isinstance(edges, TopoDS_Edge): mkwire.Add(edges) self.done = True self.wire = mkwire.Wire() elif len(edges) > 0: for edge in edges: if isinstance(edge, list): for e in edge: mkwire.Add(e) else: mkwire.Add(edge) if not mkwire.IsDone(): OCCWrapper.OccError('OccWire', mkwire) else: self.done = True self.wire = mkwire.Wire() return
def makeWire(self): """Generate a wire from the edges in self.edgeList.""" wireBldr = BRepBuilderAPI_MakeWire() occ_seq = TopTools_ListOfShape() for edge in self.edgeList: occ_seq.Append(edge) wireBldr.Add(occ_seq) if wireBldr.IsDone(): self.wire = wireBldr.Wire() status = True else: status = False return status
def display_path(lay, col, nozz_dia=0): wire = BRepBuilderAPI_MakeWire() for i in range(1, len(lay)): if lay[i - 1][0].Distance(lay[i][0]) < 8 and i < len(lay) - 1: ray = BRepBuilderAPI_MakeEdge(lay[i - 1][0], lay[i][0]).Edge() wire.Add(ray) else: display.DisplayShape(wire.Wire(), color=col, update=False) wire = BRepBuilderAPI_MakeWire() if i < len(lay) - 1: display.DisplayShape(ray, color=col, update=False) else: display.DisplayShape(ray, color=col, update=True)
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 make_wire(*args): # if we get an iterable, than add all edges to wire builder if isinstance(args[0], list) or isinstance(args[0], tuple): wire = BRepBuilderAPI_MakeWire() for i in args[0]: wire.Add(i) wire.Build() return wire.Wire() wire = BRepBuilderAPI_MakeWire(*args) wire.Build() with assert_isdone(wire, 'failed to produce wire'): result = wire.Wire() return result
def create_model(self): boltCylinderex = BRepPrimAPI_MakeCylinder( gp_Ax2(getGpPt(self.p1), getGpDir(-self.shaftDir)), self.r, self.cylex_length).Shape() boltCylinder1 = BRepPrimAPI_MakeCylinder( gp_Ax2(getGpPt(self.p1), getGpDir(self.shaftDir)), self.r, self.cyl1_length).Shape() boltCylinder2 = BRepPrimAPI_MakeCylinder( gp_Ax2(getGpPt(self.p2), getGpDir(self.cyl2_angle)), self.r, self.cyl2_ht).Shape() boltCylinder3 = BRepPrimAPI_MakeCylinder( gp_Ax2(getGpPt(self.p3), getGpDir(self.shaftDir)), self.r, self.cyl3_length).Shape() boltCylinder4 = BRepPrimAPI_MakeCylinder( gp_Ax2(getGpPt(self.p6), getGpDir(-self.shaftDir)), self.r, self.cyl5_length).Shape() sphere1 = BRepPrimAPI_MakeSphere(getGpPt(self.p2), self.r).Shape() sphere2 = BRepPrimAPI_MakeSphere(getGpPt(self.p3), self.r).Shape() edg_points = gp_Circ(gp_Ax2(getGpPt(self.p4), getGpDir(self.shaftDir)), self.r) hexwire = BRepBuilderAPI_MakeWire() hexedge = BRepBuilderAPI_MakeEdge(edg_points).Edge() hexwire.Add(hexedge) hexwire_wire = hexwire.Wire() hexface = BRepBuilderAPI_MakeFace(hexwire_wire).Face() revolve_axis = gp_Ax1(getGpPt(self.p5), gp_Dir(0, -1, 0)) revolved_shape = BRepPrimAPI_MakeRevol(hexface, revolve_axis, math.radians(180.)).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(boltCylinder1, boltCylinder2).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(boltCylinder3, Anchor_BOlt).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(revolved_shape, Anchor_BOlt).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(boltCylinder4, Anchor_BOlt).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(sphere1, Anchor_BOlt).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(sphere2, Anchor_BOlt).Shape() Anchor_BOlt = BRepAlgoAPI_Fuse(boltCylinderex, Anchor_BOlt).Shape() return Anchor_BOlt
def face_polyline(polyline, frame): pol3d = polyline.to_frame(frame) lines = [] yb_point = Point([frame[0][i] for i in range(3)]) yb_vec = Vector([frame[3][i] for i in range(3)]).unit() orig = gp_Pnt(frame[0][0], frame[0][1], frame[0][2]) vec = gp_Dir(yb_vec[0], yb_vec[1], yb_vec[2]) plane = gp_Pln(orig, vec) for i, p in enumerate(pol3d[:-1]): gp0 = gp_Pnt(p[0], p[1], p[2]) gp1 = gp_Pnt(pol3d[i + 1][0], pol3d[i + 1][1], pol3d[i + 1][2]) lines.append(BRepBuilderAPI_MakeEdge(gp0, gp1).Edge()) wire = BRepBuilderAPI_MakeWire(lines[0]) for l in lines[1:]: wire.Add(l) face = BRepBuilderAPI_MakeFace(wire.Wire()) return face.Shape()
def revolved_cut(base): # Define 7 points face_points = TColgp_Array1OfPnt(1, 7) face_inner_radius = 0.6 pts = [ gp_Pnt(face_inner_radius - 0.05, 0.0, -0.05), gp_Pnt(face_inner_radius - 0.10, 0.0, -0.025), gp_Pnt(face_inner_radius - 0.10, 0.0, 0.025), gp_Pnt(face_inner_radius + 0.10, 0.0, 0.025), gp_Pnt(face_inner_radius + 0.10, 0.0, -0.025), gp_Pnt(face_inner_radius + 0.05, 0.0, -0.05), gp_Pnt(face_inner_radius - 0.05, 0.0, -0.05), ] for n, i in enumerate(pts): face_points.SetValue(n + 1, i) # Use these points to create edges and add these edges to a wire hexwire = BRepBuilderAPI_MakeWire() for i in range(1, 7): hexedge = BRepBuilderAPI_MakeEdge(face_points.Value(i), face_points.Value(i + 1)).Edge() hexwire.Add(hexedge) # Turn the wire into a 6 sided face hexface = BRepBuilderAPI_MakeFace(hexwire.Wire()).Face() # Revolve the face around an axis revolve_axis = gp_Ax1(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)) revolved_shape = BRepPrimAPI_MakeRevol(hexface, revolve_axis).Shape() # Move the generated shape move = gp_Trsf() move.SetTranslation(gp_Pnt(0, 0, 0), gp_Pnt(0, 0, sin(0.5))) moved_shape = BRepBuilderAPI_Transform(revolved_shape, move, False).Shape() # Remove the revolved shape cut = BRepAlgoAPI_Cut(base, moved_shape).Shape() return cut
def revolved_shape(): """ demonstrate how to create a revolved shape from an edge adapted from algotopia.com's opencascade_basic tutorial: http://www.algotopia.com/contents/opencascade/opencascade_basic """ face_inner_radius = 0.6 # point to create an edge from edg_points = [ gp_Pnt(face_inner_radius - 0.05, 0.0, -0.05), gp_Pnt(face_inner_radius - 0.10, 0.0, -0.025), gp_Pnt(face_inner_radius - 0.10, 0.0, 0.025), gp_Pnt(face_inner_radius + 0.10, 0.0, 0.025), gp_Pnt(face_inner_radius + 0.10, 0.0, -0.025), gp_Pnt(face_inner_radius + 0.05, 0.0, -0.05), gp_Pnt(face_inner_radius - 0.05, 0.0, -0.05), ] # aggregate edges in wire hexwire = BRepBuilderAPI_MakeWire() for i in range(6): hexedge = BRepBuilderAPI_MakeEdge(edg_points[i], edg_points[i + 1]).Edge() hexwire.Add(hexedge) hexwire_wire = hexwire.Wire() # face from wire hexface = BRepBuilderAPI_MakeFace(hexwire_wire).Face() revolve_axis = gp_Ax1(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1)) # create revolved shape revolved_shape_ = BRepPrimAPI_MakeRevol(hexface, revolve_axis, math.radians(90.)).Shape() # render wire & revolved shape display.DisplayShape([revolved_shape_, hexwire_wire]) display.FitAll() start_display()
def sweep_pipe(edge, xvec, r, wt, geom_repr=ElemType.SOLID): if geom_repr not in [ElemType.SOLID, ElemType.SHELL]: raise ValueError("Sweeping pipe must be either 'solid' or 'shell'") t = TopologyExplorer(edge) points = [v for v in t.vertices()] point = BRep_Tool_Pnt(points[0]) # x, y, z = point.X(), point.Y(), point.Z() direction = gp_Dir(*unit_vector(xvec).astype(float).tolist()) # pipe makeWire = BRepBuilderAPI_MakeWire() makeWire.Add(edge) makeWire.Build() wire = makeWire.Wire() try: if geom_repr == ElemType.SOLID: i = make_circular_sec_face(point, direction, r - wt) elbow_i = BRepOffsetAPI_MakePipe(wire, i).Shape() o = make_circular_sec_face(point, direction, r) elbow_o = BRepOffsetAPI_MakePipe(wire, o).Shape() else: elbow_i = None o = make_circular_sec_wire(point, direction, r) elbow_o = BRepOffsetAPI_MakePipe(wire, o).Shape() except RuntimeError as e: logging.error(f'Pipe sweep failed: "{e}"') return wire if geom_repr == ElemType.SOLID: boolean_result = BRepAlgoAPI_Cut(elbow_o, elbow_i).Shape() if boolean_result.IsNull(): logging.debug("Boolean returns None") else: boolean_result = elbow_o return boolean_result
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 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 write_face(self, points_face, list_points_edge, topo_face, toledge): """ Method to recreate a Face associated to a geometric surface after the modification of Face points. It returns a TopoDS_Face. :param points_face: the new face points array. :param list_points_edge: new edge points :param topo_face: the face to be modified :param toledge: tolerance on the surface creation after modification :return: TopoDS_Face (Shape) :rtype: TopoDS_Shape """ # convert Face to Geom B-spline Surface nurbs_converter = BRepBuilderAPI_NurbsConvert(topo_face) nurbs_converter.Perform(topo_face) nurbs_face = nurbs_converter.Shape() topo_nurbsface = topods.Face(nurbs_face) h_geomsurface = BRep_Tool.Surface(topo_nurbsface) h_bsurface = geomconvert_SurfaceToBSplineSurface(h_geomsurface) bsurface = h_bsurface nb_u = bsurface.NbUPoles() nb_v = bsurface.NbVPoles() # check consistency if points_face.shape[0] != nb_u * nb_v: raise ValueError("Input control points do not have not have the " "same number as the geometric face!") # cycle on the face points indice_cpt = 0 for iu in range(1, nb_u + 1): for iv in range(1, nb_v + 1): cpt = points_face[indice_cpt] bsurface.SetPole(iu, iv, gp_Pnt(cpt[0], cpt[1], cpt[2])) indice_cpt += 1 # create modified new face new_bspline_tface = BRepBuilderAPI_MakeFace() toler = precision_Confusion() new_bspline_tface.Init(bsurface, False, toler) # cycle on the wires face_wires_explorer = TopExp_Explorer( topo_nurbsface.Oriented(TopAbs_FORWARD), TopAbs_WIRE) ind_edge_total = 0 while face_wires_explorer.More(): # get old wire twire = topods_Wire(face_wires_explorer.Current()) # cycle on the edges ind_edge = 0 wire_explorer_edge = TopExp_Explorer( twire.Oriented(TopAbs_FORWARD), TopAbs_EDGE) # check edges order on the wire mode3d = True tolerance_edges = toledge wire_order = ShapeAnalysis_WireOrder(mode3d, tolerance_edges) # an edge list deformed_edges = [] # cycle on the edges while wire_explorer_edge.More(): tedge = topods_Edge(wire_explorer_edge.Current()) new_bspline_tedge = self.write_edge( list_points_edge[ind_edge_total], tedge) deformed_edges.append(new_bspline_tedge) analyzer = topexp() vfirst = analyzer.FirstVertex(new_bspline_tedge) vlast = analyzer.LastVertex(new_bspline_tedge) pt1 = BRep_Tool.Pnt(vfirst) pt2 = BRep_Tool.Pnt(vlast) wire_order.Add(pt1.XYZ(), pt2.XYZ()) ind_edge += 1 ind_edge_total += 1 wire_explorer_edge.Next() # grouping the edges in a wire, then in the face # check edges order and connectivity within the wire wire_order.Perform() # new wire to be created stol = ShapeFix_ShapeTolerance() new_bspline_twire = BRepBuilderAPI_MakeWire() for order_i in range(1, wire_order.NbEdges() + 1): deformed_edge_i = wire_order.Ordered(order_i) if deformed_edge_i > 0: # insert the deformed edge to the new wire new_edge_toadd = deformed_edges[deformed_edge_i - 1] stol.SetTolerance(new_edge_toadd, toledge) new_bspline_twire.Add(new_edge_toadd) if new_bspline_twire.Error() != 0: stol.SetTolerance(new_edge_toadd, toledge * 10.0) new_bspline_twire.Add(new_edge_toadd) else: deformed_edge_revers = deformed_edges[ np.abs(deformed_edge_i) - 1] stol.SetTolerance(deformed_edge_revers, toledge) new_bspline_twire.Add(deformed_edge_revers) if new_bspline_twire.Error() != 0: stol.SetTolerance(deformed_edge_revers, toledge * 10.0) new_bspline_twire.Add(deformed_edge_revers) # add new wire to the Face new_bspline_tface.Add(new_bspline_twire.Wire()) face_wires_explorer.Next() return topods.Face(new_bspline_tface.Face())
def brep_feat_extrusion_protrusion(event=None): # Extrusion S = BRepPrimAPI_MakeBox(400., 250., 300.).Shape() faces = TopologyExplorer(S).faces() F = next(faces) surf1 = BRep_Tool_Surface(F) Pl1 = Geom_Plane.DownCast(surf1) D1 = Pl1.Pln().Axis().Direction().Reversed() MW = BRepBuilderAPI_MakeWire() p1, p2 = gp_Pnt2d(200., -100.), gp_Pnt2d(100., -100.) aline = GCE2d_MakeLine(p1, p2).Value() MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge()) p1, p2 = gp_Pnt2d(100., -100.), gp_Pnt2d(100., -200.) aline = GCE2d_MakeLine(p1, p2).Value() MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge()) p1, p2 = gp_Pnt2d(100., -200.), gp_Pnt2d(200., -200.) aline = GCE2d_MakeLine(p1, p2).Value() MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge()) p1, p2 = gp_Pnt2d(200., -200.), gp_Pnt2d(200., -100.) aline = GCE2d_MakeLine(p1, p2).Value() MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge()) MKF = BRepBuilderAPI_MakeFace() MKF.Init(surf1, False, 1e-6) MKF.Add(MW.Wire()) FP = MKF.Face() breplib_BuildCurves3d(FP) display.EraseAll() MKP = BRepFeat_MakePrism(S, FP, F, D1, 0, True) MKP.PerformThruAll() res1 = MKP.Shape() display.DisplayShape(res1) # Protrusion next(faces) F2 = next(faces) surf2 = BRep_Tool_Surface(F2) Pl2 = Geom_Plane.DownCast(surf2) D2 = Pl2.Pln().Axis().Direction().Reversed() MW2 = BRepBuilderAPI_MakeWire() p1, p2 = gp_Pnt2d(100., 100.), gp_Pnt2d(200., 100.) aline = GCE2d_MakeLine(p1, p2).Value() MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge()) p1, p2 = gp_Pnt2d(200., 100.), gp_Pnt2d(150., 200.) aline = GCE2d_MakeLine(p1, p2).Value() MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge()) p1, p2 = gp_Pnt2d(150., 200.), gp_Pnt2d(100., 100.) aline = GCE2d_MakeLine(p1, p2).Value() MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge()) MKF2 = BRepBuilderAPI_MakeFace() MKF2.Init(surf2, False, 1e-6) MKF2.Add(MW2.Wire()) MKF2.Build() FP = MKF2.Face() breplib_BuildCurves3d(FP) MKP2 = BRepFeat_MakePrism(res1, FP, F2, D2, 0, True) MKP2.PerformThruAll() display.EraseAll() trf = gp_Trsf() trf.SetTranslation(gp_Vec(0, 0, 300)) gtrf = gp_GTrsf() gtrf.SetTrsf(trf) tr = BRepBuilderAPI_GTransform(MKP2.Shape(), gtrf, True) fused = BRepAlgoAPI_Fuse(tr.Shape(), MKP2.Shape()) fused.Build() display.DisplayShape(fused.Shape()) display.FitAll()
def max_counter(self, facesS_2): section_edges = list(Topo(facesS_2).edges()) # print(len(section_edges)) if len(section_edges) > 0: Wire_c = BRepBuilderAPI_MakeWire() prep_list = [] Wire_c.Add(section_edges[0]) prep_list.append(section_edges[0]) ex = TopExp_Explorer(section_edges[0], TopAbs_VERTEX) # no need for a loop since we know for a fact that # the edge has only one start and one end c = ex.Current() cv = topods_Vertex(c) v0 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) v1 = BRep_Tool_Pnt(cv) section_edges.pop(0) flag = 0 wires = [] while len(section_edges) > 0: new_list = [] for edges in section_edges: # Wire_c.Add(edges) ex = TopExp_Explorer(edges, TopAbs_VERTEX) c = ex.Current() cv = topods_Vertex(c) End_1 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) End_2 = BRep_Tool_Pnt(cv) if End_1.X() == v0.X() and End_1.Y() == v0.Y() and End_1.Z( ) == v0.Z(): Wire_c.Add(edges) v0 = End_2 flag = 0 elif End_1.X() == v1.X() and End_1.Y() == v1.Y( ) and End_1.Z() == v1.Z(): Wire_c.Add(edges) v1 = End_2 flag = 0 elif End_2.X() == v0.X() and End_2.Y() == v0.Y( ) and End_2.Z() == v0.Z(): Wire_c.Add(edges) v0 = End_1 flag = 0 elif End_2.X() == v1.X() and End_2.Y() == v1.Y( ) and End_2.Z() == v1.Z(): Wire_c.Add(edges) v1 = End_1 flag = 0 else: new_list.append(edges) flag += 1 section_edges = new_list if flag >= 5: # print('number_ostalos', len(section_edges)) wires.append(Wire_c.Wire()) Wire_c = BRepBuilderAPI_MakeWire() Wire_c.Add(section_edges[0]) ex = TopExp_Explorer(section_edges[0], TopAbs_VERTEX) # no need for a loop since we know for a fact that # the edge has only one start and one end c = ex.Current() cv = topods_Vertex(c) v0 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) v1 = BRep_Tool_Pnt(cv) section_edges.pop(0) flag = 0 wires.append(Wire_c.Wire()) areas = [] props = GProp_GProps() for wire in wires: brown_face = BRepBuilderAPI_MakeFace(wire) brown_face = brown_face.Face() # props = GProp_GProps() brepgprop_SurfaceProperties(brown_face, props) areas.append(props.Mass()) return max(areas) else: return 0
def __call__(self, obj, dst=None): """ This method performs the deformation on the CAD geometry. If `obj` is a TopoDS_Shape, the method returns a TopoDS_Shape containing the deformed geometry. If `obj` is a filename, the method deforms the geometry contained in the file and writes the deformed shape to `dst` (which has to be set). :param obj: the input geometry. :type obj: str or TopoDS_Shape :param str dst: if `obj` is a string containing the input filename, `dst` refers to the file where the deformed geometry is saved. """ # Manage input if isinstance(obj, str): # if a input filename is passed if dst is None: raise ValueError( 'Source file is provided, but no destination specified') shape = self.read_shape(obj) elif isinstance(obj, TopoDS_Shape): shape = obj # Maybe do we need to handle also Compound? else: raise TypeError #create compound to store modified faces compound_builder = BRep_Builder() compound = TopoDS_Compound() compound_builder.MakeCompound(compound) # cycle on the faces to get the control points # iterator to faces (TopoDS_Shape) contained in the shape faces_explorer = TopExp_Explorer(shape, TopAbs_FACE) while faces_explorer.More(): # performing some conversions to get the right # format (BSplineSurface) # TopoDS_Face obtained from iterator face = topods_Face(faces_explorer.Current()) # performing some conversions to get the right # format (BSplineSurface) bspline_surface = self._bspline_surface_from_face(face) # add the required amount of poles in u and v directions self._enrich_surface_knots(bspline_surface) # deform the Bspline surface through FFD self._deform_bspline_surface(bspline_surface) # through moving the control points, we now changed the SURFACE # underlying FACE we are processing. we now need to obtain the # curves (actually, the WIRES) that define the bounds of the # surface and TRIM the surface with them, to obtain the new FACE #we now start really looping on the wires #we will create a single curve joining all the edges in the wire # the curve must be a bspline curve so we need to make conversions # through all the way # list that will contain the (single) outer wire of the face outer_wires = [] # list that will contain all the inner wires (holes) of the face inner_wires = [] # iterator to loop over TopoDS_Wire in the original (undeformed) # face wire_explorer = TopExp_Explorer(face, TopAbs_WIRE) while wire_explorer.More(): # wire obtained from the iterator wire = topods_Wire(wire_explorer.Current()) # getting a bpline curve joining all the edges of the wire composite_curve = self._bspline_curve_from_wire(wire) # adding all the required knots to the Bspline curve self._enrich_curve_knots(composite_curve) # deforming the Bspline curve through FFD self._deform_bspline_curve(composite_curve) # the GeomCurve corresponding to the whole edge has now # been deformed. Now we must make it become an proper # wire # list of shapes (needed by the wire generator) shapes_list = TopTools_ListOfShape() # edge (to be converted to wire) obtained from the modified # Bspline curve modified_composite_edge = \ BRepBuilderAPI_MakeEdge(composite_curve).Edge() # modified edge is added to shapes_list shapes_list.Append(modified_composite_edge) # wire builder wire_maker = BRepBuilderAPI_MakeWire() wire_maker.Add(shapes_list) # deformed wire is finally obtained modified_wire = wire_maker.Wire() # now, the wire can be outer or inner. we store the outer # and (possible) inner ones in different lists # this is because we first need to trim the surface # using the outer wire, and then we can trim it # with the wires corresponding to all the holes. # the wire order is important, in the trimming process if wire == breptools_OuterWire(face): outer_wires.append(modified_wire) else: inner_wires.append(modified_wire) wire_explorer.Next() # so once we finished looping on all the wires to modify them, # we first use the only outer one to trim the surface # face builder object face_maker = BRepBuilderAPI_MakeFace(bspline_surface, outer_wires[0]) # and then add all other inner wires for the holes for inner_wire in inner_wires: face_maker.Add(inner_wire) # finally, we get our trimmed face with all its holes trimmed_modified_face = face_maker.Face() # trimmed_modified_face is added to the modified faces compound compound_builder.Add(compound, trimmed_modified_face) # and move to the next face faces_explorer.Next() ## END SURFACES ################################################# if isinstance(dst, str): # if a input filename is passed # save the shape exactly to the filename, aka `dst` self.write_shape(dst, compound) else: return compound
def round_tooth(wedge): round_x = 2.6 round_z = 0.06 * pitch round_radius = pitch # Determine where the circle used for rounding has to start and stop p2d_1 = gp_Pnt2d(top_radius - round_x, 0) p2d_2 = gp_Pnt2d(top_radius, round_z) # Construct the rounding circle round_circle = GccAna_Circ2d2TanRad(p2d_1, p2d_2, round_radius, 0.01) if (round_circle.NbSolutions() != 2): sys.exit(-2) round_circle_2d_1 = round_circle.ThisSolution(1) round_circle_2d_2 = round_circle.ThisSolution(2) if (round_circle_2d_1.Position().Location().Coord()[1] >= 0): round_circle_2d = round_circle_2d_1 else: round_circle_2d = round_circle_2d_2 # Remove the arc used for rounding trimmed_circle = GCE2d_MakeArcOfCircle(round_circle_2d, p2d_1, p2d_2).Value() # Calculate extra points used to construct lines p1 = gp_Pnt(p2d_1.X(), 0, p2d_1.Y()) p2 = gp_Pnt(p2d_2.X(), 0, p2d_2.Y()) p3 = gp_Pnt(p2d_2.X() + 1, 0, p2d_2.Y()) p4 = gp_Pnt(p2d_2.X() + 1, 0, p2d_1.Y() - 1) p5 = gp_Pnt(p2d_1.X(), 0, p2d_1.Y() - 1) # Convert the arc and four extra lines into 3D edges plane = gp_Pln(gp_Ax3(gp_Origin(), gp_DY().Reversed(), gp_DX())) arc1 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_circle, plane)).Edge() lin1 = BRepBuilderAPI_MakeEdge(p2, p3).Edge() lin2 = BRepBuilderAPI_MakeEdge(p3, p4).Edge() lin3 = BRepBuilderAPI_MakeEdge(p4, p5).Edge() lin4 = BRepBuilderAPI_MakeEdge(p5, p1).Edge() # Make a wire composed of the edges round_wire = BRepBuilderAPI_MakeWire(arc1) round_wire.Add(lin1) round_wire.Add(lin2) round_wire.Add(lin3) round_wire.Add(lin4) # Turn the wire into a face round_face = BRepBuilderAPI_MakeFace(round_wire.Wire()).Shape() # Revolve the face around the Z axis over the tooth angle rounding_cut_1 = BRepPrimAPI_MakeRevol(round_face, gp_OZ(), tooth_angle).Shape() # Construct a mirrored copy of the first cutting shape mirror = gp_Trsf() mirror.SetMirror(gp_XOY()) mirrored_cut_1 = BRepBuilderAPI_Transform(rounding_cut_1, mirror, True).Shape() # and translate it so that it ends up on the other side of the wedge translate = gp_Trsf() translate.SetTranslation(gp_Vec(0, 0, thickness)) rounding_cut_2 = BRepBuilderAPI_Transform(mirrored_cut_1, translate, False).Shape() # Cut the wedge using the first and second cutting shape cut_1 = BRepAlgoAPI_Cut(wedge, rounding_cut_1).Shape() cut_2 = BRepAlgoAPI_Cut(cut_1, rounding_cut_2).Shape() return cut_2
# 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_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():
def glue_solids(event=None): display.EraseAll() display.Context.RemoveAll(True) # Without common edges S1 = BRepPrimAPI_MakeBox(gp_Pnt(500., 500., 0.), gp_Pnt(100., 250., 300.)).Shape() # S2 = BRepPrimAPI_MakeBox(gp_Pnt(300., 300., 300.), gp_Pnt(600., 600., 600.)).Shape() S2 = read_step_file(os.path.join('..', 'part_of_sattelate', 'pribore', 'Camara_WS16.STEP')) bbox = Bnd_Box() brepbndlib_Add(S2, bbox) xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get() print(bbox.Get()) p0 = gp_Pnt(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin+0.01) vnorm = gp_Dir(0, 0, 1) pln = gp_Pln(p0, vnorm) face = BRepBuilderAPI_MakeFace(pln, -(xmax - xmin) / 2 - 1, (xmax - xmin) / 2 + 1, -(ymax - ymin) / 2 - 1, (ymax - ymin) / 2 + 1).Face() # face = BRepBuilderAPI_MakeFace(pln, -10, 10, -10,10).Face() '''planeZ = BRepBuilderAPI_MakeFace( gp_Pln(gp_Pnt(xmin, ymin, zmin), gp_Pnt(xmax, ymax, zmin), gp_Pnt(xmin, ymax, zmin))).Face()''' facesS_2 = BRepAlgoAPI_Section(face, S2).Shape() # print(facesS_2) display.DisplayShape(face, update=True) display.DisplayShape(S2, update=True) display.DisplayShape(facesS_2, update=True) section_edges = list(Topo(facesS_2).edges()) print(len(section_edges)) '''toptool_seq_shape = TopTools_SequenceOfShape() for edge in section_edges: toptool_seq_shape.Append(edge)''' Wire_c = BRepBuilderAPI_MakeWire() prep_list = [] Wire_c.Add(section_edges[0]) prep_list.append(section_edges[0]) ex = TopExp_Explorer(section_edges[0], TopAbs_VERTEX) # no need for a loop since we know for a fact that # the edge has only one start and one end c = ex.Current() cv = topods_Vertex(c) v0 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) v1 = BRep_Tool_Pnt(cv) section_edges.pop(0) flag = 0 wires = [] while len(section_edges) > 0: new_list = [] for edges in section_edges: #Wire_c.Add(edges) ex = TopExp_Explorer(edges, TopAbs_VERTEX) c = ex.Current() cv = topods_Vertex(c) End_1 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) End_2 = BRep_Tool_Pnt(cv) if End_1.X() == v0.X() and End_1.Y() == v0.Y() and End_1.Z() == v0.Z(): Wire_c.Add(edges) v0 = End_2 flag = 0 elif End_1.X() == v1.X() and End_1.Y() == v1.Y() and End_1.Z() == v1.Z(): Wire_c.Add(edges) v1 = End_2 flag = 0 elif End_2.X() == v0.X() and End_2.Y() == v0.Y() and End_2.Z() == v0.Z(): Wire_c.Add(edges) v0 = End_1 flag = 0 elif End_2.X() == v1.X() and End_2.Y() == v1.Y() and End_2.Z() == v1.Z(): Wire_c.Add(edges) v1 = End_1 flag = 0 else: new_list.append(edges) flag += 1 section_edges = new_list if flag >= 5: print('number_ostalos', len(section_edges)) wires.append(Wire_c.Wire()) #wir = Wire_c.Wire() print('ttttt') Wire_c = BRepBuilderAPI_MakeWire() Wire_c.Add(section_edges[0]) ex = TopExp_Explorer(section_edges[0], TopAbs_VERTEX) # no need for a loop since we know for a fact that # the edge has only one start and one end c = ex.Current() cv = topods_Vertex(c) v0 = BRep_Tool_Pnt(cv) ex.Next() c = ex.Current() cv = topods_Vertex(c) v1 = BRep_Tool_Pnt(cv) section_edges.pop(0) flag = 0 # wires.append(Wire_c.Wire()) wires.append(bild_wire(Wire_c)) props = GProp_GProps() yellow_wire = wires[0] brown_face = BRepBuilderAPI_MakeFace(yellow_wire) brown_face = brown_face.Face() brepgprop_SurfaceProperties(brown_face, props) face_surf = props.Mass() print(face_surf) #display.DisplayColoredShape(brown_face.Face(), 'BLUE') areas = [] props = GProp_GProps() for wire in wires: brown_face = BRepBuilderAPI_MakeFace(wire) brown_face = brown_face.Face() #props = GProp_GProps() brepgprop_SurfaceProperties(brown_face, props) areas.append(props.Mass()) print(areas) print(len(wires))
def cut_out(base): outer = gp_Circ2d(gp_OX2d(), top_radius - 1.75 * roller_diameter) inner = gp_Circ2d(gp_OX2d(), center_radius + 0.75 * roller_diameter) geom_outer = GCE2d_MakeCircle(outer).Value() geom_inner = GCE2d_MakeCircle(inner).Value() geom_inner.Reverse() base_angle = (2. * M_PI) / mounting_hole_count hole_angle = atan(hole_radius / mounting_radius) correction_angle = 3 * hole_angle left = gp_Lin2d(gp_Origin2d(), gp_DX2d()) right = gp_Lin2d(gp_Origin2d(), gp_DX2d()) left.Rotate(gp_Origin2d(), correction_angle) right.Rotate(gp_Origin2d(), base_angle - correction_angle) geom_left = GCE2d_MakeLine(left).Value() geom_right = GCE2d_MakeLine(right).Value() inter_1 = Geom2dAPI_InterCurveCurve(geom_outer, geom_left) inter_2 = Geom2dAPI_InterCurveCurve(geom_outer, geom_right) inter_3 = Geom2dAPI_InterCurveCurve(geom_inner, geom_right) inter_4 = Geom2dAPI_InterCurveCurve(geom_inner, geom_left) if inter_1.Point(1).X() > 0: p1 = inter_1.Point(1) else: p1 = inter_1.Point(2) if inter_2.Point(1).X() > 0: p2 = inter_2.Point(1) else: p2 = inter_2.Point(2) if inter_3.Point(1).X() > 0: p3 = inter_3.Point(1) else: p3 = inter_3.Point(2) if inter_4.Point(1).X() > 0: p4 = inter_4.Point(1) else: p4 = inter_4.Point(2) trimmed_outer = GCE2d_MakeArcOfCircle(outer, p1, p2).Value() trimmed_inner = GCE2d_MakeArcOfCircle(inner, p4, p3).Value() plane = gp_Pln(gp_Origin(), gp_DZ()) arc1 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_outer, plane)).Edge() lin1 = BRepBuilderAPI_MakeEdge(gp_Pnt(p2.X(), p2.Y(), 0), gp_Pnt(p3.X(), p3.Y(), 0)).Edge() arc2 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_inner, plane)).Edge() lin2 = BRepBuilderAPI_MakeEdge(gp_Pnt(p4.X(), p4.Y(), 0), gp_Pnt(p1.X(), p1.Y(), 0)).Edge() cutout_wire = BRepBuilderAPI_MakeWire(arc1) cutout_wire.Add(lin1) cutout_wire.Add(arc2) cutout_wire.Add(lin2) # Turn the wire into a face cutout_face = BRepBuilderAPI_MakeFace(cutout_wire.Wire()) filleted_face = BRepFilletAPI_MakeFillet2d(cutout_face.Face()) explorer = BRepTools_WireExplorer(cutout_wire.Wire()) while explorer.More(): vertex = explorer.CurrentVertex() filleted_face.AddFillet(vertex, roller_radius) explorer.Next() cutout = BRepPrimAPI_MakePrism(filleted_face.Shape(), gp_Vec(0.0, 0.0, thickness)).Shape() result = base rotate = gp_Trsf() for i in range(0, mounting_hole_count): rotate.SetRotation(gp_OZ(), i * 2. * M_PI / mounting_hole_count) rotated_cutout = BRepBuilderAPI_Transform(cutout, rotate, True) result = BRepAlgoAPI_Cut(result, rotated_cutout.Shape()).Shape() return result
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 _build_solid(compound, divide_closed): """ Try to build a solid from the OpenVSP compound of faces. :param afem.topology.entities.Compound compound: The compound. :param bool divide_closed: Option to divide closed faces. :return: The solid. :rtype: afem.topology.entities.Solid """ # Get all the faces in the compound. The surfaces must be split. Discard # any with zero area. faces = [] for face in compound.faces: area = SurfaceProps(face).area if area > 1.0e-7: faces.append(face) # Replace any planar B-Spline surfaces with planes. non_planar_faces = [] planar_faces = [] for f in faces: srf = f.surface try: pln = srf.as_plane() if pln: w = f.outer_wire # Fix the wire because they are usually degenerate edges in # the planar end caps. builder = BRepBuilderAPI_MakeWire() for e in w.edges: if LinearProps(e).length > 1.0e-7: builder.Add(e.object) w = builder.Wire() fix = ShapeFix_Wire() fix.Load(w) fix.SetSurface(pln.object) fix.FixReorder() fix.FixConnected() fix.FixEdgeCurves() fix.FixDegenerated() w = Wire(fix.WireAPIMake()) fnew = Face.by_wire(w) planar_faces.append(fnew) else: non_planar_faces.append(f) except RuntimeError: logger.info('Failed to check for planar face...') non_planar_faces.append(f) # Make a compound of the faces shape = Compound.by_shapes(non_planar_faces + planar_faces) # Split closed faces if divide_closed: shape = DivideClosedShape(shape).shape # Sew shape sewn_shape = SewShape(shape).sewed_shape if isinstance(sewn_shape, Face): sewn_shape = sewn_shape.to_shell() # Attempt to unify planar domains shell = UnifyShape(sewn_shape).shape # Make solid if not isinstance(shell, Shell): logger.info('\tA valid shell was not able to be generated.') check = CheckShape(shell) if not check.is_valid: logger.info('\tShape errors:') check.log_errors() return shell, check.invalid_shapes solid = Solid.by_shell(shell) # Limit tolerance FixShape.limit_tolerance(solid) # Check the solid and attempt to fix invalid = [] check = CheckShape(solid) if not check.is_valid: logger.info('\tFixing the solid...') solid = FixShape(solid).shape check = CheckShape(solid) if not check.is_valid: logger.info('\t...solid could not be fixed.') logger.info('\tShape errors:') check.log_errors() failed = check.invalid_shapes invalid += failed else: tol = solid.tol_avg logger.info( '\tSuccessfully generated solid with tolerance={}'.format(tol)) return solid, invalid
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)