def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() degree_s = self.inputs['Degree'].sv_get() curves_out = [] points_out = [] knots_out = [] for vertices, degree in zip_long_repeat(vertices_s, degree_s): if isinstance(degree, (tuple, list)): degree = degree[0] curve = fitting.interpolate_curve(vertices, degree, centripetal=self.centripetal) points_out.append(curve.ctrlpts) knots_out.append(curve.knotvector) curve = SvGeomdlCurve(curve) curves_out.append(curve) self.outputs['Curve'].sv_set(curves_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['Knots'].sv_set(knots_out)
def test_remove_geomdl_1(self): points = np.array([[0, 0, 0], [1, 1, 0], [2, 0, 0]]) degree = 2 kv = sv_knotvector.generate(degree, 3) weights = [1, 1, 1] ts = np.linspace(0.0, 1.0, num=5) curve = SvGeomdlCurve.build_geomdl(degree, kv, points, weights) orig_pts = curve.evaluate_array(ts) inserted = curve.insert_knot(0.5, 1) self.assert_numpy_arrays_equal(inserted.evaluate_array(ts), orig_pts, precision=8) expected_inserted_kv = np.array([0, 0, 0, 0.5, 1, 1, 1]) self.assert_numpy_arrays_equal(inserted.get_knotvector(), expected_inserted_kv, precision=8) removed = inserted.remove_knot(0.5, 1) self.assert_numpy_arrays_equal(removed.get_knotvector(), kv, precision=8) #self.assert_numpy_arrays_equal(removed.evaluate_array(ts), orig_pts) #print("CP", removed.get_control_points()) #print("W", removed.get_weights()) self.assert_numpy_arrays_equal(removed.get_control_points(), points, precision=8)
def get_geometry(self): if self.mode == 'CURVE': curves = self.inputs['Curves'].sv_get() if isinstance(curves[0], (list, tuple)): curves = sum(curves, []) container = multi.CurveContainer() for i, curve in enumerate(curves): if not isinstance(curve, SvNurbsCurve): if hasattr(curve, 'to_nurbs'): curve = curve.to_nurbs( implementation=SvNurbsCurve.GEOMDL) else: raise TypeError( "Provided object #%s is not a NURBS curve, but %s!" % (i, type(curve))) container.append(SvGeomdlCurve.from_any_nurbs(curve).curve) return container else: # SURFACE surfaces = self.inputs['Surfaces'].sv_get() if isinstance(surfaces[0], (list, tuple)): surfaces = sum(surfaces, []) container = multi.SurfaceContainer() for i, surface in enumerate(surfaces): if not isinstance(surface, SvNurbsSurface): if hasattr(surface, 'to_nurbs'): surface = surface.to_nurbs( implementation=SvNurbsCurve.GEOMDL) else: raise TypeError( "Provided object #%s is not a NURBS surface, but %s!" % (i, type(surface))) container.append( SvGeomdlSurface.from_any_nurbs(surface).surface) return container
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() degree_s = self.inputs['Degree'].sv_get() points_cnt_s = self.inputs['PointsCnt'].sv_get() curves_out = [] points_out = [] knots_out = [] for vertices, degree, points_cnt in zip_long_repeat( vertices_s, degree_s, points_cnt_s): if isinstance(degree, (tuple, list)): degree = degree[0] if isinstance(points_cnt, (tuple, list)): points_cnt = points_cnt[0] kwargs = dict(centripetal=self.centripetal) if self.has_points_cnt: kwargs['ctrlpts_size'] = points_cnt curve = fitting.approximate_curve(vertices, degree, **kwargs) points_out.append(curve.ctrlpts) knots_out.append(curve.knotvector) curve = SvGeomdlCurve(curve) curves_out.append(curve) self.outputs['Curve'].sv_set(curves_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['Knots'].sv_set(knots_out)
def test_curve_tangent(self): geomdl_curve = SvGeomdlCurve.build(self.degree, self.knotvector, self.control_points, self.weights) t1s = geomdl_curve.tangent_array(self.ts) native_curve = SvNativeNurbsCurve(self.degree, self.knotvector, self.control_points, self.weights) t2s = native_curve.tangent_array(self.ts) self.assert_numpy_arrays_equal(t1s, t2s, precision=8)
def test_curve_eval_2(self): weights = [1.0, 2.0, 3.0, 1.0] geomdl_curve = SvGeomdlCurve.build_geomdl(self.degree, self.knotvector, self.control_points, weights) t1s = geomdl_curve.evaluate_array(self.ts) native_curve = SvNativeNurbsCurve(self.degree, self.knotvector, self.control_points, weights) t2s = native_curve.evaluate_array(self.ts) self.assert_numpy_arrays_equal(t1s, t2s, precision=8)
def test_curve_3436_2(self): points = [(0, 0, 0), (0.5, 0, 0.5), (1, 0, 0)] ts = np.array([0, 0.5, 1]) degree = 2 knotvector = [0, 0, 0, 1, 1, 1] weights = [1, 1, 1] geomdl_curve = SvGeomdlCurve.build(degree, knotvector, points, weights) native_curve = SvNativeNurbsCurve(degree, knotvector, points, weights) p1s = geomdl_curve.third_derivative_array(ts) p2s = native_curve.third_derivative_array(ts) self.assert_numpy_arrays_equal(p1s, p2s, precision=8)
def make(vertices): metric = 'CENTRIPETAL' if self.centripetal else 'DISTANCE' vertices = np.array(vertices) if geomdl is not None and self.nurbs_implementation == SvNurbsCurve.GEOMDL: curve = SvGeomdlCurve.interpolate(degree, vertices, metric=metric) else: curve = SvNativeNurbsCurve.interpolate(degree, vertices, metric=metric) return curve
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() degree_s = self.inputs['Degree'].sv_get() points_cnt_s = self.inputs['PointsCnt'].sv_get() input_level = get_data_nesting_level(vertices_s) vertices_s = ensure_nesting_level(vertices_s, 4) degree_s = ensure_nesting_level(degree_s, 2) points_cnt_s = ensure_nesting_level(points_cnt_s, 2) nested_output = input_level > 3 curves_out = [] points_out = [] knots_out = [] for params in zip_long_repeat(vertices_s, degree_s, points_cnt_s): new_curves = [] new_points = [] new_knots = [] for vertices, degree, points_cnt in zip_long_repeat(*params): kwargs = dict(centripetal=self.centripetal) if self.has_points_cnt: kwargs['ctrlpts_size'] = points_cnt curve = fitting.approximate_curve(vertices, degree, **kwargs) new_points.append(curve.ctrlpts) new_knots.append(curve.knotvector) curve = SvGeomdlCurve(curve) new_curves.append(curve) if nested_output: curves_out.append(new_curves) points_out.append(new_points) knots_out.append(new_knots) else: curves_out.extend(new_curves) points_out.extend(new_points) knots_out.extend(new_knots) self.outputs['Curve'].sv_set(curves_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['Knots'].sv_set(knots_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return if not self.text_block: return curves_out = [] surfaces_out = [] items = self.load_json() for i, item in enumerate(items): if isinstance(item, BSpline.Curve): curve = SvGeomdlCurve(item) curves_out.append(curve) elif isinstance(item, BSpline.Surface): surface = SvGeomdlSurface(item) surfaces_out.append(surface) else: self.warning("JSON data item #%s contains unsupported data type: %s", i, type(item)) self.outputs['Curves'].sv_set(curves_out) self.outputs['Surfaces'].sv_set(surfaces_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() weights_s = self.inputs['Weights'].sv_get(default=[[[None]]]) degree_s = self.inputs['Degree'].sv_get() points_cnt_s = self.inputs['PointsCnt'].sv_get() smoothing_s = self.inputs['Smoothing'].sv_get() input_level = get_data_nesting_level(vertices_s) vertices_s = ensure_nesting_level(vertices_s, 4) degree_s = ensure_nesting_level(degree_s, 2) points_cnt_s = ensure_nesting_level(points_cnt_s, 2) smoothing_s = ensure_nesting_level(smoothing_s, 2) has_weights = self.inputs['Weights'].is_linked if has_weights: weights_s = ensure_nesting_level(weights_s, 3) nested_output = input_level > 3 curves_out = [] points_out = [] knots_out = [] for params in zip_long_repeat(vertices_s, weights_s, degree_s, points_cnt_s, smoothing_s): new_curves = [] new_points = [] new_knots = [] for vertices, weights, degree, points_cnt, smoothing in zip_long_repeat( *params): if self.implementation == 'GEOMDL': kwargs = dict(centripetal=self.centripetal) if self.has_points_cnt: kwargs['ctrlpts_size'] = points_cnt curve = fitting.approximate_curve(vertices, degree, **kwargs) control_points = curve.ctrlpts knotvector = curve.knotvector curve = SvGeomdlCurve(curve) else: # SCIPY: points = np.array(vertices) if has_weights: weights = repeat_last_for_length( weights, len(vertices)) else: weights = None if not self.has_smoothing: smoothing = None if self.is_cyclic: if self.auto_cyclic: dv = np.linalg.norm(points[0] - points[-1]) is_cyclic = dv <= self.cyclic_threshold self.info("Dv %s, threshold %s => is_cyclic %s", dv, self.cyclic_threshold, is_cyclic) else: is_cyclic = True else: is_cyclic = False curve = scipy_nurbs_approximate( points, weights=weights, metric=self.metric, degree=degree, filter_doubles=None if not self.remove_doubles else self.threshold, smoothing=smoothing, is_cyclic=is_cyclic) control_points = curve.get_control_points().tolist() knotvector = curve.get_knotvector().tolist() new_curves.append(curve) new_points.append(control_points) new_knots.append(knotvector) if nested_output: curves_out.append(new_curves) points_out.append(new_points) knots_out.append(new_knots) else: curves_out.extend(new_curves) points_out.extend(new_points) knots_out.extend(new_knots) self.outputs['Curve'].sv_set(curves_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['Knots'].sv_set(knots_out)
def make(vertices): curve = fitting.interpolate_curve(vertices, degree, centripetal=self.centripetal) return SvGeomdlCurve(curve)