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()
