def updateGraphicObjects(self, points, display): self.GHPolygon = [] for i in self.PolygonPoints: if i in range(len(points)): self.GHPolygon.Add(points[i].Point) else: print('polygon point %d does not exist' % i) self.GHPolygon.Close() self.GHFace = BRepBuilderAPI_MakeFace(self.GHPolygon.Wire()) self.GHShape = BRepBuilderAPI_MakeShape.Shape(self.GHFace) #display.DisplayShape(self.GHShape) if len(self.Opening) > 0: print('processing openings') for i in range(len(self.Opening)): openingpolygon = BRepBuilderAPI_MakePolygon() for j in self.Opening[i]: openingpolygon.Add(points[j].Point) openingpolygon.Close() openingface = BRepBuilderAPI_MakeFace(openingpolygon.Wire()) openingshape = BRepBuilderAPI_MakeShape.Shape(openingface) cut = BRepAlgoAPI_Cut(self.GHShape, openingshape) self.GHShape = cut.Shape() #display.DisplayShape(self.GHShape) # calculate Area Props = GProp_GProps() brepgprop.SurfaceProperties(self.GHShape, Props) self.Area = Props.Mass()
def build_plate(polygon, points): ''' build a surface from a constraining polygon(s) and point(s) @param polygon: list of polygons (TopoDS_Shape) @param points: list of points (gp_Pnt) ''' # plate surface bpSrf = GeomPlate_BuildPlateSurface(3, 15, 2) # add curve constraints for poly in polygon: for edg in WireExplorer(poly.Wire()).ordered_edges(): c = BRepAdaptor_HCurve() c.ChangeCurve().Initialize(edg) constraint = BRepFill_CurveConstraint(c.GetHandle(), 0) bpSrf.Add(constraint.GetHandle()) # add point constraint for pt in points: bpSrf.Add(GeomPlate_PointConstraint(pt, 0).GetHandle()) bpSrf.Perform() maxSeg, maxDeg, critOrder = 9, 8, 0 tol = 1e-4 dmax = max([tol, 10 * bpSrf.G0Error()]) srf = bpSrf.Surface() plate = GeomPlate_MakeApprox(srf, tol, maxSeg, maxDeg, dmax, critOrder) uMin, uMax, vMin, vMax = srf.GetObject().Bounds() face = BRepBuilderAPI_MakeFace(plate.Surface(), uMin, uMax, vMin, vMax) face.Build() return face
def makePieSlice(r, theta0, theta1, z_min, z_max): p0 = gp_Pnt(0, 0, z_min) p1 = gp_Pnt(r * cos(theta0), r * sin(theta0), z_min) p2 = gp_Pnt(r * cos(theta1), r * sin(theta1), z_min) edges = [] los = TopTools_ListOfShape() me = BRepBuilderAPI_MakeEdge(p0, p1) edges.append(me.Edge()) los.Append(me.Edge()) ax = gp_Ax2(gp_Pnt(0, 0, z_min), gp_Dir(0, 0, 1), gp_Dir(1, 0, 0)) circ = gp_Circ(ax, r) me = BRepBuilderAPI_MakeEdge(circ, theta0, theta1) edges.append(me.Edge()) los.Append(me.Edge()) me = BRepBuilderAPI_MakeEdge(p2, p0) edges.append(me.Edge()) los.Append(me.Edge()) """ mw = BRepBuilderAPI_MakeWire() for i in edges: mw.Add(i) """ mw = BRepBuilderAPI_MakeWire() mw.Add(los) pln = gp_Pln(gp_Pnt(0, 0, z_min), gp_Dir(0, 0, 1)) mf = BRepBuilderAPI_MakeFace(pln, mw.Wire()) face = mf.Face() mp = BRepPrimAPI_MakePrism(face, gp_Vec(0, 0, z_max - z_min)) return mp.Shape()
def brep_feat_local_revolution(event=None): S = BRepPrimAPI_MakeBox(400., 250., 300.).Shape() faces = list(Topo(S).faces()) F1 = faces[2] surf = BRep_Tool_Surface(F1) D = gp_OX() MW1 = BRepBuilderAPI_MakeWire() p1 = gp_Pnt2d(100., 100.) p2 = gp_Pnt2d(200., 100.) aline = GCE2d_MakeLine(p1, p2).Value() MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge()) p1 = gp_Pnt2d(200., 100.) p2 = gp_Pnt2d(150., 200.) aline = GCE2d_MakeLine(p1, p2).Value() MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge()) p1 = gp_Pnt2d(150., 200.) p2 = gp_Pnt2d(100., 100.) aline = GCE2d_MakeLine(p1, p2).Value() MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge()) MKF1 = BRepBuilderAPI_MakeFace() MKF1.Init(surf, False, 1e-6) MKF1.Add(MW1.Wire()) FP = MKF1.Face() breplib_BuildCurves3d(FP) MKrev = BRepFeat_MakeRevol(S, FP, F1, D, 1, True) F2 = faces[4] MKrev.Perform(F2) display.EraseAll() display.DisplayShape(MKrev.Shape()) display.FitAll()
def extrusion(event=None): # Make a box Box = BRepPrimAPI_MakeBox(400., 250., 300.) S = Box.Shape() # Choose the first Face of the box F = next(Topo(S).faces()) surf = BRep_Tool_Surface(F) # Make a plane from this face Pl = Handle_Geom_Plane_DownCast(surf) Pln = Pl.GetObject() # Get the normal of this plane. This will be the direction of extrusion. D = Pln.Axis().Direction() # Inverse normal #D.Reverse() # Create the 2D planar sketch MW = BRepBuilderAPI_MakeWire() p1 = gp_Pnt2d(200., -100.) p2 = gp_Pnt2d(100., -100.) aline = GCE2d_MakeLine(p1, p2).Value() Edge1 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge1.Edge()) p1 = p2 p2 = gp_Pnt2d(100., -200.) aline = GCE2d_MakeLine(p1, p2).Value() Edge2 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge2.Edge()) p1 = p2 p2 = gp_Pnt2d(200., -200.) aline = GCE2d_MakeLine(p1, p2).Value() Edge3 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge3.Edge()) p1 = p2 p2 = gp_Pnt2d(200., -100.) aline = GCE2d_MakeLine(p1, p2).Value() Edge4 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)) MW.Add(Edge4.Edge()) # Build Face from Wire. NB: a face is required to generate a solid. MKF = BRepBuilderAPI_MakeFace() MKF.Init(surf, False, 1e-6) MKF.Add(MW.Wire()) FP = MKF.Face() breplib_BuildCurves3d(FP) MKP = BRepFeat_MakePrism(S, FP, F, D, False, True) MKP.Perform(200.) # TODO MKP completes, seeing a split operation but no extrusion assert MKP.IsDone() res1 = MKP.Shape() display.EraseAll() display.DisplayColoredShape(res1, 'BLUE') display.DisplayColoredShape(FP, 'YELLOW') display.FitAll()
def update_shape(self, change): wires = [c for c in self.children() if isinstance(c, OccShape)] for i, wire in enumerate(wires): if i == 0: shape = BRepBuilderAPI_MakeFace(wire.shape.Wire()) else: shape.Add(wire.shape.Wire()) self.shape = shape
def from_wires(cls, topo: List[TopoDS_Wire], plane: Optional[gp_Pln] = None) -> TopoDS_Face: """ create face from compound of edges """ # if topo.number_of_wires() == 0: wire = BRepBuilderAPI_MakeFace() for edge in topo: wire.Add(edge) wire.Build() w = wire.Face() return w
def make_shape(self): # 1 - retrieve the data from the UIUC airfoil data page foil_dat_url = 'http://www.ae.illinois.edu/m-selig/ads/coord_seligFmt/%s.dat' % self.profile if py2: f = urllib2.urlopen(foil_dat_url) else: http = urllib3.PoolManager() f = http.urlopen('GET', foil_dat_url).data.decode() f = io.StringIO(f) plan = gp_Pln(gp_Pnt(0., 0., 0.), gp_Dir(0., 0., 1.)) # Z=0 plan / XY plan section_pts_2d = [] for line in f.readlines()[1:]: # The first line contains info only # 2 - do some cleanup on the data (mostly dealing with spaces) line = line.lstrip().rstrip().replace(' ', ' ').replace( ' ', ' ').replace(' ', ' ') data = line.split(' ') # data[0] = x coord. data[1] = y coord. # 3 - create an array of points if len(data) == 2: # two coordinates for each point section_pts_2d.append( gp_Pnt2d( float(data[0]) * self.chord, float(data[1]) * self.chord)) # 4 - use the array to create a spline describing the airfoil section spline_2d = Geom2dAPI_PointsToBSpline( point2d_list_to_TColgp_Array1OfPnt2d(section_pts_2d), len(section_pts_2d) - 1, # order min len(section_pts_2d)) # order max spline = geomapi.To3d(spline_2d.Curve(), plan) # 5 - figure out if the trailing edge has a thickness or not, # and create a Face try: # first and last point of spline -> trailing edge trailing_edge = make_edge( gp_Pnt(section_pts_2d[0].X(), section_pts_2d[0].Y(), 0.0), gp_Pnt(section_pts_2d[-1].X(), section_pts_2d[-1].Y(), 0.0)) face = BRepBuilderAPI_MakeFace( make_wire([make_edge(spline), trailing_edge])) except AssertionError: # the trailing edge segment could not be created, probably because # the points are too close # No need to build a trailing edge face = BRepBuilderAPI_MakeFace(make_wire(make_edge(spline))) # 6 - extrude the Face to create a Solid return BRepPrimAPI_MakePrism( face.Face(), gp_Vec(gp_Pnt(0., 0., 0.), gp_Pnt(0., 0., self.span))).Shape()
def make_polygon(pyptlist): array = [] for pt in pyptlist: array.append(gp_Pnt(pt[0], pt[1], pt[2])) poly = BRepBuilderAPI_MakePolygon() map(poly.Add, array) poly.Build() poly.Close() wire = poly.Wire() occface = BRepBuilderAPI_MakeFace(wire) return occface.Face()
def Solid(self): mw = BRepBuilderAPI_MakeWire() points = [] x = -self.length / 2.0 y = -self.width / 2.0 z = 0.0 points.append(gp_Pnt(x, y, z)) x = self.length / 2.0 points.append(gp_Pnt(x, y, z)) me = BRepBuilderAPI_MakeEdge(points[0], points[1]) mw.Add(me.Edge()) # bottom edge ax = gp_Ax2(gp_Pnt(x, 0, 0), gp_Dir(0, 0, 1), gp_Dir(0, -1, 0)) circ = gp_Circ(ax, self.width / 2.0) me = BRepBuilderAPI_MakeEdge(circ, 0, pi) mw.Add(me.Edge()) points = [] y = self.width / 2.0 points.append(gp_Pnt(x, y, z)) x = -self.length / 2.0 points.append(gp_Pnt(x, y, z)) me = BRepBuilderAPI_MakeEdge(points[0], points[1]) mw.Add(me.Edge()) # top edge ax = gp_Ax2(gp_Pnt(x, 0, 0), gp_Dir(0, 0, 1), gp_Dir(0, 1, 0)) circ = gp_Circ(ax, self.width / 2.0) me = BRepBuilderAPI_MakeEdge(circ, 0, pi) mw.Add(me.Edge()) mf = BRepBuilderAPI_MakeFace(mw.Wire()) mp = BRepPrimAPI_MakePrism(mf.Face(), gp_Vec(0, 0, self.thickness)) shape = mp.Shape() #v_trans = gp_Vec(self.ax2.Location().XYZ()) ax = gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1), gp_Dir(1, 0, 0)) #mainRotationAngle = ax.Angle(self.ax2) trsf = gp_Trsf() trsf.SetTransformation(gp_Ax3(self.ax2), gp_Ax3(ax)) mt = BRepBuilderAPI_Transform(shape, trsf) return mt.Shape()
def heightmap_from_image(event=None): """ takes the heightmap from a jpeg file and apply a texture this example requires numpy/matplotlib """ print("opening image") heightmap = Image.open('images/mountain_heightmap.jpg') heightmap.show() width = heightmap.size[0] height = heightmap.size[1] # create the gp_Pnt array print("parse image and fill in point array") for i in range(1, width): for j in range(1, height): # all 3 RGB values are equal, just take the first one # vertex 1 height_value = heightmap.getpixel((i - 1, j - 1))[0] v1 = gp_Pnt(i, j, float(height_value) / 10) # vertex 2 height_value = heightmap.getpixel((i, j - 1))[0] v2 = gp_Pnt(i + 1, j, float(height_value) / 10) # vertex 3 height_value = heightmap.getpixel((i, j))[0] v3 = gp_Pnt(i + 1, j + 1, float(height_value) / 10) # vertex 4 height_value = heightmap.getpixel((i - 1, j))[0] v4 = gp_Pnt(i, j + 1, float(height_value) / 10) # boundaries b1 = boundary_curve_from_2_points(v1, v2) b2 = boundary_curve_from_2_points(v2, v3) b3 = boundary_curve_from_2_points(v3, v4) b4 = boundary_curve_from_2_points(v4, v1) # bConstrainedFilling = GeomFill_ConstrainedFilling(8, 2) bConstrainedFilling.Init(b1, b2, b3, b4, False) srf1 = bConstrainedFilling.Surface() # make a face from this srf patch = BRepBuilderAPI_MakeFace() bounds = True toldegen = 1e-6 patch.Init(srf1, bounds, toldegen) patch.Build() display.DisplayShape(patch.Face()) # then create faces print("%s%%" % int(float(i) / width * 100)) #display.process_events() display.FitAll() # finally display image heightmap.show()
def add_wire_to_face(face, wire, reverse=False): """ apply a wire to a face use reverse to set the orientation of the wire to opposite @param face: @param wire: @param reverse: """ faceb = BRepBuilderAPI_MakeFace(face) if reverse: wire.Reverse() faceb.Add(wire) result = faceb.Face() faceb.Delete() return 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.GetHandle(), gp_Vec(0., 10., 0.), gp_Vec(0., 0., 0.), 1, True) aform.Perform() display.DisplayShape(aform.Shape()) display.FitAll()
def get_gordon_surface(self): if self.gordon_surface is not None: return self.gordon_surface s = tigl3.surface_factories.interpolate_curve_network([self.curve1, self.curve2, self.curve3], [self.te_up, self.le, self.te_lo]) self.gordon_surface = BRepBuilderAPI_MakeFace(s, 1e-6).Face() return self.surface_skin
def pipe_fillet(radius): # the points p1 = gp_Pnt(0, 0, 0) p2 = gp_Pnt(0, 1, 0) p3 = gp_Pnt(1, 2, 0) p4 = gp_Pnt(2, 2, 0) # the edges ed1 = BRepBuilderAPI_MakeEdge(p1, p2).Edge() ed2 = BRepBuilderAPI_MakeEdge(p2, p3).Edge() ed3 = BRepBuilderAPI_MakeEdge(p3, p4).Edge() # inbetween fillet12 = filletEdges(ed1, ed2) fillet23 = filletEdges(ed2, ed3) # the wire makeWire = BRepBuilderAPI_MakeWire() makeWire.Add(ed1) makeWire.Add(fillet12) makeWire.Add(ed2) makeWire.Add(fillet23) makeWire.Add(ed3) makeWire.Build() wire = makeWire.Wire() # the pipe dir = gp_Dir(0, 1, 0) circle = gp_Circ(gp_Ax2(p1, dir), radius) profile_edge = BRepBuilderAPI_MakeEdge(circle).Edge() profile_wire = BRepBuilderAPI_MakeWire(profile_edge).Wire() profile_face = BRepBuilderAPI_MakeFace(profile_wire).Face() pipe = BRepOffsetAPI_MakePipe(wire, profile_face).Shape() #display.DisplayShape(pipe, update=True) return (pipe)
def get_skinned_surface(self): if self.surface_skin is not None: return self.surface_skin s = tigl3.surface_factories.interpolate_curves([self.curve1, self.curve2, self.curve3]) self.surface_skin = BRepBuilderAPI_MakeFace(s, 1e-6).Face() return self.surface_skin
def srf_nrml_facing_solid_inward(occ_face, occ_solid): #move the face in the direction of the normal #first offset the face so that vert will be within the solid o_wire = Construct.make_offset(occ_face, 0.0001) o_face = BRepBuilderAPI_MakeFace(o_wire).Face() wire_list = list(Topology.Topo(o_face).wires()) occpt_list = [] for wire in wire_list: occpts = Topology.WireExplorer(wire).ordered_vertices() occpt_list.extend(occpts) pt = BRep_Tool.Pnt(occpt_list[0]) #a point that is on the edge of the face normal = face_normal(occ_face) gp_direction2move = gp_Vec(normal[0], normal[1], normal[2]) gp_moved_pt = pt.Translated(gp_direction2move.Multiplied(0.001)) mv_pt = (gp_moved_pt.X(), gp_moved_pt.Y(), gp_moved_pt.Z()) in_solid = point_in_solid(occ_solid, mv_pt) if in_solid: return True else: return False
def wire_frm_loose_edges(occedge_list): ''' the edges need to be able to form a close face. IT does not work with a group of open edges need to change name to face from loose edges ''' edges = TopTools_HSequenceOfShape() edges_handle = Handle_TopTools_HSequenceOfShape(edges) wires = TopTools_HSequenceOfShape() wires_handle = Handle_TopTools_HSequenceOfShape(wires) # The edges are copied to the sequence for edge in occedge_list: edges.Append(edge) # A wire is formed by connecting the edges ShapeAnalysis_FreeBounds.ConnectEdgesToWires(edges_handle, 1e-20, True, wires_handle) wires = wires_handle.GetObject() # From each wire a face is created face_list = [] for i in range(wires.Length()): wire_shape = wires.Value(i + 1) wire = fetch.shape2shapetype(wire_shape) face = BRepBuilderAPI_MakeFace(wire).Face() if not face.IsNull(): face_list.append(face) return face_list
def split_edge_with_face(event=None): display.EraseAll() p0 = gp_Pnt() vnorm = gp_Dir(1, 0, 0) pln = gp_Pln(p0, vnorm) face = BRepBuilderAPI_MakeFace(pln, -10, 10, -10, 10).Face() p1 = gp_Pnt(0, 0, 15) p2 = gp_Pnt(0, 0, -15) edge = BRepBuilderAPI_MakeEdge(p1, p2).Edge() # Initialize splitter splitter = GEOMAlgo_Splitter() # Add the edge as an argument and the face as a tool. This will split # the edge with the face. splitter.AddArgument(edge) splitter.AddTool(face) splitter.Perform() edges = [] exp = TopExp_Explorer(splitter.Shape(), TopAbs_EDGE) while exp.More(): edges.append(exp.Current()) exp.Next() print('Number of edges in split shape: ', len(edges)) display.DisplayShape(edges[0], color='red') display.DisplayShape(edges[1], color='green') display.DisplayShape(edges[2], color='yellow') display.FitAll()
def makeFromWires(cls, outerWire, innerWires=[]): ''' Makes a planar face from one or more wires ''' face_builder = BRepBuilderAPI_MakeFace(outerWire.wrapped, True) # True is for planar only for w in innerWires: face_builder.Add(w.wrapped) face_builder.Build() f = face_builder.Face() sf = ShapeFix_Face(f) # fix wire orientation sf.FixOrientation() return cls(sf.Face())
def slicer(event=None): # Param Zmin, Zmax, deltaZ = -100, 100, 5 # Note: the shape can also come from a shape selected from InteractiveViewer if 'display' in dir(): shape = display.GetSelectedShape() else: # Create the shape to slice shape = BRepPrimAPI_MakeSphere(60.).Shape() # Define the direction D = gp_Dir(0., 0., 1.) # the z direction # Perform slice sections = [] init_time = time.time() # for total time computation for z in range(Zmin, Zmax, deltaZ): # Create Plane defined by a point and the perpendicular direction P = gp_Pnt(0, 0, z) Pln = gp_Pln(P, D) face = BRepBuilderAPI_MakeFace(Pln).Shape() # Computes Shape/Plane intersection section_shp = BRepAlgoAPI_Section(shape, face) if section_shp.IsDone(): sections.append(section_shp) total_time = time.time() - init_time print("%.3fs necessary to perform slice." % total_time) display.EraseAll() display.DisplayShape(shape) for section_ in sections: display.DisplayShape(section_.Shape()) display.FitAll()
def makeFacefromWire(wire): """ Create face from Wire""" face = BRepBuilderAPI_MakeFace(wire.Wire()) if args.v >= 1: print('Face are created') return face
def create_cutting_plane_xz(y_pos, bounding_box): """Creates a face in the x-z plane at a given y-position. :param y_pos: y position :type y_pos: float :param bounding_box: Surrounding box of the wing :type bounding_box: instance of OCC.Bnd.Bnd_Box :return: face :rtype: instance of OCC.TopoDS.TopoDS_Face or None """ plane = gp_Pln(gp_Pnt(0, y_pos, 0), gp_Dir(0, 1, 0)) face_builder = BRepBuilderAPI_MakeFace(plane) if face_builder.IsDone(): return face_builder.Face() else: raise Exception('Could not build face') return None
def build(input, output): #sample xml for testing xml = "<eagle version=\"7\"><drawing><board><plain><wire x1=\"0\" y1=\"0\" x2=\"0\" y2=\"2\" width=\"0.254\" layer=\"20\"/><wire x1=\"0\" y1=\"2\" x2=\"1.5\" y2=\"2\" width=\"0.254\" layer=\"20\"/><wire x1=\"1.5\" y1=\"2\" x2=\"1\" y2=\"0\" width=\"0.254\" layer=\"20\"/><wire x1=\"1\" y1=\"0\" x2=\"0\" y2=\"0\" width=\"0.254\" layer=\"20\"/></plain></board></drawing></eagle>" #xmldoc = minidom.parseString( xml ) xmldoc = minidom.parse(input) wires = xmldoc.getElementsByTagName('wire') makeWire = BRepBuilderAPI_MakeWire() for wire in wires: if wire.attributes['layer'].value == '20': x1 = float(wire.attributes['x1'].value) y1 = float(wire.attributes['y1'].value) x2 = float(wire.attributes['x2'].value) y2 = float(wire.attributes['y2'].value) #print('Building edge from {}, {} to {}, {}'.format( x1,y1,x2,y2)) edge = BRepBuilderAPI_MakeEdge( gp_Pnt( x1, y1, 0.0 ), \ gp_Pnt( x2, y2, 0.0 ) \ ) makeWire.Add(edge.Edge()) face = BRepBuilderAPI_MakeFace(makeWire.Wire()) #vector & height vector = gp_Vec(0, 0, .1) body = BRepPrimAPI_MakePrism(face.Face(), vector) # initialize the STEP exporter step_writer = STEPControl_Writer() Interface_Static_SetCVal("write.step.schema", "AP203") # transfer shapes and write file step_writer.Transfer(body.Shape(), STEPControl_AsIs) status = step_writer.Write(output) if status != IFSelect_RetDone: raise AssertionError("load failed")
def region_as_splinegon(boundary_splines): """Represents a region as a splinegon. Based on the combined topological-geometrical (intermediate) representation of the regions, (done by :func:`skeleton2regions`), this function provides a fully geometrical description of a region. Parameters ---------- boundary_splines : list Each element of the list is a `Handle_Geom_BSplineCurve` object, giving a reference to the B-splines bounding the region. The splines must either be ordered (see :func:`branches2boundary`) or they must appear in an order such that the n-th spline in the list can be connected to one of the first n-1 splines in the list. Returns ------- splinegon : TopoDS_Face The resulting splinegon (surface). For details on the object, see the OpenCASCADE API: https://www.opencascade.com/doc/occt-7.4.0/refman/html/class_topo_d_s___face.html boundary : TopoDS_Wire The boundary of the splinegon. For details on the resulting object, see the OpenCASCADE API: https://www.opencascade.com/doc/occt-7.4.0/refman/html/class_topo_d_s___wire.html See Also -------- skeleton2regions fit_spline Notes ----- The syntax `Handle_classname` in PythonOCC corresponds to wrapping the object of class `classname` with a smart pointer. In the C++ interface, it is done by a template: `Handle<classname>`. """ # Combine the splines so that they form the boundary (a collection of joining splines) boundary = BRepBuilderAPI_MakeWire() for spline in boundary_splines: edge = BRepBuilderAPI_MakeEdge(spline).Edge() boundary.Add(edge) _wire_error(boundary.Error()) # The planar surface (face) is stretched by the wire splinegon = BRepBuilderAPI_MakeFace(boundary.Wire()) _face_error(splinegon.Error()) return splinegon.Face(), boundary.Wire()
def from_wire(cls, topo: Union[Topo, TopoDS_Shape], plane: Optional[gp_Pln] = None) -> TopoDS_Face: """ create face from compound of edges """ # if topo.number_of_wires() == 0: from .Construct import assert_isdone wire_builder = BRepBuilderAPI_MakeWire() if isinstance(topo, TopoDS_Shape): top = Topo(topo) else: top = topo for edge in top.edges(): wire_builder.Add(edge) with assert_isdone(wire_builder, 'wire'): wire_builder.Build() w = wire_builder.Wire() if plane is not None: bface = BRepBuilderAPI_MakeFace(plane) else: # todo - this doesnt work ---- _face = TopoDS_Face() bface = BRepBuilderAPI_MakeFace(_face) bface.Add(w) with assert_isdone(bface, 'face'): bface.Build() face = bface.Shape() return face
def face(): #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.00001, 40), gp_Pnt(0, 0, 80)) ##TopoDS_Wire YellowWire MW1 = BRepBuilderAPI_MakeWire(Edge1.Edge(), Edge2.Edge(), Edge3.Edge()) print MW1.IsDone() if MW1.IsDone(): yellow_wire = MW1.Wire() brown_face = BRepBuilderAPI_MakeFace(yellow_wire) display.DisplayColoredShape(brown_face.Face(), 'BLUE')
def makePlane(cls, length, width, basePnt=(0, 0, 0), dir=(0, 0, 1)): basePnt = Vector(basePnt) dir = Vector(dir) pln_geom = gp_Pln(basePnt.toPnt(), dir.toDir()) return cls( BRepBuilderAPI_MakeFace(pln_geom, -width * 0.5, width * 0.5, -length * 0.5, length * 0.5).Face())
def draw3D(self, spaces, displaySize = (1024, 768), update = False): """ draw3D(aecSpaceGroup) Accepts an aecSpaceGroup object and renders its list of aecSpaces to the pythonOCC display. Returns True on success failure. Returns False on failure. """ try: if not spaces: return False if type(spaces) != list: spaces = spaces.spaces if not spaces: return False __display, __start_display, __add_menu, __add_function_to_menu = init_display('qt-pyqt5', size = displaySize) for space in spaces: points = self.makePoints(space) if not points: continue pointPairs = self.makePointPairs(points) if not pointPairs: continue edges = self.makeEdges(pointPairs) if not edges: continue wire = self.makeWire(edges) if not wire.IsDone: continue #if not wire: continue face = BRepBuilderAPI_MakeFace(wire.Wire()) if not face: continue vector = gp_Vec(0, 0, space.height) spaceVolume = BRepPrimAPI_MakePrism(face.Face(), vector).Shape() if not spaceVolume: continue displayColor = space.color.color_01 spaceColor = OCC.Quantity.Quantity_Color_Name( displayColor[0], displayColor[1], displayColor[2]) __display.DisplayShape( spaceVolume, color = spaceColor, transparency = space.color.alpha_01, update = update) __display.FitAll() __start_display() __display = None return True except Exception: traceback.print_exc() return False
def update_shape(self, change): d = self.declaration if d.wires: wires = d.wires else: wires = [c for c in self.children() if isinstance(c, OccShape)] if not wires: raise ValueError("No wires or children available to " "create a face!") for i, wire in enumerate(wires): if hasattr(wire, 'shape'): args = (wire.shape.Wire(), ) else: args = (wire, ) if i == 0: shape = BRepBuilderAPI_MakeFace(*args) else: shape.Add(*args) self.shape = shape