def display_curve(curve, ctrlpts=True): # Generate the visualisation configuration vis_config = VisMPL.VisConfig(legend=True, ctrlpts=ctrlpts) vis_comp = VisMPL.VisCurve2D(vis_config) # Draw the control point polygon and the evaluated curve curve.vis = vis_comp curve.render()
def test_NURBS_BSPLINE_EQUAL(self): # Save results B_res = self.B_cur.evalpts N_res = self.N_cur.evalpts # Plot the control point polygon and the evaluated curve vis_comp = vis.VisCurve2D() self.N_cur.vis = vis_comp # self.N_cur.render() self.assertListAlmostEqual(B_res, N_res, 3)
def test_gauss_newton2D(self): ''' Performs gauss newton search of optimum weights ''' # Fit the NURBS weights and control points N_fit = F.gauss_newton2D(self.N_cur, self.points) # Plot (debug) fig = plt.figure(num=1) vis_fit = vis.VisCurve2D() N_fit.vis = vis_fit N_fit.render()
def draw_curve(curve): # Try to load the visualization module try: render_curve = True from geomdl.visualization import VisMPL except ImportError: render_curve = False # Draw the control point polygon and the evaluated curve if render_curve: vis_comp = VisMPL.VisCurve2D() curve.vis = vis_comp curve.render()
def test_deriv_curve_fig(bspline_curve2d): fname = "test-derivative_curve.png" data = operations.derivative_curve(bspline_curve2d) multi_shape = multi.CurveContainer(data) multi_shape.vis = VisMPL.VisCurve2D() multi_shape.render(filename=fname, plot=False) assert os.path.isfile(fname) assert os.path.getsize(fname) > 0 # Clean up temporary file if exists if os.path.isfile(fname): os.remove(fname)
def plot_BC(BC_ctrlpts, BC_knot, p): """Plot a boundary curve :param BC_ctrlpts: boundary control points :param BC_knot: boundary knot vector :param p: boundary degree """ cu = NURBS.Curve() cu.degree = p cu.ctrlpts = BC_ctrlpts.tolist() cu.knotvector = BC_knot cu.delta = 0.01 # Plot the control point polygon and the evaluated curve cu.vis = VisMPL.VisCurve2D() cu.render()
def run(N, weight): N = N circle = create_curve(N) print(circle) weight = math.cos(math.pi / N) + weight cv = Multi.MultiCurve() k = 0 while k < len(circle) - 1: cv.add( create_bezie_curve(circle[k], circle[k + 1], circle[k + 2], weight)) k = k + 2 vis_compl = VisMPL.VisCurve2D() cv.vis = vis_compl cv.render()
def test_curve3d_fig_nowindow(bspline_curve3d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = conf.figure_image_filename bspline_curve3d.vis = vis bspline_curve3d.render(plot=False) assert os.path.isfile(fname) assert os.path.getsize(fname) > 0 # Clean up temporary file if exists if os.path.isfile(conf.figure_image_filename): os.remove(conf.figure_image_filename)
def test_curve2d_fig_save(bspline_curve2d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = "test-curve.png" bspline_curve2d.vis = vis bspline_curve2d.render(filename=fname, plot=False) assert os.path.isfile(fname) assert os.path.getsize(fname) > 0 # Clean up temporary file if exists if os.path.isfile(fname): os.remove(fname)
def test_curve2d_multi_fig_save(bspline_curve2d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = "test-multi_curve.png" multi = operations.decompose_curve(bspline_curve2d) multi.vis = vis multi.render(filename=fname, plot=False) assert os.path.isfile(fname) assert os.path.getsize(fname) > 0 # Clean up temporary file if exists if os.path.isfile(fname): os.remove(fname)
def test_curve2d_multi_fig_nowindow(bspline_curve2d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = conf.figure_image_filename multi = operations.decompose_curve(bspline_curve2d) multi.vis = vis multi.render(plot=False) assert os.path.isfile(fname) assert os.path.getsize(fname) > 0 # Clean up temporary file if exists if os.path.isfile(conf.figure_image_filename): os.remove(conf.figure_image_filename)
def build_vis(obj, **kwargs): """ Prepares visualization module for the input spline geometry. :param obj: input spline geometry object :return: spline geometry object updated with a visualization module """ vis_config = VisMPL.VisConfig(**kwargs) if isinstance(obj, (NURBS.Curve, multi.CurveContainer)): if obj.dimension == 2: obj.vis = VisMPL.VisCurve2D(vis_config) elif obj.dimension == 3: obj.vis = VisMPL.VisCurve3D(vis_config) else: raise RuntimeError("Can only plot 2- or 3-dimensional curves") if isinstance(obj, (NURBS.Surface, multi.SurfaceContainer)): obj.vis = VisMPL.VisSurface(vis_config) if isinstance(obj, (NURBS.Volume, multi.VolumeContainer)): obj.vis = VisMPL.VisVolume(vis_config) return obj
# Fix file path os.chdir(os.path.dirname(os.path.realpath(__file__))) # Create a BSpline (NUBS) curve instance curve = BSpline.Curve() # Set degree curve.degree = 2 # Set control points for a periodic curve curve.ctrlpts = [[1, 0], [-1, 0], [-1.5, 1.5], [1.5, -1.5], [1, 0], [-1, 0]] # Knot vector curve.knotvector = [0, 1, 2, 3, 4, 5, 6, 7, 8] # Set evaluation delta curve.sample_size = 100 # Evaluate curve curve.evaluate() # Draw the control point polygon and the evaluated curve vis_config = VisMPL.VisConfig(ctrlpts=False, legend=False) vis_comp = VisMPL.VisCurve2D(vis_config) curve.vis = vis_comp curve.render() # Good to have something here to put a breakpoint pass
# Try to load the visualization module try: render = True from geomdl.visualization import VisMPL except ImportError: render = False # Generate a NURBS full circle from 7 control points circle = curve2d.full_circle2(radius=5.0) circle.delta = 0.01 # Render the circle and the control points polygon if render: vis_config = VisMPL.VisConfig(ctrlpts=True, figure_size=[9, 8]) vis_comp = VisMPL.VisCurve2D(config=vis_config) circle.vis = vis_comp circle.render() # Decompose the circle into Bezier curve segments bezier_segments = circle.decompose() # Prepare Bezier segments for plotting bezier_segments.delta = 0.01 # Render the Bezier curve segments and their control points polygons if render: vis_config = VisMPL.VisConfig(ctrlpts=True, figure_size=[9, 8]) vis_comp = VisMPL.VisCurve2D(config=vis_config) bezier_segments.vis = vis_comp bezier_segments.render()
curve.ctrlpts = [[1.0,1.0], [2.5,0.5], [5.0,1.0]] curve.degree = 1 # Auto-generate knot vector curve.knotvector = utilities.generate_knot_vector(curve.degree, len(curve.ctrlpts)) # Length computation xi=[-0.57735, 0.57735] wi=[1, 1] g1= lambda t: curve.derivatives(0.25*t+0.25, 1) dcurve1 = np.array([g1(xi[i])[1] for i in range(len(xi))]) length1 = 0.25*np.dot(wi, np.linalg.norm(dcurve1, axis=1)) print length1 l1 = np.linalg.norm(np.array(curve.ctrlpts[1]) - np.array(curve.ctrlpts[0])) l2 = np.linalg.norm(np.array(curve.ctrlpts[2]) - np.array(curve.ctrlpts[1])) print 'l1 = ', l1 print 'l2 = ', l2 print 'ana lengh=', l1+l2 sys.exit(0) # Set evaluation delta curve.delta = 0.01 # Evaluate curve curve.evaluate() # Draw the control point polygon and the evaluated curve if render_curve: vis_comp = VisMPL.VisCurve2D() curve.vis = vis_comp curve.render()
Examples for the NURBS-Python Package Released under MIT License Developed by Onur Rauf Bingol (c) 2018 2-dimensional curve fitting by global interpolation """ from geomdl import fitting from geomdl.visualization import VisMPL as vis # The NURBS Book Ex9.1 points = ((0, 0), (3, 4), (-1, 4), (-4, 0), (-4, -3)) degree = 3 # cubic curve # Do global curve interpolation curve = fitting.interpolate_curve(points, degree) # Plot the interpolated curve curve.delta = 0.01 curve.vis = vis.VisCurve2D() curve.render() # # Visualize data and evaluated points together # import numpy as np # import matplotlib.pyplot as plt # evalpts = np.array(curve.evalpts) # pts = np.array(points) # plt.plot(evalpts[:, 0], evalpts[:, 1]) # plt.scatter(pts[:, 0], pts[:, 1], color="red") # plt.show()
def get_cm_from_interpolation_length(pts, interpolation_factor, center_circle, radius): # 0 is circ center = center_circle cm = multi.CurveContainer() cm.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=False, legend=False) circle_length = 2 * math.pi * radius tangents = [] curve_lengths = [] for i in range(len(pts)): p1 = pts[(i - 1) % len(pts)] p2 = pts[(i + 1) % len(pts)] pr = (p2[0] - p1[0], p2[1] - p1[1]) alpha = math.atan2(pr[1], pr[0]) % math.pi tangents.append(alpha) dists = [] for i in range(len(pts)): dist = functions.euclid_dist(pts[i], pts[(i + 1) % len(pts)]) d = dist * 0.25 dists.append(d) for i in range(len(pts)): c = BSpline.Curve() c.degree = 3 d = dists[i] p1, p2 = get_points_on_tangent(pts[i], tangents[i], d) if functions.euclid_dist( p1, pts[(i + 1) % len(pts)]) < functions.euclid_dist( p2, pts[(i + 1) % len(pts)]): p2, p1 = p1, p2 p3, p4 = get_points_on_tangent(pts[(i + 1) % len(pts)], tangents[(i + 1) % len(pts)], d) if functions.euclid_dist(p4, pts[i]) < functions.euclid_dist( p3, pts[i]): p4, p3 = p3, p4 c.ctrlpts = [pts[i], p2, p3, pts[(i + 1) % len(pts)]] c.knotvector = [0, 0, 0, 0, 1, 1, 1, 1] length = get_curve_length(c) curve_lengths.append(length) cm.add(c) curve_lengths.reverse() xc, yc = center_circle pts_r = list(pts) pts_r.reverse() distance_factor = circle_length / sum(curve_lengths) pts_interpolated = [] starting_point = functions.project_to_circle(pts[0], center_circle, radius) pts_interpolated.append(starting_point) starting_angle = math.atan2(starting_point[1] - yc, starting_point[0] - xc) alpha = curve_lengths[0] * distance_factor / radius xp = xc + radius * math.cos(alpha) yp = yc + radius * math.sin(alpha) angle_sum = starting_angle for i in range(len(pts) - 1): alpha = curve_lengths[i] * distance_factor / radius angle_sum += alpha xp = xc + radius * math.cos(angle_sum) yp = yc + radius * math.sin(angle_sum) pts_interpolated.append((xp, yp)) pts_interpolated.reverse() pts_interpolated.insert(0, pts_interpolated.pop()) tangents_interpolated = [] for i in range(len(pts_interpolated)): x, y = pts_interpolated[i] alpha = math.atan2(y - center_circle[1], x - center_circle[0]) alpha -= 0.5 * math.pi alpha = alpha % math.pi tangents_interpolated.append(alpha) dists_interpolated = [] for i in range(len(pts_interpolated)): x1, y1 = pts_interpolated[i] x4, y4 = pts_interpolated[(i + 1) % len(pts_interpolated)] xc, yc = center_circle axx = x1 - xc ay = y1 - yc bx = x4 - xc by = y4 - yc q1 = axx * axx + ay * ay q2 = q1 + axx * bx + ay * by k2 = 4 / 3 * (math.sqrt(2 * q1 * q2) - q2) / (axx * by - ay * bx) d = math.sqrt((k2 * ay)**2 + (k2 * axx)**2) dists_interpolated.append(d) cm = multi.CurveContainer() cm.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=False, legend=False) pts = [[ interpolation_factor * pp[0] + (1 - interpolation_factor) * pc[0], interpolation_factor * pp[1] + (1 - interpolation_factor) * pc[1] ] for (pp, pc) in zip(pts, pts_interpolated)] new_tangents = [] for tp, tc in zip(tangents, tangents_interpolated): if abs(tp - tc) > math.pi / 2: if tp < math.pi / 2: t = interpolation_factor * (tp + math.pi) + ( 1 - interpolation_factor) * tc elif tc < math.pi / 2: t = interpolation_factor * tp + (1 - interpolation_factor) * ( tc + math.pi) else: t = interpolation_factor * tp + (1 - interpolation_factor) * tc new_tangents.append(t) tangents = new_tangents dists = [ interpolation_factor * dp + (1 - interpolation_factor) * dc for (dp, dc) in zip(dists, dists_interpolated) ] angle_mapping = {} ctrlpts = [] for i in range(len(pts)): c = BSpline.Curve() c.degree = 3 d = dists[i] p1, p2 = get_points_on_tangent(pts[i], tangents[i], d) if i == 0: print(tangents[i]) if p1[1] < p2[1] and tangents[i] < math.pi: p1, p2 = p2, p1 elif p1[1] > p2[1] and tangents[i] > math.pi: p1, p2 = p2, p1 else: if math.atan2(p1[1] - center[1], p1[0] - center[0]) < math.atan2( p2[1] - center[1], p2[0] - center[0]): p1, p2 = p2, p1 if functions.euclid_dist( p1, pts[(i + 1) % len(pts)]) < functions.euclid_dist( p2, pts[(i + 1) % len(pts)]): p2, p1 = p1, p2 xp, yp = pts[i] if (xp, yp) in angle_mapping: p = angle_mapping[(xp, yp)] if p[0] > xp and p2[0] > xp or p[0] < xp and p2[0] < xp: p1, p2 = p2, p1 angle_mapping[(xp, yp)] = p2 p3, p4 = get_points_on_tangent(pts[(i + 1) % len(pts)], tangents[(i + 1) % len(pts)], d) if functions.euclid_dist(p4, pts[i]) < functions.euclid_dist( p3, pts[i]): p4, p3 = p3, p4 xp, yp = pts[(i + 1) % len(pts)] angle_mapping[(xp, yp)] = p3 c.ctrlpts = [pts[i], p2, p3, pts[(i + 1) % len(pts)]] c.knotvector = [0, 0, 0, 0, 1, 1, 1, 1] cm.add(c) return cm
n_cp = 10 radius_x = 5 radius_y = 10 n_sp = 100 degree = 3 sp = np.array([[radius_x * math.cos(t), radius_y * math.sin(t)] for t in np.linspace(0, 2 * math.pi, n_sp)]) t = np.linspace(0, 1, n_sp) # plt.scatter(sp[:,0], sp[:,1]) # plt.show() n_knot = n_cp + degree + 1 # knot = np.linspace(0,1, n_knot).tolist() knot = generate(degree, n_cp) A = np.array([[basis_function_one(degree, knot, j, t[i]) for j in range(n_cp)] for i in range(n_sp)]) print(A.shape) invATA = np.linalg.inv(np.dot(A.T, A)) cp = np.dot(np.dot(invATA, A.T), sp).tolist() crv = BSpline.Curve() crv.degree = degree crv.ctrlpts = cp crv.knotvector = knot crv.vis = VisMPL.VisCurve2D() crv.render()
q1 = ax * ax + ay * ay q2 = q1 + ax * bx + ay * by k2 = 4 / 3 * (math.sqrt(2 * q1 * q2) - q2) / (ax * by - ay * bx) x2 = xc + ax - k2 * ay y2 = yc + ay + k2 * ax x3 = xc + bx + k2 * by y3 = yc + by - k2 * bx return 0, (x2, y2), (x3, y3) curve = NURBS.Curve() mcrv_circle = multi.CurveContainer() mcrv_circle.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=False, legend=False) center = (317, 465) #pts = [[204, 604], [284, 612], [387, 577], [485, 475], [430, 366], [325, 231], [274, 438], [193, 436], [150, 525], [204, 604], [284, 612], [387, 577]] pts = [[204, 604], [284, 612], [387, 577], [485, 475], [430, 366], [325, 231], [274, 438], [193, 436], [150, 525], [204, 604]] pts_c = [[204, 604], [284, 612], [387, 577], [485, 475], [430, 366], [325, 231], [274, 438], [193, 436], [150, 525], [204, 604], [284, 612], [387, 577]] #pts = [[204, 604], [284, 612], [430, 366], [274, 438], [193, 436], [204, 604]] #pts_c = [[204, 604], [284, 612], [430, 366], [274, 438], [193, 436], [204, 604], [284, 612], [430, 366]] #radius = max([functions.euclid_dist(center, p) for p in pts]) curves_1 = [] curves_0 = []
k2 = 4 / 3 * (math.sqrt(2 * q1 * q2) - q2) / (ax * by - ay * bx) x2 = xc + ax - k2 * ay y2 = yc + ay + k2 * ax x3 = xc + bx + k2 * by y3 = yc + by - k2 * bx return 0, (x2, y2), (x3, y3) #pts = [[204, 604], [284, 612], [387, 577], [485, 475], [430, 366], [325, 231], [274, 438], [193, 436], [150, 525], [204, 604], [284, 612], [387, 577]] pts = [[485, 475], [430, 366], [325, 231], [274, 438], [193, 436], [150, 525], [204, 604], [284, 612], [387, 577]] cm = multi.CurveContainer() cm.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=True, legend=False) x = [p[0] for p in pts] y = [p[1] for p in pts] # append the starting x,y coordinates x = np.r_[x, x[0]] y = np.r_[y, y[0]] # fit splines to x=f(u) and y=g(u), treating both as periodic. also note that s=0 # is needed in order to force the spline fit to pass through all the input points. tck, u = interpolate.splprep([x, y], s=0, per=True) knots = list(tck[0]) coeff = list(tck[1])
# Set up the curve test_c.degree = degree test_c.ctrlpts = CP # test_c.ctrlpts = exchange.import_txt("ex_curve02.cpt") test_c.knotvector = U # Auto-generate knot vector # test_c.knotvector = utilities.generate_knot_vector(test_c.degree, len(test_c.ctrlpts)) # Set evaluation delta test_c.delta = 0.01 # Evaluate curve in same points as the test_c.evaluate() # Plot the control point polygon and the evaluated curve vis_comp = vis.VisCurve2D() test_c.vis = vis_comp # test_c.render() # Evaluate derivatives at u = 0.6 ders1 = test_c.derivatives(0.6, 4) # plot the first derivative, normed, at correct location. fig = plt.figure(num=1) plt.plot([ders1[0][0], ders1[0][0] + ders1[1][0]], [ders1[0][1], ders1[0][1] + ders1[1][1]], 'k') # First derivative plt.plot([ders1[0][0], ders1[0][0] + ders1[2][0]], [ders1[0][1], ders1[0][1] + ders1[2][1]], 'r') # Second derivative # plt.show() pdb.set_trace() # Adapt nurb from B-spline curve
# Create a NURBS curve instance (full circle) curve = NURBS.Curve() # Set up curve curve.degree = 2 curve.ctrlptsw = exchange.import_txt("ex_curve04.cptw") # Use a specialized knot vector curve.knotvector = [0, 0, 0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1, 1, 1] # Set evaluation delta curve.delta = 0.01 # Evaluate curve curve.evaluate() # Plot the control point polygon and the evaluated curve curve.vis = VisMPL.VisCurve2D() curve.render() # Degree elevation operations.degree_operations(curve, [1]) curve.render() # Degree reduction operations.degree_operations(curve, [-1]) curve.render() # Good to have something here to put a breakpoint pass
curve1.delta = 0.01 # Set up the Bezier curve curve1.ctrlpts = [[10, 0], [15, 15], [20, 0]] curve1.degree = 2 # Auto-generate knot vector curve1.knotvector = utilities.generate_knot_vector(curve1.degree, len(curve1.ctrlpts)) # Evaluate curve curve1.evaluate() # Draw the control point polygon and the evaluated curve if render_curve: vis_comp1 = VisMPL.VisCurve2D() curve1.vis = vis_comp1 curve1.render() # # 2D CURVE 2 # # Create another B-Spline curve instance (Bezier Curve) curve2 = BSpline.Curve2D() # Set evaluation delta curve2.delta = 0.01 # Set up the Bezier curve curve2.ctrlpts = [[10, 0], [15, 15], [15, 15], [20, 0]]
def run(self, N, weight): cv = Multi.MultiCurve() cv.add(self.create_bezie_curve(self.lst[0], self.lst[1], self.lst[2], weight)) vis_compl = VisMPL.VisCurve2D() cv.vis = vis_compl cv.render()
def get_cm_from_interpolation_radial(pts, interpolation_factor): # 0 is circ center_circle = (200, 540) center_polygon = (223, 555) center = center_circle[0] * ( 1 - interpolation_factor ) + center_polygon[0] * interpolation_factor, center_circle[1] * ( 1 - interpolation_factor) + center_polygon[1] * interpolation_factor radius = 70 tangents = [] for i in range(len(pts)): p1 = pts[(i - 1) % len(pts)] p2 = pts[(i + 1) % len(pts)] pr = (p2[0] - p1[0], p2[1] - p1[1]) alpha = math.atan2(pr[1], pr[0]) tangents.append(alpha) dists = [] for i in range(len(pts)): dist = functions.euclid_dist(pts[i], pts[(i + 1) % len(pts)]) d = dist * 0.3 dists.append(d) pts_interpolated = [ functions.project_to_circle(p, center_circle, radius) for p in pts ] tangents_interpolated = [] for i in range(len(pts)): x, y = pts[i] alpha = math.atan2(y - center_circle[1], x - center_circle[0]) alpha -= 0.5 * math.pi alpha = alpha % math.pi tangents_interpolated.append(alpha) dists_interpolated = [] for i in range(len(pts_interpolated)): x1, y1 = pts_interpolated[i] x4, y4 = pts_interpolated[(i + 1) % len(pts_interpolated)] xc, yc = center_circle axx = x1 - xc ay = y1 - yc bx = x4 - xc by = y4 - yc q1 = axx * axx + ay * ay q2 = q1 + axx * bx + ay * by k2 = 4 / 3 * (math.sqrt(2 * q1 * q2) - q2) / (axx * by - ay * bx) d = math.sqrt((k2 * ay)**2 + (k2 * axx)**2) dists_interpolated.append(d) cm = multi.CurveContainer() cm.vis = VisMPL.VisCurve2D(axes=False, labels=False, ctrlpts=False, legend=False) pts = [[ interpolation_factor * pp[0] + (1 - interpolation_factor) * pc[0], interpolation_factor * pp[1] + (1 - interpolation_factor) * pc[1] ] for (pp, pc) in zip(pts, pts_interpolated)] new_tangents = [] for tp, tc in zip(tangents, tangents_interpolated): if abs(tp - tc) > math.pi / 2: if tp < math.pi / 2: t = interpolation_factor * (tp + math.pi) + ( 1 - interpolation_factor) * tc elif tc < math.pi / 2: t = interpolation_factor * tp + (1 - interpolation_factor) * ( tc + math.pi) else: t = interpolation_factor * tp + (1 - interpolation_factor) * tc new_tangents.append(t) tangents = new_tangents dists = [ interpolation_factor * dp + (1 - interpolation_factor) * dc for (dp, dc) in zip(dists, dists_interpolated) ] ctrlpts = [] for i in range(len(pts)): c = BSpline.Curve() c.degree = 3 d = dists[i] p1, p2 = get_points_on_tangent(pts[i], tangents[i], d) if math.atan2(p1[1] - center[1], p1[0] - center[0]) < math.atan2( p2[1] - center[1], p2[0] - center[0]): p1, p2 = p2, p1 if functions.euclid_dist( p1, pts[(i + 1) % len(pts)]) < functions.euclid_dist( p2, pts[(i + 1) % len(pts)]): p2, p1 = p1, p2 p3, p4 = get_points_on_tangent(pts[(i + 1) % len(pts)], tangents[(i + 1) % len(pts)], d) if functions.euclid_dist(p4, pts[i]) < functions.euclid_dist( p3, pts[i]): p4, p3 = p3, p4 c.ctrlpts = [pts[i], p2, p3, pts[(i + 1) % len(pts)]] c.knotvector = [0, 0, 0, 0, 1, 1, 1, 1] cm.add(c) return cm
# curve1.knotvector = (0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0) # curve2.ctrlpts =[(disp_X[2,0], -disp_Z[2,0]), # (disp_X[2,1], -disp_Z[2,1]), # (disp_X[2,2], -disp_Z[2,2]), # (disp_X[2,3], -disp_Z[2,3]), # (disp_X[2,4], -disp_Z[2,4]), # (disp_X[2,5], -disp_Z[2,5]), # (disp_X[2,6], -disp_Z[2,6]), # (disp_X[2,7], -disp_Z[2,7]),] # curve2.knotvector = (0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 5.0, 5.0) # multi_curve_x = Multi.MultiCurve(curve0, curve1, curve2) multi_curve.delta = 0.05 vis_config = VisMPL.VisConfig(legend=False) multi_curve.vis = VisMPL.VisCurve2D(vis_config) multi_curve.render() print("Prozes time: %s seconds ---" % (time.time() - start_time)) print("Exit!") # print('Kontrollpunkte und Gewichte:') # for i in range(curve_geometry.NbPoles): # pole = curve_geometry.Pole(i) # weight = curve_geometry.Weight(i) # print(' ', i, pole, weight) # print() # print('Knots:')
def smooth_bspline(self, filename): """ Smooth respiratory function using B-spline curve Parameters ---------- filname: string Name of 2DST file to smooth the respiratory function Returns ------- snake: list Optimised B-spline curve (respiratory function smoothed) """ # Recover respiratory function extracted from 2DST images using masks ldiaphragm_pts = [list(item) for item in self.respiratory_pattern(filename)] # print("Original diaphragm points: {}".format(ldiaphragm_pts)) # img = cv2.imread('{}/{}/{}/{}'.format(DIR_2DST_DICOM, self.patient, self.plan, filename), 1) # diaphragm_mask = np.zeros((256, 50, 3), np.uint8) # img_mask = img.copy() # i = 0 # while(i < len(ldiaphragm_pts) - 1): # cv2.line( # img_mask, # ldiaphragm_pts[i], ldiaphragm_pts[i + 1], # (255, 0, 0), 1) # i = i + 1 # cv2.imshow('Diaphragmatic level', img_mask) # cv2.waitKey(0) # cv2.destroyAllWindows() # cv2.imwrite('name.png', img_mask) # Try to load the visualization module try: render_curve = True from geomdl.visualization import VisMPL except ImportError: render_curve = False # Create a B-Spline curve instance curve = BSpline.Curve() # Set evaluation delta curve.delta = 0.0002 """ Set up curve """ # Set control points controlpts = ldiaphragm_pts convert_controlpts = map(lambda x: 255 - x[1], controlpts) for i in range(len(controlpts)): controlpts[i][1] = convert_controlpts[i] curve.ctrlpts = controlpts # Set curve degree curve.degree = 3 # Auto-generate knot vector curve.knotvector =\ utilities.generate_knot_vector( curve.degree, len(curve.ctrlpts)) # Evaluate curve curve.evaluate() # Draw the control point polygon and the evaluated curve if render_curve: vis_comp = VisMPL.VisCurve2D() curve.vis = vis_comp curve.render()