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 build(cls,
implementation,
degree_u,
degree_v,
knotvector_u,
knotvector_v,
control_points,
weights=None,
normalize_knots=False):
kv_error = sv_knotvector.check(degree_u, knotvector_u,
len(control_points))
if kv_error is not None:
raise Exception("U direction: " + kv_error)
kv_error = sv_knotvector.check(degree_v, knotvector_v,
len(control_points[0]))
if kv_error is not None:
raise Exception("V direction: " + kv_error)
if implementation == SvNurbsSurface.GEOMDL:
return SvGeomdlSurface.build(degree_u, degree_v, knotvector_u,
knotvector_v, control_points, weights,
normalize_knots)
elif implementation == SvNurbsSurface.NATIVE:
if normalize_knots:
knotvector_u = sv_knotvector.normalize(knotvector_u)
knotvector_v = sv_knotvector.normalize(knotvector_v)
return SvNativeNurbsSurface(degree_u, degree_v, knotvector_u,
knotvector_v, control_points, weights)
else:
raise Exception(
f"Unsupported NURBS Surface implementation: {implementation}")
def __init__(self,
degree_u,
degree_v,
knotvector_u,
knotvector_v,
control_points,
weights,
normalize_knots=False):
self.degree_u = degree_u
self.degree_v = degree_v
self.knotvector_u = np.array(knotvector_u)
self.knotvector_v = np.array(knotvector_v)
if normalize_knots:
self.knotvector_u = sv_knotvector.normalize(self.knotvector_u)
self.knotvector_v = sv_knotvector.normalize(self.knotvector_v)
self.control_points = np.array(control_points)
c_ku, c_kv, _ = self.control_points.shape
if weights is None:
self.weights = weights = np.ones((c_ku, c_kv))
else:
self.weights = np.array(weights)
w_ku, w_kv = self.weights.shape
if c_ku != w_ku or c_kv != w_kv:
raise Exception(
f"Shape of control_points ({c_ku}, {c_kv}) does not match to shape of weights ({w_ku}, {w_kv})"
)
self.basis_u = SvNurbsBasisFunctions(knotvector_u)
self.basis_v = SvNurbsBasisFunctions(knotvector_v)
self.u_bounds = (self.knotvector_u.min(), self.knotvector_u.max())
self.v_bounds = (self.knotvector_v.min(), self.knotvector_v.max())
self.normal_delta = 0.0001
self.__description__ = f"Native NURBS (degree={degree_u}x{degree_v}, pts={self.control_points.shape[0]}x{self.control_points.shape[1]})"
def build(cls, implementation, degree, knotvector, control_points, weights=None, normalize_knots=False):
kv_error = sv_knotvector.check(degree, knotvector, len(control_points))
if kv_error is not None:
raise Exception(kv_error)
if implementation == SvNurbsCurve.NATIVE:
if normalize_knots:
knotvector = sv_knotvector.normalize(knotvector)
return SvNativeNurbsCurve(degree, knotvector, control_points, weights)
elif implementation == SvNurbsCurve.GEOMDL and geomdl is not None:
return SvGeomdlCurve.build(degree, knotvector, control_points, weights, normalize_knots)
else:
raise Exception(f"Unsupported NURBS Curve implementation: {implementation}")
def build(cls, implementation, degree, knotvector, control_points, weights=None, normalize_knots=False):
n = len(control_points)
if weights is None:
weights = np.ones((n,))
if normalize_knots:
knotvector = sv_knotvector.normalize(knotvector)
pts = [Base.Vector(t[0], t[1], t[2]) for t in control_points]
ms = sv_knotvector.to_multiplicity(knotvector)
knots = [p[0] for p in ms]
mults = [p[1] for p in ms]
curve = Part.BSplineCurve()
curve.buildFromPolesMultsKnots(pts, mults, knots, False, degree, weights)
return SvFreeCadNurbsCurve(curve)
def __init__(self,
degree,
knotvector,
control_points,
weights=None,
normalize_knots=False):
self.control_points = np.array(control_points) # (k, 3)
k = len(control_points)
if weights is not None:
self.weights = np.array(weights) # (k, )
else:
self.weights = np.ones((k, ))
self.knotvector = np.array(knotvector)
if normalize_knots:
self.knotvector = sv_knotvector.normalize(self.knotvector)
self.degree = degree
self.basis = SvNurbsBasisFunctions(knotvector)
self.tangent_delta = 0.001
self.u_bounds = None # take from knotvector
self.__description__ = f"Native NURBS (degree={degree}, pts={k})"
