def makeEllipticalAnnularSolid(rx_outer, ry_outer, rx_inner, ry_inner, z_min, z_max): # Make the outer part of the clamp ax = gp_Ax2(gp_Pnt(0, 0, z_min), gp_Dir(0, 0, 1), gp_Dir(1, 0, 0)) ge = Geom_Ellipse(ax, rx_outer, ry_outer) elip = ge.Elips() me = BRepBuilderAPI_MakeEdge(elip, 0, 2 * pi) edge = me.Edge() mw = BRepBuilderAPI_MakeWire(edge) wire = mw.Wire() pln = gp_Pln(gp_Pnt(0, 0, z_min), gp_Dir(0, 0, 1)) mf = BRepBuilderAPI_MakeFace(pln, wire) face = mf.Face() mp = BRepPrimAPI_MakePrism(face, gp_Vec(0, 0, z_max - z_min)) body = mp.Shape() # Make the cutter for the inner hole body ax = gp_Ax2(gp_Pnt(0, 0, z_min - 1), gp_Dir(0, 0, 1), gp_Dir(1, 0, 0)) ge = Geom_Ellipse(ax, rx_inner, ry_inner) elip = ge.Elips() me = BRepBuilderAPI_MakeEdge(elip, 0, 2 * pi) edge = me.Edge() mw = BRepBuilderAPI_MakeWire(edge) wire = mw.Wire() pln = gp_Pln(gp_Pnt(0, 0, z_min - 1), gp_Dir(0, 0, 1)) mf = BRepBuilderAPI_MakeFace(pln, wire) face = mf.Face() mp = BRepPrimAPI_MakePrism(face, gp_Vec(0, 0, z_max + 1)) innerHoleCutter = mp.Shape() # Cut out the middle mc = BRepAlgoAPI_Cut(body, innerHoleCutter) return mc.Shape()
def update_shape(self, change): d = self.declaration if d.shape: c = d.shape.proxy else: c = self.get_shape() if d.infinite: self.shape = BRepPrimAPI_MakePrism(c.shape.Shape(), d.direction, True, d.copy, d.canonize) else: self.shape = BRepPrimAPI_MakePrism(c.shape.Shape(), gp_Vec(*d.vector), d.copy, d.canonize)
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 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 prism(): # the bspline profile 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 = BRepBuilderAPI_MakeEdge(bspline).Edge() # the linear path starting_point = gp_Pnt(0., 0., 0.) end_point = gp_Pnt(0., 0., 6.) vec = gp_Vec(starting_point, end_point) path = BRepBuilderAPI_MakeEdge(starting_point, end_point).Edge() # extrusion prism = BRepPrimAPI_MakePrism(profile, vec).Shape() display.DisplayShape(profile, update=False) display.DisplayShape(starting_point, update=False) display.DisplayShape(end_point, update=False) display.DisplayShape(path, update=False) display.DisplayShape(prism, update=True)
def extrudeLinear(cls, outerWire, innerWires, vecNormal): """ Attempt to extrude the list of wires into a prismatic solid in the provided direction :param outerWire: the outermost wire :param innerWires: a list of inner wires :param vecNormal: a vector along which to extrude the wires :return: a Solid object The wires must not intersect Extruding wires is very non-trivial. Nested wires imply very different geometry, and there are many geometries that are invalid. In general, the following conditions must be met: * all wires must be closed * there cannot be any intersecting or self-intersecting wires * wires must be listed from outside in * more than one levels of nesting is not supported reliably This method will attempt to sort the wires, but there is much work remaining to make this method reliable. """ # one would think that fusing faces into a compound and then extruding would work, # but it doesnt-- the resulting compound appears to look right, ( right number of faces, etc), # but then cutting it from the main solid fails with BRep_NotDone. # the work around is to extrude each and then join the resulting solids, which seems to work # FreeCAD allows this in one operation, but others might not face = Face.makeFromWires(outerWire, innerWires) prism_builder = BRepPrimAPI_MakePrism(face.wrapped, vecNormal.wrapped, True) return cls(prism_builder.Shape())
def make_prism(profile, vec): """ makes a finite prism """ pri = BRepPrimAPI_MakePrism(profile, vec, True) with assert_isdone(pri, 'failed building prism'): pri.Build() return pri.Shape()
def make_extrusion(face, length, vector=gp_Vec(0., 0., 1.)): ''' creates a extrusion from a face, along the vector vector. with a distance legnth. Note that the normal vector does not necessary be normalized. By default, the extrusion is along the z axis. ''' vector.Normalize() vector.Scale(length) return BRepPrimAPI_MakePrism(face, vector).Shape()
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 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 shape_base_drain(): ''' output s: TopoDS_Shape ''' wire = wire_circle() trsf = gp_Trsf() trsf.SetScale(DRAIN_RCS.Location(), DRAIN_R) bresp_trsf = BRepBuilderAPI_Transform(wire, trsf) wire = topods.Wire(bresp_trsf.Shape()) base_face = BRepBuilderAPI_MakeFace(wire).Face() shape = BRepPrimAPI_MakePrism(base_face, gp_Vec(0, 0, DRAIN_T)).Shape() return shape
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 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 draw(self, display, c): #self.out() pol = self.curve.polygon() if pol != None: pol = pol.Wire() n = Vector(0, 0, 1) n.scale(self.height) n = n.gpV() prism = BRepPrimAPI_MakePrism(pol, n).Shape() if c == 0: color = 'YELLOW' elif c == 1: color = 'BLUE' elif c == 2: color = 'GREEN' elif c == 3: color = 'BLACK' elif c == 4: color = 'RED' elif c == 5: color = 'WHITE' elif c == 6: color = 'CYAN' else: color = 'ORANGE' display.DisplayColoredShape(prism, color, update=True)
def draw(self,display,c) : pol=self.curve.polygon() if pol!=None: pol=pol.Wire() n=copy.copy(self.normal) n.scale(self.thickness) n=n.gpV() face=BRepBuilderAPI_MakeFace(pol,True).Face() #my_shell = BRepPrimAPI_MakePrism(my_pol,n1).Shape() prism = BRepPrimAPI_MakePrism(face,n).Shape() if c==0: color='YELLOW' elif c==1: color='BLUE' elif c==2: color='GREEN' elif c==3: color='BLACK' elif c==4: color='RED' elif c==5: color='WHITE' elif c==6: color='CYAN' else: color='ORANGE' display.DisplayColoredShape(prism,color, update=True)
def gen_boxSolidAsTable(width=1000, depth=1000, height=1215): pntList = [ gp_Pnt(width / 2., depth / 2., 0), gp_Pnt(-width / 2., depth / 2., 0), gp_Pnt(-width / 2., -depth / 2., 0), gp_Pnt(width / 2., -depth / 2., 0) ] edgList = [] for i in range(0, len(pntList) - 1): edgList.append(BRepBuilderAPI_MakeEdge(pntList[i], pntList[i + 1])) edgList.append(BRepBuilderAPI_MakeEdge(pntList[3], pntList[0])) wire = BRepBuilderAPI_MakeWire() for i in edgList: wire.Add(i.Edge()) wireProfile = wire.Wire() faceProfile = BRepBuilderAPI_MakeFace(wireProfile).Shape() aPrismVec = gp_Vec(0, 0, height) return BRepPrimAPI_MakePrism(faceProfile, aPrismVec).Shape()
def ExtrudeFace(face, vec=gp_Vec(1, 0, 0)): """Extrudes a face by input vector Parameters ---------- face : TopoDS_Face vec : OCC.gp.gp_Vec The offset vector to extrude through Returns ------- shape : TopoDS_Shape The extruded shape Notes ----- Uses BRepBuilderAPI_MakePrism """ from OCC.BRepPrimAPI import BRepPrimAPI_MakePrism builder = BRepPrimAPI_MakePrism(face, vec) builder.Build() return builder.Shape()
def build_test(path): #points pt1 = gp_Pnt(0, 0, 0) pt2 = gp_Pnt(0, 2, 0) pt3 = gp_Pnt(1.5, 2, 0) pt4 = gp_Pnt(1, 0, 0) edge1 = BRepBuilderAPI_MakeEdge(pt1, pt2) edge2 = BRepBuilderAPI_MakeEdge(pt2, pt3) edge3 = BRepBuilderAPI_MakeEdge(pt3, pt4) edge4 = BRepBuilderAPI_MakeEdge(pt4, pt1) #make wire with 4 edges wire = BRepBuilderAPI_MakeWire(edge1.Edge(), edge2.Edge(), edge3.Edge(), edge4.Edge()) #alternate wire. create and then add in #makeWire = BRepBuilderAPI_MakeWire() #makeWire.add( wire ) #wireProfile = makeWire.Wire() face = BRepBuilderAPI_MakeFace(wire.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(path) if status != IFSelect_RetDone: raise AssertionError("load failed")
def makePrismFromFace(aFace, eDir): return BRepPrimAPI_MakePrism( aFace, gp_Vec(gp_Pnt(0., 0., 0.), gp_Pnt(eDir[0], eDir[1], eDir[2]))).Shape()
def char_to_solid(self, glyph): layer = glyph.layers['Fore'] bodies = [] for contour in layer: i = 0 total = len(contour) curve_points = [] if total <= 2: # Can't make solid out of 1 or 2 points continue wire = BRepBuilderAPI_MakeWire() for point in contour: if point.on_curve: if i > 0: # Complete old curve curve_points.append(gp_Pnt(point.x, point.y, 0)) self.add_to_wire(curve_points, wire) if i < total: # Start new curve curve_points = [gp_Pnt(point.x, point.y, 0)] if i == total-1: first = contour[0] curve_points.append(gp_Pnt(first.x, first.y, 0)) self.add_to_wire(curve_points, wire) else: curve_points.append(gp_Pnt(point.x, point.y, 0)) if i == total-1: first = contour[0] curve_points.append(gp_Pnt(first.x, first.y, 0)) self.add_to_wire(curve_points, wire) i += 1 face = BRepBuilderAPI_MakeFace(wire.Wire()) extrusion_vector = gp_Vec(0, 0, self.thickness) prism = BRepPrimAPI_MakePrism(face.Shape(), extrusion_vector) bodies.append(dict( prism = prism, isClockwise = contour.isClockwise(), )) if len(bodies) > 0: if len(bodies) == 1: return bodies[0]['prism'].Shape() elif len(bodies) > 1: final = None positive_union = None for body in bodies: if body['isClockwise'] == 1: if positive_union: positive_union = BRepAlgoAPI_Fuse( positive_union.Shape(), body['prism'].Shape()) else: positive_union = body['prism'] negative_union = None for body in bodies: if body['isClockwise'] == 0: if negative_union: negative_union = BRepAlgoAPI_Fuse( negative_union.Shape(), body['prism'].Shape()) else: negative_union = body['prism'] if positive_union and negative_union: final = BRepAlgoAPI_Cut( positive_union.Shape(), negative_union.Shape()) elif positive_union: final = positive_union elif negative_union: final = negative_union return final.Shape()
def create_shape(self): d = self.declaration self.shape = BRepPrimAPI_MakePrism(d.shape, d.direction, d.infinite, d.copy, d.canonize)
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() Proxy(trimmed_base).Reverse() # just a trick p0 = Proxy(trimmed_base).StartPoint() p1 = Proxy(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: 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 = Handle_Geom2d_TrimmedCurve.DownCast( Proxy(trimmed_base).Copy()) mirror_profile = Handle_Geom2d_TrimmedCurve.DownCast( Proxy(trimmed_profile).Copy()) mirror_outer = Handle_Geom2d_TrimmedCurve.DownCast( Proxy(trimmed_outer).Copy()) Proxy(mirror_base).Mirror(mirror_axis) Proxy(mirror_profile).Mirror(mirror_axis) Proxy(mirror_outer).Mirror(mirror_axis) Proxy(mirror_base).Reverse() Proxy(mirror_profile).Reverse() Proxy(mirror_outer).Reverse() # Replace the two outer arcs with a single one outer_start = Proxy(trimmed_outer).StartPoint() outer_mid = Proxy(trimmed_outer).EndPoint() outer_end = Proxy(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() Proxy(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 = Proxy(mirror_base).EndPoint() p5 = Proxy(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 = Proxy(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 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() Proxy(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 makeStringerWithContinuousSlot(): thickness = 5.0 width = 25.0 slot_width = 5.0 slot_depth = thickness / 4.0 length = 150.0 points = [] x = 0 y = 0 z = 0 x = thickness / 2.0 y = -width / 2.0 points.append(gp_Pnt(x, y, z)) # bottom right corner y = -slot_width / 2.0 points.append(gp_Pnt(x, y, z)) x = x - slot_depth points.append(gp_Pnt(x, y, z)) y = slot_width / 2.0 points.append(gp_Pnt(x, y, z)) x = x + slot_depth points.append(gp_Pnt(x, y, z)) y = width / 2.0 # top right corner points.append(gp_Pnt(x, y, z)) x = -thickness / 2.0 # top left corner points.append(gp_Pnt(x, y, z)) y = slot_width / 2.0 points.append(gp_Pnt(x, y, z)) x = x + slot_depth points.append(gp_Pnt(x, y, z)) y = -slot_width / 2.0 points.append(gp_Pnt(x, y, z)) x = x - slot_depth points.append(gp_Pnt(x, y, z)) y = -width / 2.0 points.append(gp_Pnt(x, y, z)) # bottom left corner x = thickness / 2.0 points.append(gp_Pnt(x, y, z)) # back to the bottom right corner mw = BRepBuilderAPI_MakeWire() for i in range(len(points) - 1): me = BRepBuilderAPI_MakeEdge(points[i], points[i + 1]) edge = me.Edge() mw.Add(edge) mf = BRepBuilderAPI_MakeFace(mw.Wire()) mp = BRepPrimAPI_MakePrism(mf.Face(), gp_Vec(0, 0, length)) return mp.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 # Create the neck of the bottle neckLocation = gp_Pnt(0, 0, height)