def curves2d_from_offset(event=None): ''' @param display: ''' pnt2d_array = TColgp_Array1OfPnt2d(1, 5) pnt2d_array.SetValue(1, gp_Pnt2d(-4, 0)) pnt2d_array.SetValue(2, gp_Pnt2d(-7, 2)) pnt2d_array.SetValue(3, gp_Pnt2d(-6, 3)) pnt2d_array.SetValue(4, gp_Pnt2d(-4, 3)) pnt2d_array.SetValue(5, gp_Pnt2d(-3, 5)) spline_1 = Geom2dAPI_PointsToBSpline(pnt2d_array).Curve() dist = 1 offset_curve1 = Geom2d_OffsetCurve(spline_1, dist) result = offset_curve1.IsCN(2) print("Offset curve yellow is C2: %r" % result) dist2 = 1.5 offset_curve2 = Geom2d_OffsetCurve(spline_1, dist2) result2 = offset_curve2.IsCN(2) print("Offset curve blue is C2: %r" % result2) display.DisplayShape(spline_1) display.DisplayShape(offset_curve1, color='YELLOW') display.DisplayShape(offset_curve2, color='BLUE', update=True)
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(TopologyExplorer(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.FitAll()
def testAutoImportOfDependentModules(self): """ Test: automatic import of dependent modules """ returned_object = GCE2d_MakeSegment(gp_Pnt2d(1, 1), gp_Pnt2d(3, 4)).Value() # for this unittest, don't use the issinstance() function, # since the OCC.Geom2d module # is *not* manually imported returned_object_type = '%s' % type(returned_object) self.assertEqual(returned_object_type, "<class 'OCC.Core.Geom2d.Handle_Geom2d_TrimmedCurve'>")
def test_auto_import_of_dependent_modules(self) -> None: """ Test: automatic import of dependent modules """ returned_object = GCE2d_MakeSegment(gp_Pnt2d(1, 1), gp_Pnt2d(3, 4)).Value() # for this unittest, don't use the issinstance() function, # since the OCC.Geom2d module # is *not* manually imported returned_object_type = '%s' % type(returned_object) self.assertEqual(returned_object_type, "<class 'OCC.Core.Geom2d.Geom2d_TrimmedCurve'>")
def bisect_pnt(event=None): display.EraseAll() p1 = gp_Pnt2d(1, 0.5) p2 = gp_Pnt2d(0, 1e5) bi = GccAna_Pnt2dBisec(p1, p2) bisec = bi.ThisSolution() # enum GccInt_Lin, GccInt_Cir, GccInt_Ell, GccInt_Par, GccInt_Hpr, GccInt_Pnt p1_ = make_vertex(gp_Pnt(p1.X(), p1.Y(), 0)) p2_ = make_vertex(gp_Pnt(p2.X(), p2.Y(), 0)) display.DisplayShape([p1_, p2_]) display.DisplayColoredShape(make_edge2d(bisec), 'BLUE') display.FitAll()
def bisect_lineline(event=None): display.EraseAll() li1 = gp_Lin2d(gp_Pnt2d(), gp_Dir2d(1, 0)) li2 = gp_Lin2d(gp_Pnt2d(), gp_Dir2d(0, 1)) bi = GccAna_Lin2dBisec(li1, li2) bi_li1 = bi.ThisSolution(1) bi_li2 = bi.ThisSolution(2) for i in [li1, li2]: display.DisplayShape(make_edge2d(i)) for i in [bi_li1, bi_li2]: display.DisplayColoredShape(make_edge2d(i), 'BLUE') display.FitAll()
def faircurve(event=None): pt1 = gp_Pnt2d(0., 0.) pt2 = gp_Pnt2d(0., 120.) height = 100. pl = Geom_Plane(gp_Pln()) for i in range(0, 40): # TODO: the parameter slope needs to be visualized slope = i/100. bc = batten_curve(pt1, pt2, height, slope, math.radians(i), math.radians(-i)) display.EraseAll() edge = BRepBuilderAPI_MakeEdge(bc, pl).Edge() display.DisplayShape(edge, update=True) time.sleep(0.21)
def uniformdeflection_on_BSplineLst(BSplineLst, deflection): """ distributes Points and NormalVectors on Geom2d_BSplineLst such that the concentration is higher in regions of high curvature """ PntLst = [] VecLst = [] for item in BSplineLst: if isinstance(item,Geom_BSplineCurve): print('ERROR: Argument must be a Geom2d_BSplineLst') Adaptor = Geom2dAdaptor_Curve(item) discretization = GCPnts_UniformDeflection(Adaptor,deflection) NbPoints = discretization.NbPoints() for j in range(1, NbPoints+1): para = discretization.Parameter(j) Pnt2d = gp_Pnt2d() Vec2d = gp_Vec2d() item.D1(para, Pnt2d, Vec2d) PntLst.append(Pnt2d) VecLst.append(Vec2d.GetNormal()) return (PntLst, VecLst)
def _calc_cubic_parabola_point(self, lpt, L, R, ccw): x = lpt y = math.pow(x, 3) / (6 * R * L) if not ccw: y = -y return gp_Pnt2d(x, y)
def cline_gen(self, cline): '''Generate a cline extending to the edge of the border. cline coords (a,b,c) are in (mm) values.''' self.clList.append(cline) # TopLft & BotRgt corners of the border trimbox = (-self.size, self.size, self.size, -self.size) endpts = cline_box_intrsctn(cline, trimbox) if len(endpts) == 2: ep1, ep2 = endpts aPnt1 = gp_Pnt2d(ep1[0], ep1[1]) aPnt2 = gp_Pnt2d(ep2[0], ep2[1]) aSegment = GCE2d_MakeSegment( aPnt1, aPnt2).Value() #type: Handle_Geom2d_TrimmedCurve # convert 2d line segment to 3d line aLine = geomapi_To3d(aSegment, self.gpPlane) # type: Handle_Geom_Curve self.clineList.append(aLine)
def gen_data_spline_2d(self, dat, ratio=1.0): num = dat.shape[0] pts = TColgp_Array1OfPnt2d(1, num) for i, xyz in enumerate(dat): pnt = gp_Pnt2d(xyz[0], xyz[1]) pts.SetValue(i+1, pnt) geo_spl = Geom2dAPI_PointsToBSpline(pts) return geo_spl
def test_circles2d_from_curves(self): '''Test: circles2d from curves''' P1 = gp_Pnt2d(9, 6) P2 = gp_Pnt2d(10, 4) P3 = gp_Pnt2d(6, 7) C = gce_MakeCirc2d(P1, P2, P3).Value() QC = gccent_Outside(C) P4 = gp_Pnt2d(-2, 7) P5 = gp_Pnt2d(12, -3) L = GccAna_Lin2d2Tan(P4, P5, precision_Confusion()).ThisSolution(1) QL = gccent_Unqualified(L) radius = 2. TR = GccAna_Circ2d2TanRad(QC, QL, radius, precision_Confusion()) if TR.IsDone(): NbSol = TR.NbSolutions() for k in range(1, NbSol+1): circ = TR.ThisSolution(k) # find the solution circle pnt1 = gp_Pnt2d() parsol, pararg = TR.Tangency1(k, pnt1) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the first tangent point pnt2 = gp_Pnt2d() parsol, pararg = TR.Tangency2(k, pnt2) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the second tangent point aLine = GCE2d_MakeSegment(L, -2, 20).Value() self.assertIsInstance(aLine, Geom2d_TrimmedCurve) if TR.IsDone(): NbSol = TR.NbSolutions() for k in range(1, NbSol+1): circ = TR.ThisSolution(k) aCircle = Geom2d_Circle(circ) self.assertIsInstance(aCircle, Geom2d_Circle) # find the solution circle (index, outvalue, outvalue, gp_Pnt2d) pnt3 = gp_Pnt2d() parsol, pararg = TR.Tangency1(k, pnt3) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the first tangent point pnt4 = gp_Pnt2d() parsol, pararg = TR.Tangency2(k, pnt4) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.)
def test_circles2d_from_curves(self): '''Test: circles2d from curves''' P1 = gp_Pnt2d(9, 6) P2 = gp_Pnt2d(10, 4) P3 = gp_Pnt2d(6, 7) C = gce_MakeCirc2d(P1, P2, P3).Value() QC = gccent_Outside(C) P4 = gp_Pnt2d(-2, 7) P5 = gp_Pnt2d(12, -3) L = GccAna_Lin2d2Tan(P4, P5, precision_Confusion()).ThisSolution(1) QL = gccent_Unqualified(L) radius = 2. TR = GccAna_Circ2d2TanRad(QC, QL, radius, precision_Confusion()) if TR.IsDone(): NbSol = TR.NbSolutions() for k in range(1, NbSol + 1): circ = TR.ThisSolution(k) # find the solution circle pnt1 = gp_Pnt2d() parsol, pararg = TR.Tangency1(k, pnt1) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the first tangent point pnt2 = gp_Pnt2d() parsol, pararg = TR.Tangency2(k, pnt2) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the second tangent point aLine = GCE2d_MakeSegment(L, -2, 20).Value() self.assertIsInstance(aLine, Geom2d_TrimmedCurve) if TR.IsDone(): NbSol = TR.NbSolutions() for k in range(1, NbSol + 1): circ = TR.ThisSolution(k) aCircle = Geom2d_Circle(circ) self.assertIsInstance(aCircle, Geom2d_Circle) # find the solution circle (index, outvalue, outvalue, gp_Pnt2d) pnt3 = gp_Pnt2d() parsol, pararg = TR.Tangency1(k, pnt3) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.) # find the first tangent point pnt4 = gp_Pnt2d() parsol, pararg = TR.Tangency2(k, pnt4) self.assertGreater(parsol, 0.) self.assertGreater(pararg, 0.)
def to_gp_pnt2d(p): """ Convert the point_like entity to a gp_Pnt2d. """ if isinstance(p, gp_Pnt2d): return p if is_array_like(p) and len(p) == 2: return gp_Pnt2d(*p) return None
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 test_curves2d_from_offset(self): '''Test: curves 2d from offset''' array = [] array.append(gp_Pnt2d(-4, 0)) array.append(gp_Pnt2d(-7, 2)) array.append(gp_Pnt2d(-6, 3)) array.append(gp_Pnt2d(-4, 3)) array.append(gp_Pnt2d(-3, 5)) xxx = point2d_list_to_TColgp_Array1OfPnt2d(array) SPL1 = Geom2dAPI_PointsToBSpline(xxx).Curve() dist = 1 OC = Geom2d_OffsetCurve(SPL1, dist) result = OC.IsCN(2) dist2 = 1.5 OC2 = Geom2d_OffsetCurve(SPL1, dist2) result2 = OC2.IsCN(2)
def on_trimmed(self, u, v): '''tests whether the surface at the u,v parameter has been trimmed ''' if self._classify_uv is None: self._classify_uv = BRepTopAdaptor_FClass2d(self, 1e-9) uv = gp_Pnt2d(u, v) if self._classify_uv.Perform(uv) == TopAbs_IN: return True else: return False
def bisect_crvcrv(event=None): display.EraseAll() ax = gp_Ax22d(gp_Pnt2d(), gp_Dir2d(1, 0), gp_Dir2d(0, -1)) circ = gp_Circ2d(ax, 5) crv1 = GCE2d_MakeCircle(circ).Value() edg1 = make_edge2d(crv1, -1.0, 1.0) display.DisplayColoredShape(edg1, 'BLUE') p1 = gp_Pnt2d(-10, 0) p2 = gp_Pnt2d(-10, 10) crv2 = GCE2d_MakeLine(p1, p2).Value() edg2 = make_edge2d(crv2, -10.0, 10.0) display.DisplayColoredShape(edg2, 'GREEN') bi = Bisector_BisecCC(crv1, crv2, 50, -5, gp_Pnt2d(0, 0)) crv_bi = bi.Curve(1) edg3 = make_edge2d(crv_bi, -1.0, 1.0) display.DisplayColoredShape(edg3, 'RED') display.FitAll()
def bisect_linecircle(event=None): display.EraseAll() ci1 = gp_Circ2d(gp_Ax22d(), 10000) li1 = gp_Lin2d(gp_Pnt2d(2000000, 20), gp_Dir2d(0, 1)) bi = GccAna_CircLin2dBisec(ci1, li1) assert bi.IsDone() bisec = bi.ThisSolution(1) pb = bisec.Parabola() display.DisplayShape([make_edge2d(ci1), make_edge2d(li1)]) display.DisplayColoredShape(make_edge2d(pb), 'BLUE') display.FitAll()
def test_parabola(self): '''Test: parabola''' # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2., 3.) D = gp_Dir2d(4., 5.) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True)
def variable_filleting(event=None): a_pnt = gp_Pnt(350, 0, 0) box_2 = BRepPrimAPI_MakeBox(a_pnt, 200, 200, 200).Shape() a_fillet = BRepFilletAPI_MakeFillet(box_2) tab_point = TColgp_Array1OfPnt2d(1, 6) p_1 = gp_Pnt2d(0., 8.) p_2 = gp_Pnt2d(0.2, 16.) p_3 = gp_Pnt2d(0.4, 25.) p_4 = gp_Pnt2d(0.6, 55.) p_5 = gp_Pnt2d(0.8, 28.) p_6 = gp_Pnt2d(1., 20.) tab_point.SetValue(1, p_1) tab_point.SetValue(2, p_2) tab_point.SetValue(3, p_3) tab_point.SetValue(4, p_4) tab_point.SetValue(5, p_5) tab_point.SetValue(6, p_6) expl3 = list(TopologyExplorer(box_2).edges()) a_fillet.Add(tab_point, expl3[9]) a_fillet.Build() if a_fillet.IsDone(): law_evolved_box = a_fillet.Shape() display.DisplayShape(law_evolved_box) else: print("aFillet not done.") display.FitAll()
def brep_feat_local_revolution(event=None): S = BRepPrimAPI_MakeBox(400., 250., 300.).Shape() faces = list(TopologyExplorer(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 test_curves2d_from_offset(self): '''Test: curves 2d from offset''' array = [] array.append(gp_Pnt2d(-4, 0)) array.append(gp_Pnt2d(-7, 2)) array.append(gp_Pnt2d(-6, 3)) array.append(gp_Pnt2d(-4, 3)) array.append(gp_Pnt2d(-3, 5)) xxx = point2d_list_to_TColgp_Array1OfPnt2d(array) SPL1 = Geom2dAPI_PointsToBSpline(xxx).Curve() self.assertTrue(SPL1 is not None) dist = 1 OC = Geom2d_OffsetCurve(SPL1, dist) result = OC.IsCN(2) self.assertTrue(result) dist2 = 1.5 OC2 = Geom2d_OffsetCurve(SPL1, dist2) result2 = OC2.IsCN(2) self.assertTrue(result2)
def test_parabola(self): '''Test: parabola''' # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2., 3.) D = gp_Dir2d(4., 5.) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() self.assertIsInstance(gParabola, Geom2d_Parabola) aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) self.assertIsNotNone(aTrimmedCurve) self.assertFalse(aTrimmedCurve.IsNull())
def test_parabola(self): """Test: parabola""" # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola P = gp_Pnt2d(2.0, 3.0) D = gp_Dir2d(4.0, 5.0) A = gp_Ax22d(P, D, True) Para = gp_Parab2d(A, 6) aParabola = GCE2d_MakeParabola(Para) gParabola = aParabola.Value() self.assertIsInstance(gParabola, Geom2d_Parabola) aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) self.assertIsNotNone(aTrimmedCurve) self.assertFalse(aTrimmedCurve is None)
def make_shape(self): # 1 - retrieve the data from the UIUC airfoil data page foil_dat_url = 'http://m-selig.ae.illinois.edu/ads/coord_seligFmt/%s.dat' % self.profile # explicitly tell to not use ssl verification ssl._create_default_https_context = ssl._create_unverified_context print("Connecting to m-selig, retrieving foil data") f = urllib2.urlopen(foil_dat_url) print("Building foil geometry") 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) data = line.split() # 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 parabola(event=None): # P is the vertex point # P and D give the axis of symmetry # 6 is the focal length of the parabola a_pnt = gp_Pnt2d(2, 3) a_dir = gp_Dir2d(4, 5) an_ax = gp_Ax22d(a_pnt, a_dir, True) para = gp_Parab2d(an_ax, 6) display.DisplayShape(a_pnt) display.DisplayMessage(a_pnt, "P") aParabola = GCE2d_MakeParabola(para) gParabola = aParabola.Value() aTrimmedCurve = Geom2d_TrimmedCurve(gParabola, -100, 100, True) display.DisplayShape(aTrimmedCurve, update=True)
def _edge_to_svg_polyline(self, topods_edge,scale=1): """ Returns a svgwrite.Path for the edge, and the 2d bounding box """ unit = self.UNIT tol = self.TOL points_3d = discretize_edge(topods_edge, tol) points_2d = [] box2d = Bnd_Box2d() for point in points_3d: # we tak only the first 2 coordinates (x and y, leave z) x_p = point[0] y_p = - point[1] box2d.Add(gp_Pnt2d(x_p, y_p)) points_2d.append((x_p, y_p)) return svgwrite.shapes.Polyline(points_2d, fill="none", class_='vectorEffectClass'), box2d
def _calc_biquadratic_parabola_point(self, lpt, L, R, ccw): x = lpt if x <= (L / 2): y = x ** 4 / (6 * R * L ** 2) else: yterm_1 = (-1 * x ** 4) / (6 * R * L ** 2) yterm_2 = (2 * x ** 3) / (3 * R * L) yterm_3 = x ** 2 / (2 * R) yterm_4 = (L * x) / (6 * R) yterm_5 = L ** 2 / (48 * R) y = yterm_1 + yterm_2 - yterm_3 + yterm_4 - yterm_5 if not ccw: y = -y return gp_Pnt2d(x, y)
def test_point_from_curve(self): '''Test: point from curve''' radius, abscissa = 5., 3. C = Geom2d_Circle(gp_OX2d(), radius, True) GAC = Geom2dAdaptor_Curve(C) UA = GCPnts_UniformAbscissa(GAC, abscissa) aSequence = [] if UA.IsDone(): N = UA.NbPoints() for count in range(1, N + 1): P = gp_Pnt2d() C.D0(UA.Parameter(count), P) Parameter = UA.Parameter(count) self.assertIsInstance(Parameter, float) aSequence.append(P) Abscissa = UA.Abscissa() self.assertEqual(Abscissa, abscissa)
def _calc_clothoid_curve_point(self, lpt, L, R, ccw): RL = R * L xterm_1 = 1 xterm_2 = lpt ** 4 / (40 * RL ** 2) xterm_3 = lpt ** 8 / (3456 * RL ** 4) xterm_4 = lpt ** 12 / (599040 * RL ** 6) x = lpt * (xterm_1 - xterm_2 + xterm_3 - xterm_4) factor = lpt ** 3 / (6 * RL) yterm_1 = 1 yterm_2 = lpt ** 4 / (56 * RL ** 2) yterm_3 = lpt ** 8 / (7040 * RL ** 4) yterm_4 = lpt ** 12 / (1612800 * RL ** 6) y = factor * (yterm_1 - yterm_2 + yterm_3 - yterm_4) if not ccw: y = -y return gp_Pnt2d(x, y)
def _calc_cosine_curve_point(self, lpt, L, R, ccw): pi = math.pi psi_x = (pi * lpt) / L xterm_1 = (L ** 2) / (8.0 * pi ** 2 * R ** 2) xterm_2 = L / pi xterm_3 = psi_x ** 3 / (3.0) xterm_4 = psi_x / (2.0) xterm_5 = (math.sin(psi_x) * math.cos(psi_x)) / (2.0) xterm_6 = psi_x * math.cos(psi_x) x = lpt - xterm_1 * xterm_2 * (xterm_3 + xterm_4 - xterm_5 - (2.0 * xterm_6)) # TODO: code for y - coordinate y = 0 if not ccw: y = -y return gp_Pnt2d(x, y)
def edge_to_svg_polyline(topods_edge, tol=0.1, unit="mm"): """Returns a svgwrite.Path for the edge, and the 2d bounding box""" unit_factor = 1 # by default if unit == "mm": unit_factor = 1 elif unit == "m": unit_factor = 1e3 points_3d = discretize_edge(topods_edge, tol) points_2d = [] box2d = Bnd_Box2d() for point in points_3d: # we tak only the first 2 coordinates (x and y, leave z) x_p = -point[0] * unit_factor y_p = point[1] * unit_factor box2d.Add(gp_Pnt2d(x_p, y_p)) points_2d.append((x_p, y_p)) return svgwrite.shapes.Polyline(points_2d, fill="none"), box2d
def sample_point(face): # randomly choose a point from F u_min, u_max, v_min, v_max = breptools_UVBounds(face) u = random.uniform(u_min, u_max) v = random.uniform(v_min, v_max) itool = IntTools_FClass2d(face, 1e-6) while itool.Perform(gp_Pnt2d(u,v)) != 0: print('outside') u = random.uniform(u_min, u_max) v = random.uniform(v_min, v_max) P = BRepAdaptor_Surface(face).Value(u, v) # the normal surf = BRep_Tool_Surface(face) D = GeomLProp_SLProps(surf,u,v,1,0.01).Normal() if face.Orientation() == TopAbs_REVERSED: D.Reverse() return P, D
def test_bspline(self): '''Test: bspline''' array = [] array.append(gp_Pnt2d(0, 0)) array.append(gp_Pnt2d(1, 2)) array.append(gp_Pnt2d(2, 3)) array.append(gp_Pnt2d(4, 3)) array.append(gp_Pnt2d(5, 5)) xxx = point2d_list_to_TColgp_Array1OfPnt2d(array) SPL1 = Geom2dAPI_PointsToBSpline(xxx).Curve() self.assertTrue(SPL1 is not None) harray = TColgp_HArray1OfPnt2d(1, 5) harray.SetValue(1, gp_Pnt2d(7 + 0, 0)) harray.SetValue(2, gp_Pnt2d(7 + 1, 2)) harray.SetValue(3, gp_Pnt2d(7 + 2, 3)) harray.SetValue(4, gp_Pnt2d(7 + 4, 3)) harray.SetValue(5, gp_Pnt2d(7 + 5, 5)) anInterpolation = Geom2dAPI_Interpolate(harray, False, 0.01) anInterpolation.Perform() SPL2 = anInterpolation.Curve() self.assertTrue(SPL2 is not None) harray2 = TColgp_HArray1OfPnt2d(1, 5) harray2.SetValue(1, gp_Pnt2d(11 + 0, 0)) harray2.SetValue(2, gp_Pnt2d(11 + 1, 2)) harray2.SetValue(3, gp_Pnt2d(11 + 2, 3)) harray2.SetValue(4, gp_Pnt2d(11 + 4, 3)) harray2.SetValue(5, gp_Pnt2d(11 + 5, 5)) anInterpolation2 = Geom2dAPI_Interpolate(harray2, True, 0.01) anInterpolation2.Perform() SPL3 = anInterpolation2.Curve() self.assertTrue(SPL3 is not None) i = 0 for P in array: i = i+1 make_vertex(P) for j in range(harray.Lower(), harray.Upper()+1): i = i+1 P = harray.Value(j) make_vertex(P) for j in range(harray2.Lower(), harray2.Upper()+1): i = i+1 P = harray2.Value(j) make_vertex(P)