def points_to_bspline(pnts): ''' Points to bspline ''' pnts = point_list_to_TColgp_Array1OfPnt(pnts) crv = GeomAPI_PointsToBSpline(pnts) return crv.Curve()
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, color='WHITE', update=False) display.DisplayShape(path_wire, color='BLUE', update=False) display.DisplayShape(pipe, update=True)
def get_simple_bound(rndPts0): _spl1 = GeomAPI_PointsToBSpline(rndPts0) #not a GeomAPI_PointsToBSplineSurface ?? _spl1.thisown = False spl1 = _spl1.Curve() spl1_adap = GeomAdaptor_HCurve(spl1) spl1_adap.thisown = False spl1_adap_h = spl1_adap.GetHandle() bound1 = GeomFill_SimpleBound(spl1_adap_h, 0.001, 0.001) bound1.thisown = False bound1_h = bound1.GetHandle() return spl1, bound1_h
def get_simple_bound(rndPts0): _spl1 = GeomAPI_PointsToBSpline( rndPts0) #not a GeomAPI_PointsToBSplineSurface ?? _spl1.thisown = False spl1 = _spl1.Curve() spl1_adap = GeomAdaptor_HCurve(spl1) spl1_adap.thisown = False spl1_adap_h = spl1_adap.GetHandle() bound1 = GeomFill_SimpleBound(spl1_adap_h, 0.001, 0.001) bound1.thisown = False bound1_h = bound1.GetHandle() return spl1, bound1_h
def DisplayG01Line(coor1, coor2): array = TColgp_Array1OfPnt(1, 2) array.SetValue(1, gp_Pnt(coor1[0], coor1[1], coor1[2])) array.SetValue(2, gp_Pnt(coor2[0], coor2[1], coor2[2])) bspline2 = GeomAPI_PointsToBSpline(array).Curve() path_edge = BRepBuilderAPI_MakeEdge(bspline2).Edge() display.DisplayColoredShape(path_edge, 'GREEN')
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 make_bspline_edge(pyptlist, mindegree=3, maxdegree=8): array = TColgp_Array1OfPnt(1, len(pyptlist)) pcnt = 1 for pypt in pyptlist: gppt = make_gppnt(pypt) array.SetValue(pcnt, gppt) pcnt += 1 bcurve = GeomAPI_PointsToBSpline(array, mindegree, maxdegree).Curve() curve_edge = BRepBuilderAPI_MakeEdge(bcurve) return curve_edge.Edge()
def DisplayG02Arc(coor1, coor2, ARCCMD): f = G02EXE(coor1, coor2, ARCCMD) print(f) pty = f[0] center = f[1] radius = f[2] startA = f[3] endA = f[4] if endA - startA >= 0: endA = -2 * math.pi + endA dis = endA - startA dis = dis / 30 array = TColgp_Array1OfPnt(1, 30) if pty == 'xy': for i in range(29): array.SetValue( i + 1, gp_Pnt(radius * math.cos(startA + dis * i) + center[0], radius * math.sin(startA + dis * i) + center[1], coor1[2])) array.SetValue( 30, gp_Pnt(radius * math.cos(endA) + center[0], radius * math.sin(endA) + center[1], coor1[2])) elif pty == 'zx': for i in range(29): array.SetValue( i + 1, gp_Pnt(radius * math.sin(startA + dis * i) + center[1], coor1[1], radiud * math.cos(startA + dis * i) + center[0])) array.SetValue( 30, gp_Pnt(radius * math.sin(endA) + center[1], coor1[1], radiud * math.cos(endA) + center[0])) elif pty == 'yz': for i in range(29): array.SetValue( i + 1, gp_Pnt(coor1[0], radiud * math.cos(startA + dis * i) + center[0], radius * math.sin(startA + dis * i) + center[1])) array.SetValue( 30, gp_Pnt(coor1[0], radiud * math.cos(endA) + center[0], radius * math.sin(endA) + center[1])) bspline2 = GeomAPI_PointsToBSpline(array).Curve() path_edge = BRepBuilderAPI_MakeEdge(bspline2).Edge() display.DisplayColoredShape(path_edge, 'RED')
def resample_curve_with_uniform_deflection(curve, deflection=0.5, degreeMin=3, degreeMax=8, continuity=GeomAbs_C2, tolerance=1e-4): """ fits a bspline through the samples on `curve` @param curve: TopoDS_Wire, TopoDS_Edge, curve @param n_samples: """ crv = to_adaptor_3d(curve) defl = GCPnts_UniformDeflection(crv, deflection) with assert_isdone(defl, 'failed to compute UniformDeflection'): print("Number of points:", defl.NbPoints()) sampled_pnts = [defl.Value(i) for i in range(1, defl.NbPoints())] resampled_curve = GeomAPI_PointsToBSpline( point_list_to_TColgp_Array1OfPnt(sampled_pnts), degreeMin, degreeMax, continuity, tolerance) return resampled_curve.Curve().GetObject()
def create_shape(self): d = self.declaration if not d.points: raise ValueError("Must have at least two points") # Poles and weights pts = TColgp_Array1OfPnt(1, len(d.points)) set_value = pts.SetValue # TODO: Support weights for i, p in enumerate(d.points): set_value(i + 1, gp_Pnt(*p)) self.shape = GeomAPI_PointsToBSpline(pts).Curve().GetObject()
def DisplayG00Line(coor1, coor2): coors = [ coor1, [coor2[0], coor1[1], coor1[2]], [coor2[0], coor2[1], coor1[2]], coor2 ] for i in range(3): array = TColgp_Array1OfPnt(1, 2) array.SetValue(1, gp_Pnt(coors[i][0], coors[i][1], coors[i][2])) array.SetValue( 2, gp_Pnt(coors[i + 1][0], coors[i + 1][1], coors[i + 1][2])) bspline2 = GeomAPI_PointsToBSpline(array).Curve() path_edge = BRepBuilderAPI_MakeEdge(bspline2).Edge() display.DisplayColoredShape(path_edge, 'YELLOW')
def makeSpline(cls, listOfVector): """ Interpolate a spline through the provided points. :param cls: :param listOfVector: a list of Vectors that represent the points :return: an Edge """ pnts = TColgp_Array1OfPnt(0, len(listOfVector) - 1) for ix, v in enumerate(listOfVector): pnts.SetValue(ix, v.toPnt()) spline_geom = GeomAPI_PointsToBSpline(pnts).Curve() return cls(BRepBuilderAPI_MakeEdge(spline_geom).Edge())
def test_stl(self, event=None): #you probably dont have these #occ_shape = load_stl("~/local/pythonocc-0.3/pythonOCC/src/samples/Level2/DataExchange/sample.stl") #occ_shape = load_stl("~/local/legos/diver.stl") #http://adl.serveftp.org/lab/legos/diver.stl #occ_shape = load_stl(os.path.join(os.path.curdir, "models/cube.stl")) #make a box occ_shape = BRepPrimAPI_MakeBox(Point(0, 0, 0), Point(1, 1, 1)).Shape() display.DisplayShape(occ_shape) shape = Face(occ_shape) temp_points = list(set(shape.points)) #self.assertTrue(len(temp_points)>0) #TODO: cluster points and make surfaces. but how do you compute the first parameter to build_plate? surf = Surface() surf.shape = occ_shape surf.points = temp_points #surf.approximate() #should be more like test_extract_shape_vertices curve1 = GeomAPI_PointsToBSpline(point_list_1(surf.points)).Curve() curve1.GetObject() e1 = Edge(curve1.GetHandle()) display.DisplayShape(e1)
def fit_spline(points, degree_min=3, degree_max=8, continuity='C2', tol=1e-3): """Approximates a set of points on the plane with a B-spline. Parameters ---------- points : ndarray 2D ndarray with N>=2 rows and 2 columns, representing the points on the plane, ordered from one end point to the other. The first column gives the x, the second column gives the the y coordinates of the points. degree_min : int, optional Minimum degree of the spline. The default is 3. degree_max : int, optional Maximum degree of the spline. The default is 8. continuity : {'C0', 'G1', 'C1', 'G2', 'C2', 'C3', 'CN'}, optional The continuity of the spline will be at least `continuity`. The default is 'C2'. For their meanings, consult with https://www.opencascade.com/doc/occt-7.4.0/refman/html/_geom_abs___shape_8hxx.html tol : float, optional The distance from the points to the spline will be lower than `tol`. The default is 1e-3. Returns ------- spline : Geom_BSplineCurve For details on the resulting spline, see the OpenCASCADE documentation: https://www.opencascade.com/doc/occt-7.4.0/refman/html/class_geom___b_spline_curve.html Raises ------ ValueError If the minimum degree of the B-spline to be constructed is greater than its maximum degree. """ if degree_min > degree_max: raise ValueError( 'Minimum degree must not be lower than the maximum degree.') # Create points from the input array that OCCT understands n_point = np.size(points, 0) pts = TColgp_Array1OfPnt(0, n_point - 1) for i in range(n_point): pts.SetValue(i, gp_Pnt(float(points[i][0]), float(points[i][1]), 0)) # Construct the spline continuity = _spline_continuity_enum(continuity) spline = GeomAPI_PointsToBSpline(pts, degree_min, degree_max, continuity, tol).Curve() return spline
def surface_from_curves(): ''' @param display: ''' # First spline array = [] array.append(gp_Pnt(-4, 0, 2)) array.append(gp_Pnt(-7, 2, 2)) array.append(gp_Pnt(-6, 3, 1)) array.append(gp_Pnt(-4, 3, -1)) array.append(gp_Pnt(-3, 5, -2)) pt_list1 = point_list_to_TColgp_Array1OfPnt(array) SPL1 = GeomAPI_PointsToBSpline(pt_list1).Curve() SPL1_c = SPL1.GetObject() # Second spline a2 = [] a2.append(gp_Pnt(-4, 0, 2)) a2.append(gp_Pnt(-2, 2, 0)) a2.append(gp_Pnt(2, 3, -1)) a2.append(gp_Pnt(3, 7, -2)) a2.append(gp_Pnt(4, 9, -1)) pt_list2 = point_list_to_TColgp_Array1OfPnt(a2) SPL2 = GeomAPI_PointsToBSpline(pt_list2).Curve() SPL2_c = SPL2.GetObject() # Fill with StretchStyle aGeomFill1 = GeomFill_BSplineCurves(SPL1, SPL2, GeomFill_StretchStyle) SPL3 = Handle_Geom_BSplineCurve_DownCast( SPL1_c.Translated(gp_Vec(10, 0, 0))) SPL4 = Handle_Geom_BSplineCurve_DownCast( SPL2_c.Translated(gp_Vec(10, 0, 0))) # Fill with CoonsStyle aGeomFill2 = GeomFill_BSplineCurves(SPL3, SPL4, GeomFill_CoonsStyle) SPL5 = Handle_Geom_BSplineCurve_DownCast( SPL1_c.Translated(gp_Vec(20, 0, 0))) SPL6 = Handle_Geom_BSplineCurve_DownCast( SPL2_c.Translated(gp_Vec(20, 0, 0))) # Fill with CurvedStyle aGeomFill3 = GeomFill_BSplineCurves(SPL5, SPL6, GeomFill_CurvedStyle) aBSplineSurface1 = aGeomFill1.Surface() aBSplineSurface2 = aGeomFill2.Surface() aBSplineSurface3 = aGeomFill3.Surface() display.DisplayShape(make_face(aBSplineSurface1, 1e-6)) display.DisplayShape(make_face(aBSplineSurface2, 1e-6)) display.DisplayShape(make_face(aBSplineSurface3, 1e-6), update=True)
def points_to_bspline(pnts): pts = TColgp_Array1OfPnt(0, len(pnts) - 1) for n, i in enumerate(pnts): pts.SetValue(n, i) crv = GeomAPI_PointsToBSpline(pts) return crv.Curve()
def points_to_bspline(pnts, deg=3, periodic=False, tangents=None, scale=False, continuity=GeomAbs_C2): """ Points to bspline: originally from pythonocc-utils, changed to allow numpy arrays as input Paramters --------- pnts : list or numpy array array of x, y, z points deg : integer degree of the fitted bspline periodic : Bool (default=False) If true, OCC.GeomAPI_Interpolate will be used instead of the GeomAPI_PointsToBspline. Curve tangent vectors can then be enforced at the interpolation pnts tangents : array (default=None) list of [x,y,z] tangent vectors to be specificied at points: if only 2 tangents are specified, these will be enforced at the start and end points, otherwise tangents should have the same length as pnts and will be enforced at each point. Scale : Bool (default=False) Will scale the tangents (gives a smoother Periodic curve if False) continuity : OCC.GeomAbs.GeomAbs_XX type (default C2) The order of continuity (C^0, C^1, C^2, G^0, ....) Returns ------- crv : OCC.Geom.BSplineCurve Notes ----- """ if not periodic and (tangents is None): _type = TColgp_Array1OfPnt pnts = point_array_to_TColgp_PntArrayType(pnts, _type) # Fit the curve to the point array deg_min = deg deg_max = deg crv = GeomAPI_PointsToBSpline(pnts, deg_min, deg_max, continuity).Curve() else: _type = TColgp_HArray1OfPnt pnts = point_array_to_TColgp_PntArrayType(pnts, _type) tol = 0.001 interp = GeomAPI_Interpolate(pnts.GetHandle(), periodic, tol) if tangents is not None: N = tangents.shape[0] if N == 2: try: interp.Load(gp_Vec(*tangents[0, :]), gp_Vec(*tangents[1, :]), scale) except: # Python 3 issue: using * on numpy array breaks gp_Vec interp.Load(gp_Vec(*tangents[0, :].tolist()), gp_Vec(*tangents[1, :].tolist()), scale) else: tan_array = TColgp_Array1OfVec(1, N) for i in range(1, N + 1): try: tan_array.SetValue(i, gp_Vec(*tangents[i - 1, :])) except TypeError: # Python 3 issue: using * on numpy array breaks gp_Vec tan_array.SetValue(i, gp_Vec(*tangents[i - 1, :].tolist())) tan_flags = TColStd_HArray1OfBoolean(1, N) tan_flags.Init(True) # Set all true i.e. enforce all tangents interp.Load(tan_array, tan_flags.GetHandle(), scale) interp.Perform() crv = interp.Curve() return crv
def get_simple_bound(pts): spl1 = GeomAPI_PointsToBSpline(pts).Curve() spl1_adap_h = GeomAdaptor_HCurve(spl1).GetHandle() bound1_h = GeomFill_SimpleBound(spl1_adap_h, 0.001, 0.001).GetHandle() return spl1, bound1_h