def buildSurf(self, obj): pts = self.Points[obj.FirstIndex:obj.LastIndex + 1] bs = Part.BSplineSurface() cont = 0 if obj.Continuity == 'C1': cont = 1 elif obj.Continuity == 'C2': cont = 2 if obj.Method == "Parametrization": bs.approximate(Points=pts, DegMin=obj.DegreeMin, DegMax=obj.DegreeMax, Tolerance=obj.ApproxTolerance, Continuity=cont, ParamType=obj.Parametrization) elif obj.Method == "Smoothing Algorithm": bs.approximate(Points=pts, DegMin=obj.DegreeMin, DegMax=obj.DegreeMax, Tolerance=obj.ApproxTolerance, Continuity=cont, LengthWeight=obj.LengthWeight, CurvatureWeight=obj.CurvatureWeight, TorsionWeight=obj.TorsionWeight) self.curve = bs
def flat_cylinder_surface(face, in_place=False): """ flat_face = flat_cylinder_surface(face, in_place=False) Creates a flat nurbs surface from input cylindrical face, with same parametrization. If in_place is True, the surface is located at the seam edge of the face. """ u0, u1, v0, v1 = get_finite_surface_bounds(face) c1 = face.Surface.uIso(u0) # seam line e1 = c1.toShape(v0, v1) l1 = e1.Length c2 = face.Surface.vIso(v0) # circle e2 = c2.toShape(u0, u1) l2 = e2.Length if in_place: t1 = c2.tangent(c2.FirstParameter)[0] e3 = e1.copy() e3.translate(t1 * l2) rs = Part.makeRuledSurface(e1, e3) bs = rs.Surface bs.exchangeUV() else: bs = Part.BSplineSurface() bs.setPole(1, 1, vec3(v0, 0, 0)) bs.setPole(1, 2, vec3(v1, 0, 0)) bs.setPole(2, 1, vec3(v0, l2, 0)) bs.setPole(2, 2, vec3(v1, l2, 0)) bs.setUKnots([0, 2 * pi]) bs.setVKnots([v0, v1]) return bs
def get_nurbs_rectangle(shapes): bb = Part.Compound(shapes).BoundBox dims = [bb.XLength, bb.YLength, bb.ZLength] if min(dims) == dims[0]: pts = [ vec3(bb.XMin, bb.YMin, bb.ZMin), vec3(bb.XMin, bb.YMax, bb.ZMin), vec3(bb.XMin, bb.YMax, bb.ZMax), vec3(bb.XMin, bb.YMin, bb.ZMax) ] elif min(dims) == dims[1]: pts = [ vec3(bb.XMin, bb.YMin, bb.ZMin), vec3(bb.XMax, bb.YMin, bb.ZMin), vec3(bb.XMax, bb.YMin, bb.ZMax), vec3(bb.XMin, bb.YMin, bb.ZMax) ] else: pts = [ vec3(bb.XMin, bb.YMin, bb.ZMin), vec3(bb.XMax, bb.YMin, bb.ZMin), vec3(bb.XMax, bb.YMax, bb.ZMin), vec3(bb.XMin, bb.YMax, bb.ZMin) ] bs = Part.BSplineSurface() bs.setPole(1, 1, pts[0]) bs.setPole(1, 2, pts[1]) bs.setPole(2, 2, pts[2]) bs.setPole(2, 1, pts[3]) return bs
def machFlaeche(psta, ku=None, objName="XXd"): NbVPoles, NbUPoles, _t1 = psta.shape degree = 3 ps = [[ FreeCAD.Vector(psta[v, u, 0], psta[v, u, 1], psta[v, u, 2]) for u in range(NbUPoles) ] for v in range(NbVPoles)] kv = [1.0 / (NbVPoles - 3) * i for i in range(NbVPoles - 2)] if ku == None: ku = [1.0 / (NbUPoles - 3) * i for i in range(NbUPoles - 2)] mv = [4] + [1] * (NbVPoles - 4) + [4] mu = [4] + [1] * (NbUPoles - 4) + [4] bs = Part.BSplineSurface() bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False, False, degree, degree) res = App.ActiveDocument.getObject(objName) # if res==None: res = App.ActiveDocument.addObject("Part::Spline", objName) # res.ViewObject.ControlPoints=True res.Shape = bs.toShape() return bs
def get_bspline_surface(self, surf): """Input : Rhino rhino3dm.NurbsSurface Output : FreeCAD Part.BSplineSurface""" pts = [] weights = [] for u in range(surf.Points.CountU): row = [] wrow = [] for v in range(surf.Points.CountV): op = surf.Points[u, v] p, w = self.get_point_and_weight(op) row.append(p) wrow.append(w) pts.append(row) weights.append(wrow) ku, mu = self.get_FCKnots(surf.KnotsU) kv, mv = self.get_FCKnots(surf.KnotsV) uperiodic = False vperiodic = False bs = Part.BSplineSurface() bs.buildFromPolesMultsKnots(pts, mu, mv, ku, kv, uperiodic, vperiodic, surf.Degree(0), surf.Degree(1), weights) if mu[0] < (surf.Degree(0) + 1): bs.setUPeriodic() if mv[0] < (surf.Degree(1) + 1): bs.setVPeriodic() return bs
def makeSurfaceVolume(filename): import FreeCAD,Part f1=open(filename) coords=[] miny=1 for line in f1.readlines(): sline=line.strip() if sline and not sline.startswith('#'): ycoord=len(coords) lcoords=[] for xcoord, num in enumerate(sline.split()): fnum=float(num) lcoords.append(FreeCAD.Vector(float(xcoord),float(ycoord),fnum)) miny=min(fnum,miny) coords.append(lcoords) s=Part.BSplineSurface() s.interpolate(coords) plane=Part.makePlane(len(coords[0])-1,len(coords)-1,FreeCAD.Vector(0,0,miny-1)) l1=Part.makeLine(plane.Vertexes[0].Point,s.value(0,0)) l2=Part.makeLine(plane.Vertexes[1].Point,s.value(1,0)) l3=Part.makeLine(plane.Vertexes[2].Point,s.value(0,1)) l4=Part.makeLine(plane.Vertexes[3].Point,s.value(1,1)) f0=plane.Faces[0] f0.reverse() f1=Part.Face(Part.Wire([plane.Edges[0],l1.Edges[0],s.vIso(0).toShape(),l2.Edges[0]])) f2=Part.Face(Part.Wire([plane.Edges[1],l3.Edges[0],s.uIso(0).toShape(),l1.Edges[0]])) f3=Part.Face(Part.Wire([plane.Edges[2],l4.Edges[0],s.vIso(1).toShape(),l3.Edges[0]])) f4=Part.Face(Part.Wire([plane.Edges[3],l2.Edges[0],s.uIso(1).toShape(),l4.Edges[0]])) f5=s.toShape().Faces[0] solid=Part.Solid(Part.Shell([f0,f1,f2,f3,f4,f5])) return solid,(len(coords[0])-1)/2.0,(len(coords)-1)/2.0
def nurbs_quad(poles, param_range=[0.0, 1.0, 0.0, 1.0], extend_factor=1.0): """Create a Nurbs Quad surface between the four supplied poles. The parameter range is given by param_range The surface can be extended multiple times with extend_factor This is used as a projection surface for face mapping. """ s0, s1, t0, t1 = param_range bs = Part.BSplineSurface() umults = [2, 2] vmults = [2, 2] uknots = [s0, s1] vknots = [t0, t1] if extend_factor > 1.0: ur = s1 - s0 vr = t1 - t0 uknots = [s0 - extend_factor * ur, s1 + extend_factor * ur] vknots = [t0 - extend_factor * vr, t1 + extend_factor * vr] diag_1 = poles[1][1] - poles[0][0] diag_2 = poles[1][0] - poles[0][1] np1 = poles[0][0] - extend_factor * diag_1 np2 = poles[0][1] - extend_factor * diag_2 np3 = poles[1][0] + extend_factor * diag_2 np4 = poles[1][1] + extend_factor * diag_1 poles = [[np1, np2], [np3, np4]] bs.buildFromPolesMultsKnots(poles, umults, vmults, uknots, vknots, False, False, 1, 1) return bs
def machFlaeche(psta, ku=None, closed=False, weights=None): NbVPoles, NbUPoles, _t1 = psta.shape # print psta.shape degree = 3 ps = [[ FreeCAD.Vector(psta[v, u, 0], psta[v, u, 1], psta[v, u, 2]) for u in range(NbUPoles) ] for v in range(NbVPoles)] kv = [1.0 / (NbVPoles - 3) * i for i in range(NbVPoles - 2)] if ku == None: ku = [1.0 / (NbUPoles - 3) * i for i in range(NbUPoles - 2)] mv = [4] + [1] * (NbVPoles - 4) + [4] mu = [4] + [1] * (NbUPoles - 4) + [4] if closed: ku = [1.0 / (NbUPoles + 1) * i for i in range(NbUPoles + 1)] mu = [1] * (NbUPoles + 1) mu = [4, 3, 4] ku = [0, 1, 2] bs = Part.BSplineSurface() if weights != None: wew = weights bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False, closed, degree, degree, wew) else: bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False, closed, degree, degree) return bs
def makeSurfaceFromSag(self, surface, startpoint=[0, 0, 0], R=50.0, rpoints=10, phipoints=12): # TODO: sdia parameter not valid anymore, change behaviour here, too. depending on the type of aperture surPoints = [] pts = Points.Points() pclpoints = [] for r in np.linspace(0, R, rpoints): points = [] for a in np.linspace(0.0, 360.0 - 360 / float(phipoints), phipoints): x = r * math.cos(a * math.pi / 180.0) # + startpoint[0] y = r * math.sin(a * math.pi / 180.0) # + startpoint[1] z = surface.shape.getSag(x, y) # + startpoint[2] p = FreeCAD.Base.Vector(x, y, z) p2 = FreeCAD.Base.Vector(x + startpoint[0], y + startpoint[1], z + startpoint[2]) points.append(p) pclpoints.append(p2) surPoints.append(points) pts.addPoints(pclpoints) sur = Part.BSplineSurface() sur.interpolate(surPoints) sur.setVPeriodic() surshape = sur.toShape() surshape.translate(tuple(startpoint)) return (surshape, pts)
def build(cls, implementation, degree_u, degree_v, knotvector_u, knotvector_v, control_points, weights=None, normalize_knots=False): control_points = np.asarray(control_points) m, n, _ = control_points.shape if weights is None: weights = np.ones((m, n)) weights = np.asarray(weights) if normalize_knots: knotvector_u = sv_knotvector.normalize(knotvector_u) knotvector_v = sv_knotvector.normalize(knotvector_v) pts = [[Base.Vector(*t) for t in row] for row in control_points] ms_u = sv_knotvector.to_multiplicity(knotvector_u) knots_u = [p[0] for p in ms_u] mults_u = [p[1] for p in ms_u] ms_v = sv_knotvector.to_multiplicity(knotvector_v) knots_v = [p[0] for p in ms_v] mults_v = [p[1] for p in ms_v] surface = Part.BSplineSurface() surface.buildFromPolesMultsKnots(pts, mults_u, mults_v, knots_u, knots_v, False, False, degree_u, degree_v, weights.tolist()) return SvFreeCadNurbsSurface(surface)
def sweep_edge(self, e, extend=False): if self.rational_approx: approx = e.toNurbs().Edges[0] else: approx = e.Curve.toBSpline(e.FirstParameter, e.LastParameter).toShape() bs = approx.Curve #self.cylinder.transform(self.placement.toMatrix()) poles = [] weights = [] oc = False for w, p in zip(bs.getWeights(), bs.getPoles()): p2d = vec2(*self._plane.projectPoint(p, "LowerDistanceParameters")) c = self.sweep_Point2D(p2d, extend).Curve if oc and self.check_splines: nurbs_tools.is_same(oc, c, 1e-3, True) oc = c poles.append(oc.getPoles()) weights.append([w] * oc.NbPoles) bss = Part.BSplineSurface() bss.buildFromPolesMultsKnots(poles, bs.getMultiplicities(), oc.getMultiplicities(), bs.getKnots(), oc.getKnots(), bs.isPeriodic(), oc.isPeriodic(), bs.Degree, oc.Degree, weights) return bss.toShape()
def create_surface(self, surf): nu = surf.ToNurbsSurface() #print("{} x {}".format(nu.Degree(0), nu.Degree(1))) pts = [] weights = [] for u in range(nu.Points.CountU): row = [] wrow = [] for v in range(nu.Points.CountV): p = nu.Points[u, v] #print(FreeCAD.Vector(p.X,p.Y,p.Z)) row.append(FreeCAD.Vector(p.X, p.Y, p.Z)) wrow.append(p.W) pts.append(row) weights.append(wrow) ku, mu = self.getFCKnots(nu.KnotsU) kv, mv = self.getFCKnots(nu.KnotsV) uperiodic = False #mu[0] <= nu.Degree(0) vperiodic = False #mv[0] <= nu.Degree(1) # print(list(nu.KnotsU)) # print(ku, mu) # print(kv, mv) # vflatknots = list(nu.KnotsV) # print("{}\n{}".format(uflatknots, vflatknots)) bs = Part.BSplineSurface() bs.buildFromPolesMultsKnots(pts, mu, mv, ku, kv, \ uperiodic, vperiodic, nu.Degree(0), nu.Degree(1), weights) if mu[0] < (nu.Degree(0) + 1): bs.setUPeriodic() if mv[0] < (nu.Degree(1) + 1): bs.setVPeriodic() return bs
def generate_bspline_patch(vertices, n_nodes, degree, knots): """ Generates a bspine patch from the given vertices. Parameters like degree of the patch, knot vector and number of control points are defined above. :param vertices: lexicographically numbered control points in a 2D Array of 3 component points """ n_nodes_u = n_nodes n_nodes_v = n_nodes degree_u = degree degree_v = degree knot_u = knots knot_v = knots patch = Part.BSplineSurface() patch.increaseDegree(degree_u, degree_v) for i in range(4, len(knot_u)-4): patch.insertUKnot(knot_u[i], 1, 0) # todo why is the second argument equal to 1? If anyone could explain = awesome for i in range(4, len(knot_v)-4): patch.insertVKnot(knot_v[i], 1, 0) # todo why is the second argument equal to 1? If anyone could explain = awesome for ii in range(0, n_nodes_u): for jj in range(0, n_nodes_v): k = ii + jj * n_nodes_u v = vertices[k] control_point = FreeCAD.Vector(v[0], v[1], v[2]) patch.setPole(ii + 1, jj + 1, control_point, 1) if(PLOT_CONTROL_POINTS): Part.show(Part.Vertex(control_point)) # plotting corresponding control points, switched on/off in configuration section return patch.toShape()
def projection_quad(pts, param_range=[0, 1, 0, 1], extend_factor=1.0): """ quad = projection_quad(pts, param_range=[0,1,0,1]) Create a quad bspline surface between points pts (SW, NW, SE, NE). param_range is the parametric range of the surface (u0,u1,v0,v1). surface is extended outside of the original points, by extend_factor. """ s0, s1, t0, t1 = param_range bs = Part.BSplineSurface() poles = [pts[:2], pts[2:]] umults = [2, 2] vmults = [2, 2] uknots = [s0, s1] vknots = [t0, t1] if extend_factor > 1.0: ur = s1 - s0 vr = t1 - t0 uknots = [s0 - extend_factor * ur, s1 + extend_factor * ur] vknots = [t0 - extend_factor * vr, t1 + extend_factor * vr] diag_1 = poles[1][1] - poles[0][0] diag_2 = poles[1][0] - poles[0][1] np1 = poles[0][0] - extend_factor * diag_1 np2 = poles[0][1] - extend_factor * diag_2 np3 = poles[1][0] + extend_factor * diag_2 np4 = poles[1][1] + extend_factor * diag_1 poles = [[np1, np2], [np3, np4]] bs.buildFromPolesMultsKnots(poles, umults, vmults, uknots, vknots, False, False, 1, 1) return bs
def createToy(): countA=11 countB=11 degA=3 degB=3 poles=np.zeros(countA*countB*3).reshape(countA,countB,3) for u in range(countA): for v in range(countB): poles[u,v,0]=10*u poles[u,v,1]=10*v poles[1:-1,:,2]=30 poles[2:-2,:,2]=60 poles[3:8,3:8,2]=180 poles[4,4,2]=150 poles[6,4,2]=220 multA=[degA+1]+[1]*(countA-1-degA)+[degA+1] multB=[degB+1]+[1]*(countB-1-degB)+[degB+1] knotA=range(len(multA)) knotB=range(len(multB)) sf=Part.BSplineSurface() sf.buildFromPolesMultsKnots(poles,multA,multB,knotA,knotB,False,False,degA,degB) shape=sf.toShape() Part.show(shape)
def machFlaeche(psta, ku=None, closed=False): print "mqachflaeche koko" NbVPoles, NbUPoles, _t1 = psta.shape degree = 3 ps = [[ FreeCAD.Vector(psta[v, u, 0], psta[v, u, 1], psta[v, u, 2]) for u in range(NbUPoles) ] for v in range(NbVPoles)] kv = [1.0 / (NbVPoles - 3) * i for i in range(NbVPoles - 2)] if ku == None: ku = [1.0 / (NbUPoles - 3) * i for i in range(NbUPoles - 2)] mv = [4] + [1] * (NbVPoles - 4) + [4] mu = [4] + [1] * (NbUPoles - 4) + [4] mv = [4] + [1] * (NbVPoles - 4) + [4] mu = [4] + [1] * (NbUPoles - 4) + [4] if closed: ku = [1.0 / (NbUPoles + 1) * i for i in range(NbUPoles + 1)] if closed: mu = [1] * (NbUPoles + 1) bs = Part.BSplineSurface() bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False, closed, degree, degree) return bs
def showFace(rbf, rbf2, x, y, gridsize, shapeColor, bound): import Draft grids = gridsize ws = [] pts2 = [] xi, yi = np.linspace(np.min(x), np.max(x), grids), np.linspace(np.min(y), np.max(y), grids) for ix in xi: points = [] for iy in yi: # print (ix,iy, rbf(ix,iy)) iz = float(rbf(ix, iy)) #---------------------- special hacks #+# if bound > 0: if iz > bound: iz = bound if iz < -bound: iz = -bound # print (ix,iy,iz) # if abs(ix)>20 or abs(iy)>20: # iz=0 # if ix==np.max(x) or ix==np.min(x) or iy==np.max(y) or iy==np.min(y): # iz=0 #---------------------- end hack # if rbf2<>None: # iz -= float(rbf2(ix,iy)) points.append(FreeCAD.Vector(iy, ix, iz)) w = Draft.makeWire(points, closed=False, face=False, support=None) ws.append(w) pts2.append(points) #- FreeCAD.activeDocument().recompute() #- FreeCADGui.updateGui() #- Gui.SendMsgToActiveView("ViewFit") ll = FreeCAD.activeDocument().addObject('Part::Loft', 'elevation') ll.Sections = ws ll.Ruled = True ll.ViewObject.ShapeColor = shapeColor ll.ViewObject.LineColor = (0.00, 0.67, 0.00) for w in ws: w.ViewObject.Visibility = False ll.Label = "Interpolation Gitter " + str(grids) bs = Part.BSplineSurface() # print "Points --" # print pts2 bs.interpolate(pts2) Part.show(bs.toShape())
def dist(x): t = x[0] sfa = Part.BSplineSurface() ap[3:7, 4:8] = sppoles + dirtt * t sfa.buildFromPolesMultsKnots(ap, mu, mv, uk, vk, False, False, ud, vd) return sfa.toShape().distToShape(Part.Vertex(target))[0]
def makeSurfaceFromSag(self, obj, rpoints=10, phipoints=12): shape = obj.shapeclass aperture = obj.apertureclass coords = obj.LocalCoordinatesLink.globalcoordinates basisX = obj.LocalCoordinatesLink.localbasisX basisY = obj.LocalCoordinatesLink.localbasisY basisZ = obj.LocalCoordinatesLink.localbasisZ vobj = obj.ViewObject surshape = None if aperture.annotations["typicaldimension"] < 100.0: surPoints = [] rvalues = np.linspace(0, aperture.annotations["typicaldimension"], rpoints) phivalues = np.linspace(0, 2 * math.pi - 2 * math.pi / phipoints, phipoints) PHI, R = np.meshgrid(phivalues, rvalues) X = (R * np.cos(PHI)).reshape((rpoints * phipoints, )).T Y = (R * np.sin(PHI)).reshape((rpoints * phipoints, )).T Z = shape.getSag(X, Y) Z[np.isnan( Z)] = 0.0 # something has to happen if sqrts become negative # TODO: setting values to last defined values # TODO: constructing wires set from last defined values # TODO: generating final aperture from this wires set XYZ = np.vstack((X, Y, Z)).T XYZ = XYZ.reshape((rpoints, phipoints, 3)) surPoints = [[FreeCAD.Base.Vector(*p) for p in r] for r in XYZ.tolist()] sur = Part.BSplineSurface() sur.interpolate(surPoints) sur.setVPeriodic() surshape = sur.toShape() vobj.ShapeColor = (0., 0., 1.) else: surshape = Part.makePlane(2, 2) surshape.translate((-1, -1, 0)) vobj.ShapeColor = (1., 0., 0.) surshape.transformShape( FreeCAD.Matrix(basisX[0], basisY[0], basisZ[0], 0, basisX[1], basisY[1], basisZ[1], 0, basisX[2], basisY[2], basisZ[2], 0, 0, 0, 0, 1)) surshape.translate(coords) return surshape
def table2Nurbs(ss, label="MyNurbs"): ''' create nurbs from table''' NbUPoles = int(ss.NbUPoles) NbVPoles = int(ss.NbVPoles) x = [] for u in range(int(ss.NbUPoles)): cn = cellname(u + 2, 10) x.append(ss.get(cn)) y = [] for v in range(int(ss.NbVPoles)): cn = cellname(1, 11 + v) y.append(ss.get(cn)) z = [] for v in range(NbVPoles): for u in range(NbUPoles): cn = cellname(u + 2, 10 + v + 1) z.append(ss.get(cn)) ps = [] for v in range(NbVPoles): for u in range(NbUPoles): p = [x[u], y[v], z[v * NbUPoles + u]] ps.append(p) ps = np.array(ps).reshape(NbVPoles, NbUPoles, 3) #-hack for 0.16 ps = [] for v in range(NbVPoles): psl = [] for u in range(NbUPoles): p = (x[u], y[v], z[v * NbUPoles + u]) psl.append(FreeCAD.Vector(p)) ps.append(psl) #- end hack bs = Part.BSplineSurface() kv = [1.0 / (NbVPoles - 1) * i for i in range(NbVPoles)] ku = [1.0 / (NbUPoles - 1) * i for i in range(NbUPoles)] bs.buildFromPolesMultsKnots(ps, [3] + [1] * (NbVPoles - 2) + [3], [3] + [1] * (NbUPoles - 2) + [3], kv, ku, False, False, 3, 3) sha = bs.toShape() sp = App.ActiveDocument.addObject("Part::Spline", label) sp.Shape = sha sp.ViewObject.ControlPoints = True sp.ViewObject.ShapeColor = (random.random(), random.random(), random.random())
def createBSplineSurface(poles=None, uknots=None, vknots=None, umults=None, vmults=None, udegree=3, vdegree=3, uperiodic=False, vperiodic=False, uclosed=False, vclosed=False, weights=None): if poles is None: poles = [[[0, 0, 0], [50, 0, 0], [100, 0, 0]], [[0, 50, 0], [50, 50, 200], [100, 50, 0]], [[0, 100, 0], [50, 100, 0], [100, 100, 0]]] (uc, vc, _) = np.array(poles).shape udegree = min(udegree, uc - 1) vdegree = min(vdegree, uc - 1) bs = Part.BSplineSurface() if umults is None: umults = [udegree + 1] + [1] * (uc - 1 - udegree) + [udegree + 1] if vmults is None: vmults = [vdegree + 1] + [1] * (vc - 1 - vdegree) + [vdegree + 1] if uknots is None: uknots = range(len(umults)) if vknots is None: vknots = range(len(vmults)) bsa = Part.BSplineSurface() if weights is None: bsa.buildFromPolesMultsKnots(poles, umults, vmults, uknots, vknots, uclosed, vclosed, udegree, vdegree) else: bsa.buildFromPolesMultsKnots(poles, umults, vmults, uknots, vknots, uclosed, vclosed, udegree, vdegree, weights) return bsa
def bspline(pts=None): '''interpolate a bspline surface over the point matrix''' ffs = App.ActiveDocument.getObject("TestPCL") if ffs == None: bs = Part.BSplineSurface() if pts == None: pts = pointarray() bs.interpolate(pts) ffs = App.ActiveDocument.addObject("Part::Spline", "TestBSF") ffs.Shape = bs.toShape() return ffs
def run_FreeCAD_Helmet3(self): dome = self.getData('dome') say(np.array(dome).shape) border = self.getData('border') say(np.array(border).shape) hh = self.getData("heightBorder") ptsa = np.array(border) assert np.array(dome).shape == (3, 3, 3) assert ptsa.shape == (16, 3) poles = np.zeros((5, 5, 3)) poles[0, 0:-1] = ptsa[12:17][::-1] poles[4] = ptsa[4:9] poles = poles.swapaxes(0, 1) poles[0] = ptsa[0:5] poles[4] = ptsa[8:13][::-1] poles[1, 1:4] = dome[0] poles[2, 1:4] = dome[1] poles[3, 1:4] = dome[2] polesb = np.zeros((7, 7, 3)) polesb[1:-1, 1:-1] = poles polesb[0] = polesb[1] polesb[-1] = polesb[-2] polesb = polesb.swapaxes(0, 1) polesb[0] = polesb[1] polesb[-1] = polesb[-2] polesb = polesb.swapaxes(0, 1) polesb[1, 1:-1, 2] += hh polesb[-2, 1:-1, 2] += hh polesb[2:-2, 1, 2] += hh polesb[2:-2, -2, 2] += hh polesb[0, 0] = polesb[0, 1] polesb[-1, -1] = polesb[-1, -2] polesb[0, -1] = polesb[0, -2] polesb[-1, 0] = polesb[-1, 1] ud = 3 vd = 3 mu = [4, 1, 1, 1, 4] mv = [4, 1, 1, 1, 4] uk = range(len(mu)) vk = range(len(mv)) sf = Part.BSplineSurface() sf.buildFromPolesMultsKnots(polesb, mu, mv, uk, vk, False, False, ud, vd) self.setPinObject("Shape_out", sf.toShape())
def createBS(arr): ''' createBS(arr): create a BSpline Surface with the poles array arr''' cylinder=True #cylinder=False arr=np.array(arr) # pst=arr.swapaxes(0,1) pst=arr NbVPoles,NbUPoles,_t1 =pst.shape degree=3 udegree=degree vdegree=degree if degree == 1: cylinder = False ps=[[FreeCAD.Vector(pst[v,u,0],pst[v,u,1],pst[v,u,2]) for u in range(NbUPoles)] for v in range(NbVPoles)] kv=[1.0/(NbVPoles-3)*i for i in range(NbVPoles-2)] mv=[4] +[1]*(NbVPoles-4) +[4] if NbVPoles == 2: print "KKKK" kv=[0,1] mv=[2,2] vdegree=1 if cylinder: ku=[1.0/(NbUPoles-1)*i for i in range(NbUPoles)] mu=[2]+[1]*(NbUPoles-2)+[2] # bug ku=[1.0/(NbUPoles)*i for i in range(NbUPoles+1)] mu=[1]*(NbUPoles+1) print len(ps) print sum(mu) else: ku=[1.0/(NbUPoles-3)*i for i in range(NbUPoles-2)] mu=[4]+[1]*(NbUPoles-4)+[4] bs=Part.BSplineSurface() bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False,cylinder ,vdegree,udegree) print ("Cylinmder::",cylinder) return bs
def computeShape(self, obj): """ Computes simulation involved shapes. @param obj Created Part::FeaturePython object. @return Shape """ nx = obj.FS_Nx ny = obj.FS_Ny mesh = FSMesh(obj) surf = Part.BSplineSurface() pos = [] for i in range(0,nx): pos.append([]) for j in range(0,ny): pos[i].append(mesh[i][j].pos) surf.interpolate(pos) return surf.toShape()
def run(): allpts = [] # for obj in Gui.Selection.getSelection(): for obj in App.ActiveDocument.clones.OutList: if obj.Label.startswith('t='): exec(obj.Label) #print t #print y.Placement obj.Placement = t #.inverse() print len(obj.Shape.Edge1.Curve.getPoles()) pts = obj.Shape.Edge1.Curve.discretize(30) allpts.append(pts) bs = Part.BSplineSurface() bs.interpolate(allpts) sp = App.ActiveDocument.addObject("Part::Spline", "Spline") sp.Shape = bs.toShape()
def array2Nurbs(arr, a, b, c, d, label="MyArrayNurbs", borderPoles=False): ''' create nurbs from array''' ps = arr[a:a + b, c:c + d] NbVPoles, NbUPoles, _t1 = ps.shape bs = Part.BSplineSurface() if borderPoles: kv = [1.0 / (NbVPoles - 1) * i for i in range(NbVPoles)] ku = [1.0 / (NbUPoles - 1) * i for i in range(NbUPoles)] mv = [3] + [1] * (NbVPoles - 2) + [3] mu = [3] + [1] * (NbUPoles - 2) + [3] kv = [1.0 / (NbVPoles - 3) * i for i in range(NbVPoles - 2)] ku = [1.0 / (NbUPoles - 3) * i for i in range(NbUPoles - 2)] mv = [4] + [1] * (NbVPoles - 4) + [4] mu = [4] + [1] * (NbUPoles - 4) + [4] else: kv = [1.0 / (NbVPoles + 3) * i for i in range(NbVPoles + 4)] ku = [1.0 / (NbUPoles + 3) * i for i in range(NbUPoles + 4)] mv = [1] * (NbVPoles + 4) mu = [1] * (NbUPoles + 4) print(ps.shape, ku, kv) bs.buildFromPolesMultsKnots(ps, mv, mu, kv, ku, False, False, 3, 3) # bs.insertVKnot(0.51,1,0.0) # print "B4xxx5" # fehler,wenn tolerance kleiner #+# warum bei u=0.2 ?? # bs.insertUKnot(0.2,1,0.0) # bs.insertVKnot(0.2,1,0.0) sha = bs.toShape() sp = App.ActiveDocument.addObject("Part::Spline", label) sp.Shape = sha sp.ViewObject.ControlPoints = True sp.ViewObject.ShapeColor = (random.random(), random.random(), random.random()) return sp
def run_FreeCAD_Nurbs(self): #shape=FreeCAD.ActiveDocument.Cone.Shape.Face1 #shape=FreeCAD.ActiveDocument.Sphere.Shape.Face1 shape=self.getPinObject("shape") if shape is None: sayErOb(self,"no shape") return return n=shape.toNurbs() say(n.Faces) say(n.Edges) sf=n.Face1.Surface ssff=Part.BSplineSurface() ssff.buildFromPolesMultsKnots(sf.getPoles(), sf.getUMultiplicities(), sf.getVMultiplicities(), sf.getUKnots(),sf.getVKnots(),False,False,sf.UDegree,sf.VDegree) ff=ssff.toShape() self.setPinObject("Shape_out",ff)
def stretched_plane(poles, param_range=[0, 2, 0, 2], extend_factor=1.0): s0, s1, t0, t1 = param_range bs = Part.BSplineSurface() umults = [2, 2] vmults = [2, 2] uknots = [s0, s1] vknots = [t0, t1] if extend_factor > 1.0: ur = s1 - s0 vr = t1 - t0 uknots = [s0 - extend_factor * ur, s1 + extend_factor * ur] vknots = [t0 - extend_factor * vr, t1 + extend_factor * vr] diag_1 = poles[1][1] - poles[0][0] diag_2 = poles[1][0] - poles[0][1] np1 = poles[0][0] - extend_factor * diag_1 np2 = poles[0][1] - extend_factor * diag_2 np3 = poles[1][0] + extend_factor * diag_2 np4 = poles[1][1] + extend_factor * diag_1 poles = [[np1, np2], [np3, np4]] bs.buildFromPolesMultsKnots(poles, umults, vmults, uknots, vknots, False, False, 1, 1) return bs
def computeShape(self, obj): """ Computes simulation involved shapes. @param obj Created Part::FeaturePython object. @return Shape """ nx = obj.FS_Nx ny = obj.FS_Ny mesh = FSMesh(obj) # Create BSpline surface surf = Part.BSplineSurface() for i in range(1,nx-1): u = i / float(nx-1) surf.insertUKnot(u,i,0.000001) for i in range(1,ny-1): v = i / float(ny-1) surf.insertVKnot(v,i,0.000001) for i in range(0,nx): for j in range(0,ny): u = i / float(nx-1) v = j / float(ny-1) point = mesh[i][j].pos surf.movePoint(u,v,point,i+1,i+1,j+1,j+1) return surf.toShape()