def to_wire(self, stroking_interval=5.0): """convert IfcTransitionSegment2D to OCC wire :param stroking_interval: maximum curve length between points to be calculated :type stroking_interval: float :return: OCC wire containing interpolated points """ points = list() L = self.SegmentLength R = self.EndRadius ccw = self.IsStartRadiusCCW trans_type = self.TransitionCurveType.name num_intervals = math.ceil(L / stroking_interval) interval_dist = L / num_intervals lpt = 0.0 # length along the curve at the point to be calculated for _ in range(num_intervals): points.append(self._calc_transition_curve_point(lpt, L, R, ccw, trans_type)) lpt += interval_dist edges = list() for i in range(len(points) - 1): edges.append(BRepBuilderAPI_MakeEdge2d(points[i], points[i + 1])) wire = BRepBuilderAPI_MakeWire() for e in edges: wire.Add(e.Edge()) # return wire return points
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 display_path(lay, col): wire = BRepBuilderAPI_MakeWire() for i in range(1, len(lay)): if lay[i - 1][0].Distance(lay[i][0]) < 50: ray = BRepBuilderAPI_MakeEdge(lay[i - 1][0], lay[i][0]).Edge() wire.Add(ray) display.DisplayShape(wire.Wire(), color=col, update=False)
def thicken_spline(event=None): # Creation of points for the spine array = TColgp_Array1OfPnt(1, 5) array.SetValue(1, gp_Pnt(1, 4, 0)) array.SetValue(2, gp_Pnt(2, 2, 0)) array.SetValue(3, gp_Pnt(3, 3, 0)) array.SetValue(4, gp_Pnt(4, 3, 0)) array.SetValue(5, gp_Pnt(5, 5, 0)) # Creation of a Bezier Curve as the spine bz_curv = Geom_BezierCurve(array) bz_curv_edge = BRepBuilderAPI_MakeEdge(bz_curv).Edge() bz_curv_wire = BRepBuilderAPI_MakeWire(bz_curv_edge).Wire() display.DisplayShape(bz_curv_wire) # Creation of profile to sweep along the spine circle = gp_Circ(gp_ZOX(), 1) circle.SetLocation(array[0]) circle_edge = BRepBuilderAPI_MakeEdge(circle).Edge() circle_wire = BRepBuilderAPI_MakeWire(circle_edge).Wire() # Creation of the law to dictate the evolution of the profile brep1 = BRepOffsetAPI_MakePipeShell(bz_curv_wire) law_f = Law_Linear() law_f.Set(0, 0.5, 1, 1) brep1.SetLaw(circle_wire, law_f, False, True) return brep1.Shape()
def extrude_polyline2d(polyline, frame, height): pol3d = polyline.to_frame(frame) lines = [] yb_point = Point([frame[0][i] for i in range(3)]) yb_vec = Vector([frame[1][0][i] for i in range(3)]).unit() print '*************' print yb_vec 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]): print p print 'zob' 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()) print 'normal' print[vec.X(), vec.Y(), vec.Z()] extrude = BRepPrimAPI_MakePrism( face.Shape(), gp_Vec(height * vec.X(), height * vec.Y(), height * vec.Z())).Shape() return extrude
def main(): vertices = [gp_Pnt(p[0], p[1], p[2]) for p in mesh['vertices']] oFaces = [] builder = BRep_Builder() shell = TopoDS_Shell() builder.MakeShell(shell) for face in mesh['faces']: edges = [] face.reverse() for i in range(len(face)): cur = face[i] nxt = face[(i + 1) % len(face)] segment = GC_MakeSegment(vertices[cur], vertices[nxt]) edges.append(BRepBuilderAPI_MakeEdge(segment.Value())) wire = BRepBuilderAPI_MakeWire() for edge in edges: wire.Add(edge.Edge()) oFace = BRepBuilderAPI_MakeFace(wire.Wire()) builder.Add(shell, oFace.Shape()) write_stl_file(shell, "./cube_binding.stl")
def make_revolved_cylinder(pnt, height, revolve_angle, rotation, wall_thick): """ This method demonstrates how to create a revolved shape from a drawn closed edge. It currently creates a hollow cylinder adapted from algotopia.com's opencascade_basic tutorial: http://www.algotopia.com/contents/opencascade/opencascade_basic :param pnt: :param height: :param revolve_angle: :param rotation: :param wall_thick: :type pnt: dict :type height: float :type revolve_angle: float :type rotation: float :type wall_thick: float """ from OCC.Core.BRepBuilderAPI import ( BRepBuilderAPI_MakeEdge, BRepBuilderAPI_MakeFace, BRepBuilderAPI_MakeWire, ) from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeRevol from OCC.Core.gp import gp_Ax1, gp_Dir, gp_Pnt face_inner_radius = pnt["X"] + (17.0 - wall_thick / 2) * 1000 face_outer_radius = pnt["X"] + (17.0 + wall_thick / 2) * 1000 # point to create an edge from edg_points = [ gp_Pnt(face_inner_radius, pnt["Y"], pnt["Z"]), gp_Pnt(face_inner_radius, pnt["Y"], pnt["Z"] + height), gp_Pnt(face_outer_radius, pnt["Y"], pnt["Z"] + height), gp_Pnt(face_outer_radius, pnt["Y"], pnt["Z"]), gp_Pnt(face_inner_radius, pnt["Y"], pnt["Z"]), ] # aggregate edges in wire hexwire = BRepBuilderAPI_MakeWire() for i in range(len(edg_points) - 1): 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(pnt["X"], pnt["Y"], pnt["Z"]), gp_Dir(0, 0, 1)) # create revolved shape revolved_shape_ = BRepPrimAPI_MakeRevol(hexface, revolve_axis, np.radians( float(revolve_angle))).Shape() revolved_shape_ = rotate_shp_3_axis(revolved_shape_, revolve_axis, rotation) return revolved_shape_
def face_polygon(pnts): wire_maker = BRepBuilderAPI_MakeWire() verts = [BRepBuilderAPI_MakeVertex(as_occ(pnt, gp_Pnt)).Vertex() for pnt in pnts] for i in range(len(verts)): j = (i + 1) % len(verts) wire_maker.Add(BRepBuilderAPI_MakeEdge(verts[i], verts[j]).Edge()) return BRepBuilderAPI_MakeFace(wire_maker.Wire()).Face()
def _make_wire(arr): mk = BRepBuilderAPI_MakeWire() for ptr in arr: if (ptr.Shape().ShapeType() == TopAbs_WIRE): mk.Add(ptr.Wire()) elif (ptr.Shape().ShapeType() == TopAbs_EDGE): mk.Add(ptr.Edge()) return Shape(mk.Wire())
def __make_wire(lst): mk = BRepBuilderAPI_MakeWire() for ptr in lst: if ptr.Shape().ShapeType() == TopAbs_WIRE: mk.Add(ptr.Wire()) elif ptr.Shape().ShapeType() == TopAbs_EDGE: mk.Add(ptr.Edge()) return mk.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 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 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 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 pipe(): # the bspline path, must be a wire array2 = TColgp_Array1OfPnt(1, 3) array2.SetValue(1, gp_Pnt(0, 0, 0)) array2.SetValue(2, gp_Pnt(0, 1, 2)) array2.SetValue(3, gp_Pnt(0, 2, 3)) bspline2 = GeomAPI_PointsToBSpline(array2).Curve() path_edge = BRepBuilderAPI_MakeEdge(bspline2).Edge() path_wire = BRepBuilderAPI_MakeWire(path_edge).Wire() # the bspline profile. Profile mist be a wire array = TColgp_Array1OfPnt(1, 5) array.SetValue(1, gp_Pnt(0, 0, 0)) array.SetValue(2, gp_Pnt(1, 2, 0)) array.SetValue(3, gp_Pnt(2, 3, 0)) array.SetValue(4, gp_Pnt(4, 3, 0)) array.SetValue(5, gp_Pnt(5, 5, 0)) bspline = GeomAPI_PointsToBSpline(array).Curve() profile_edge = BRepBuilderAPI_MakeEdge(bspline).Edge() # pipe pipe = BRepOffsetAPI_MakePipe(path_wire, profile_edge).Shape() display.DisplayShape(profile_edge, update=False) display.DisplayShape(path_wire, update=False) display.DisplayShape(pipe, update=True)
def _generate_tip(self, maxDeg): """ Private method to generate the surface that closing the blade tip. :param int maxDeg: Define the maximal U degree of generated surface """ self._import_occ_libs() generator = BRepOffsetAPI_ThruSections(False, False, 1e-10) generator.SetMaxDegree(maxDeg) # npoints_up == npoints_down npoints = len(self.blade_coordinates_down[-1][0]) vertices_1 = TColgp_HArray1OfPnt(1, npoints) vertices_2 = TColgp_HArray1OfPnt(1, npoints) for j in range(npoints): vertices_1.SetValue( j + 1, gp_Pnt(1000 * self.blade_coordinates_down[-1][0][j], 1000 * self.blade_coordinates_down[-1][1][j], 1000 * self.blade_coordinates_down[-1][2][j])) vertices_2.SetValue( j + 1, gp_Pnt(1000 * self.blade_coordinates_up[-1][0][j], 1000 * self.blade_coordinates_up[-1][1][j], 1000 * self.blade_coordinates_up[-1][2][j])) # Initializes an algorithm for constructing a constrained # BSpline curve passing through the points of the blade last # section, with tolerance = 1e-9 bspline_1 = GeomAPI_Interpolate(vertices_1, False, 1e-9) bspline_1.Perform() bspline_2 = GeomAPI_Interpolate(vertices_2, False, 1e-9) bspline_2.Perform() edge_1 = BRepBuilderAPI_MakeEdge(bspline_1.Curve()).Edge() edge_2 = BRepBuilderAPI_MakeEdge(bspline_2.Curve()).Edge() # Add BSpline wire to the generator constructor generator.AddWire(BRepBuilderAPI_MakeWire(edge_1).Wire()) generator.AddWire(BRepBuilderAPI_MakeWire(edge_2).Wire()) # Returns the shape built by the shape construction algorithm generator.Build() # Returns the Face generated by each edge of the first section self.generated_tip = generator.GeneratedFace(edge_1)
def __init__(self, center: numpy.array, normal: numpy.array, radius: float): super().__init__() self.wire = TopoDS_Wire gpCenter = OccPoint(center) gpVec = OccVector(normal) mkcircle = GC_MakeCircle(gpCenter.Value(), gpVec.Value(), radius) if not mkcircle.IsDone(): OCCWrapper.OccError('OccCircle', mkcircle) else: mkwire = BRepBuilderAPI_MakeWire(mkcircle.Value()) if not mkwire.IsDone(): OCCWrapper.OccError('OccCircle', mkwire) else: self.done = True self.w = mkwire.Wire() return
def makeSqProfile(self, size): # points and segments need to be in CW sequence to get W pointing along Z p1 = gp_Pnt(-size, size, 0).Transformed(self.Trsf) p2 = gp_Pnt(size, size, 0).Transformed(self.Trsf) p3 = gp_Pnt(size, -size, 0).Transformed(self.Trsf) p4 = gp_Pnt(-size, -size, 0).Transformed(self.Trsf) seg1 = GC_MakeSegment(p1, p2).Value() seg2 = GC_MakeSegment(p2, p3).Value() seg3 = GC_MakeSegment(p3, p4).Value() seg4 = GC_MakeSegment(p4, p1).Value() e1 = BRepBuilderAPI_MakeEdge(seg1).Edge() e2 = BRepBuilderAPI_MakeEdge(seg2).Edge() e3 = BRepBuilderAPI_MakeEdge(seg3).Edge() e4 = BRepBuilderAPI_MakeEdge(seg4).Edge() aWire_mkr = BRepBuilderAPI_MakeWire(e1, e2, e3, e4) myWireProfile = aWire_mkr.Wire() return myWireProfile # TopoDS_Wire
def makeHalfWire(event=None): global aWire aWire = BRepBuilderAPI_MakeWire(aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge()).Wire() display.EraseAll() display.DisplayColoredShape(aWire, 'BLUE') display.Repaint() win.statusBar().showMessage('Make Half Wire complete')
def display_path(lay, col, nozz_dia=0): wire = BRepBuilderAPI_MakeWire() for i in range(1, len(lay)): ray = BRepBuilderAPI_MakeEdge(lay[i - 1][0], lay[i][0]).Edge() if i == len(lay) - 1: display.DisplayShape(ray, color=col, update=True) else: display.DisplayShape(ray, color=col, update=False)
def makeWholeWire(): global myWireProfile xAxis = gp_OX() # Set up the mirror aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) # Apply the mirror transform aBRepTrsf = BRepBuilderAPI_Transform(aWire, aTrsf) # Convert mirrored shape to a wire aMirroredShape = aBRepTrsf.Shape() aMirroredWire = topods_Wire(aMirroredShape) # Combine the two wires mkWire = BRepBuilderAPI_MakeWire() mkWire.Add(aWire) mkWire.Add(aMirroredWire) myWireProfile = mkWire.Wire() return myWireProfile
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) return wire.Wire()
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 boundary_curve_from_2_points(p1, p2): # first create an edge e0 = BRepBuilderAPI_MakeEdge(p1, p2).Edge() w0 = BRepBuilderAPI_MakeWire(e0).Wire() # boundary for filling adap = BRepAdaptor_CompCurve(w0) p0_h = BRepAdaptor_HCompCurve(adap) boundary = GeomFill_SimpleBound(p0_h.GetHandle(), 1e-6, 1e-6) return boundary.GetHandle()
def __init__(self, p1: numpy.array, p2: numpy.array, p3: numpy.array): # p1, p2, p3: Three points on a circle. Cannot be colinear super().__init__() self.wire = TopoDS_Wire gp1 = OccPoint(p1) gp2 = OccPoint(p2) gp3 = OccPoint(p3) mkcircle = GC_MakeCircle(gp1.Value(), gp3.Value(), gp2.Value()) if not mkcircle.IsDone(): OCCWrapper.OccError(type(self), mkcircle) else: mkwire = BRepBuilderAPI_MakeWire(mkcircle.Value()) if not mkwire.IsDone(): OCCWrapper.OccError(type(self), mkwire) else: self.done = True self.wire = mkwire.Wire() return
def makeSqProfile(self, size): # points and segments need to be in CW sequence to get W pointing along Z p1 = gp_Pnt2d(-size, size) p2 = gp_Pnt2d(size, size) p3 = gp_Pnt2d(size, -size) p4 = gp_Pnt2d(-size, -size) seg1 = GCE2d_MakeSegment(p1, p2) seg2 = GCE2d_MakeSegment(p2, p3) seg3 = GCE2d_MakeSegment(p3, p4) seg4 = GCE2d_MakeSegment(p4, p1) e1 = BRepBuilderAPI_MakeEdge(seg1.Value(), self.plane) e2 = BRepBuilderAPI_MakeEdge(seg2.Value(), self.plane) e3 = BRepBuilderAPI_MakeEdge(seg3.Value(), self.plane) e4 = BRepBuilderAPI_MakeEdge(seg4.Value(), self.plane) aWire = BRepBuilderAPI_MakeWire(e1.Edge(), e2.Edge(), e3.Edge(), e4.Edge()) myWireProfile = aWire.Wire() return myWireProfile # TopoDS_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 makeWholeWire(event=None): global myWireProfile xAxis = gp_OX() # Set up the mirror aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) # Apply the mirror transform aBRepTrsf = BRepBuilderAPI_Transform(aWire, aTrsf) # Convert mirrored shape to a wire aMirroredShape = aBRepTrsf.Shape() aMirroredWire = topods_Wire(aMirroredShape) # Combine the two wires mkWire = BRepBuilderAPI_MakeWire() mkWire.Add(aWire) mkWire.Add(aMirroredWire) myWireProfile = mkWire.Wire() display.DisplayColoredShape(myWireProfile, 'BLUE') display.Repaint() win.statusBar().showMessage('Make whole wire complete')
def _renderWireObj(self, aWire, aWireRadius): startPoint, tangentDir = _getWireStartPointAndTangentDir(aWire) profileCircle = GC_MakeCircle(startPoint, tangentDir, aWireRadius).Value() profileEdge = BRepBuilderAPI_MakeEdge(profileCircle).Edge() profileWire = BRepBuilderAPI_MakeWire(profileEdge).Wire() shape = BRepOffsetAPI_MakePipe(aWire, profileWire).Shape() self._renderShapeObj(shape)
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())