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 surface_visualizer(self, surface): #%matplotlib # Create a visualization configuration instance with no legend, no axes and set the resolution to 120 dpi vis_config = VisMPL.VisConfig(ctrlpts=False, axes_equal=False) # Create a visualization method instance using the configuration above vis_obj = VisMPL.VisSurface(vis_config) # Set the visualization method of the curve object surface.vis = vis_obj surface.render(colormap=cm.cool, plot=False)
def test_curve3d_multi_fig_nowindow(bspline_curve3d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve3D(config=conf) multi = operations.decompose_curve(bspline_curve3d) multi.vis = vis multi.render(plot=False) assert os.path.isfile(conf.figure_image_filename) assert os.path.getsize(conf.figure_image_filename) > 0 # Clean up temporary file if exists if os.path.isfile(conf.figure_image_filename): os.remove(conf.figure_image_filename)
def test_curve3d_fig_save(bspline_curve3d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve3D(config=conf) fname = "test-curve.png" bspline_curve3d.vis = vis bspline_curve3d.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_surf_fig_nowindow(bspline_surface): conf = VisMPL.VisConfig() vis = VisMPL.VisSurface(config=conf) fname = conf.figure_image_filename bspline_surface.vis = vis bspline_surface.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_surf_fig_save(bspline_surface): conf = VisMPL.VisConfig() vis = VisMPL.VisSurface(config=conf) fname = "test-surface.png" bspline_surface.vis = vis bspline_surface.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_surf_multi_fig_save(bspline_surface): conf = VisMPL.VisConfig() vis = VisMPL.VisSurfWireframe(config=conf) fname = "test-multi_surface.png" multi = operations.decompose_surface(bspline_surface) 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_save(bspline_curve2d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = "test-multi_curve.png" multi = bspline_curve2d.decompose() 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_surf_multi_fig_nowindow(bspline_surface): conf = VisMPL.VisConfig() vis = VisMPL.VisSurfScatter(config=conf) fname = conf.figure_image_filename multi = operations.decompose_surface(bspline_surface) 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 test_curve3d_multi_fig_save(bspline_curve3d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve3D(config=conf) fname = "test-multi_curve.png" data = operations.decompose_curve(bspline_curve3d) multi_shape = multi.CurveContainer(data) multi_shape.vis = vis 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 test_curve2d_multi_fig_nowindow(bspline_curve2d): conf = VisMPL.VisConfig() vis = VisMPL.VisCurve2D(config=conf) fname = conf.figure_image_filename data = operations.decompose_curve(bspline_curve2d) multi_shape = multi.CurveContainer(data) multi_shape.vis = vis multi_shape.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_surf_ctrlpts_offset(bspline_surface): conf = VisMPL.VisConfig() vis = VisMPL.VisSurface(config=conf) # Set control points grid offset vis.ctrlpts_offset = 3.5 fname = "test-surface.png" bspline_surface.vis = vis bspline_surface.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 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
def display_landscape(landscape, delta=0.04): # Auto-generate knot vector landscape.knotvector_u = utilities.generate_knot_vector( landscape.degree_u, landscape.ctrlpts_size_u) landscape.knotvector_v = utilities.generate_knot_vector( landscape.degree_v, landscape.ctrlpts_size_v) # Set evaluation delta landscape.delta = delta # Evaluate curve landscape.evaluate() # Draw the control point polygon and the evaluated curve # Prepare the VisConfig vis_config = VisMPL.VisConfig(ctrlpts=False) vis_comp = VisMPL.VisSurfTriangle(vis_config) landscape.vis = vis_comp print( "Displaying the landscape. This consists of a large mountainous area with several peaks, a small hill, a river which runs between the hill and the mountains, and a lake which the river feeds into." ) landscape.render( colormap=cm.get_cmap(name='terrain')) # Apply a colormap to the render
[-4.4061, -0.056926, 6.3034]] n = int(len(cp_o) / 2) control_points = [[0, 0, 0]] * n for i in range(len(y)): ang = np.linspace(0, 2 * np.pi, n) for th in ang: control_points.append([y[i] * np.cos(th), y[i] * np.sin(th), z[i]]) for c in cp_o: control_points.append(c) t = int(len(control_points) / n) surf.set_ctrlpts(control_points, t, n) surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u, t) surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v, n) surf.evaluate() # Visualization config vis_config = vis.VisConfig(figure_size=[30, 15]) # Visualization component vis_comp = vis.VisSurface(vis_config) # Set visualization component of the surface surf.vis = vis_comp # Render the surface surf.render()
# 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
from geomdl.shapes import curve2d # 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
# Set control points surf.set_ctrlpts(*exchange.import_txt("../ex_surface01.cpt", two_dimensional=True)) # Set knot vectors surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0] surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0] # Set sample size surf.sample_size = 30 # Set surface tessellation component surf.tessellator = tessellate.TrimTessellate() # Set visualization component visconf = vis.VisConfig(ctrlpts=False, legend=False, trims=False) surf.vis = vis.VisSurface(config=visconf) # Generate circular trim curves with different sense tcrv1 = analytic.Circle(origin=(0.25, 0.25), radius=0.20) tcrv1.opt = ['sense', 1] tcrv2 = analytic.Circle(origin=(0.75, 0.75), radius=0.20) tcrv2.opt = ['sense', 1] trim_curves = [tcrv1, tcrv2] # Set trim curves (as a list) surf.trims = trim_curves # Visualize surface surf.render(colormap=cm.copper)
import numpy as np import matplotlib.pyplot as plt from geomdl import fitting from geomdl import exchange from geomdl.visualization import VisMPL as vis ''' todo: fit 3d curves to central axes of the toroid experiments ''' con_toroid = exchange.import_csv("con_toroid_caxis.csv",delimiter = ',') print(len(con_toroid)) toroid = exchange.import_csv("toroid_caxis.csv",delimiter = ',') print(toroid) curve = fitting.approximate_curve(toroid,degree = 2,ctrlpts_size = 10) curve1 = fitting.approximate_curve(con_toroid,degree = 2,ctrlpts_size = 10-) # Plot the interpolated curve curve.delta = 0.005 curve.vis = vis.VisCurve3D(vis.VisConfig(ctrlpts=False)) curve.render() # Plot the interpolated curve curve1.delta = 0.005 curve1.vis = vis.VisCurve3D(vis.VisConfig(ctrlpts=False)) curve1.render()
def _execute(self): print('Process of field surface evaluation started') start = time.time() if not os.path.exists(self.path + 'surface_evaluation/'): os.makedirs(self.path + 'surface_evaluation/') odP = outlier_detector_Parameters() tfP = terrain_filter_Parameters() tgP = terrain_grid_Parameters() sfP = surface_fit_Parameters() out_flag = self.outlier_detector(points=self.dws_point_cloud, metric=odP.METRIC, method=odP.METHOD, radius=odP.RADIUS, deviance=odP.DEVIANCE, K=odP.K) store_point_cloud(self.path + 'surface_evaluation/' + "clean_roi.las", self.dws_point_cloud[out_flag, :], self.header) save_img(self.dws_point_cloud[out_flag, :], 'clean_roi_0_0', self.path + 'surface_evaluation/', 0, 0) save_img(self.dws_point_cloud[out_flag, :], 'clean_roi_0_90', self.path + 'surface_evaluation/', 0, 90) print('outliers removed .....') terrain_points = self.terrain_filter( points=self.dws_point_cloud[out_flag, :], method=tfP.METHOD, window_size=tfP.WINDOW_SIZE, window_stride=tfP.WINDOW_STRIDE, quantile=tfP.WINDOW_QUANTILE, k=tfP.K) print('terrain points founded .....') terrain_grid_points = self.terrain_grid( points=terrain_points, metric=tgP.METRIC, K=tgP.K, grid_resolution=tgP.GRID_RESOLUTION) print('terrain grid was formed .....') surface = self.surface_fit(terrain_grid=terrain_grid_points, grid_resolution=tgP.GRID_RESOLUTION, u_degree=sfP.U_DEGREE, v_degree=sfP.V_DEGREE, delta=sfP.DELTA) # Create a visualization configuration instance with no legend, no axes and set the resolution to 120 dpi vis_config = VisMPL.VisConfig(ctrlpts=False, axes_equal=False) # Create a visualization method instance using the configuration above vis_obj = VisMPL.VisSurface(vis_config) # Set the visualization method of the curve object surface.vis = vis_obj surface.render(filename=self.path + 'surface_evaluation/' + "terrain.png", colormap=cm.cool, plot=False) print('surface was modeled .....') # Get the evaluated points surface_points = np.array(surface.evalpts) print('de-terrain points process') deTerreained_points = np.zeros_like(self.dws_point_cloud[out_flag, :]) for i, point in enumerate(tqdm(self.dws_point_cloud[out_flag, :])): clean_point = point.copy() point_dist = np.array( ((surface_points[:, 0] - point[0])**2 + (surface_points[:, 1] - point[1])**2)**(0.5)) clean_point[2] = clean_point[2] - surface_points[ np.argmin(point_dist), 2] deTerreained_points[i] = clean_point deTerreained_points[:, 2] = deTerreained_points[:, 2] + np.abs( deTerreained_points[:, 2].min()) store_point_cloud( self.path + 'surface_evaluation/' + "de-terrained_roi.las", deTerreained_points, self.header) save_img(deTerreained_points, 'de-terrained_roi_0_0', self.path + 'surface_evaluation/', 0, 0) save_img(deTerreained_points, 'de-terrained_roi_0_90', self.path + 'surface_evaluation/', 0, 90) print('point cloud was de-terrained ......') end = time.time() print('Time:{}'.format(end - start))
# Fix file path os.chdir(os.path.dirname(os.path.realpath(__file__))) # Create a NURBS curve instance (full circle) curve = NURBS.Curve() # Set evaluation delta curve.delta = 0.01 # Set up curve curve.read_ctrlpts_from_txt("ex_curve04.cptw") curve.degree = 2 # 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] # Convert to a 3D curve curve3d = curve.add_dimension() # Translate curve to z = 5 curve3d.translate((0, 0, 5)) # Draw the control point polygon and the evaluated curve if render_curve: vis_config = VisMPL.VisConfig(ctrlpts=True) vis_comp = VisMPL.VisCurve3D(vis_config) curve3d.vis = vis_comp curve3d.render() # Good to have something here to put a breakpoint pass
# (disp_X[1,7], -disp_Z[1,7]),] # 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()
# Get the control points from the generated grid surf04.ctrlpts2d = sg04.grid # Set knot vectors surf04.knotvector_u = utilities.generate_knot_vector(surf04.degree_u, surf04.ctrlpts_size_u) surf04.knotvector_v = utilities.generate_knot_vector(surf04.degree_v, surf04.ctrlpts_size_v) # Construct the parametric volume with a uniform knot vector pvolume = construct.construct_volume('w', surf01, surf02, surf03, surf04, degree=2) # Visualize volume pvolume.vis = vis.VisVolume(vis.VisConfig(ctrlpts=True, evalpts=False)) pvolume.render() # Knot vector refinement operations.refine_knotvector(pvolume, [1, 1, 1]) # Visualize volume after knot insertions pvolume.render() # Good to have something here to put a breakpoint pass
# -*- coding: utf-8 -*- """ Question 2a: Decompose the heart-shaped object in question 1 into Bezier curves and show all control points for each Bezier curve. """ import os from geomdl import BSpline from geomdl import utilities from geomdl import operations from geomdl.visualization import VisMPL from question_1 import generate_heart # Set up the visualisation settings vis_config = VisMPL.VisConfig( legend=False, ctrlpts=True) # Set ctrlpts=True to plot control points with the curves vis_comp = VisMPL.VisCurve2D(vis_config) # # Create the decomposed heart # # Generate the heart heart = generate_heart() # Decompose the B-Spline into Bezier curves heart_bezier = operations.decompose_curve(heart) # Set evaluation delta heart_bezier.delta = 0.001
def main(): points = np.loadtxt("N2_RV_P0.txt") zmin_loc_temp = np.where(points[:, 1] == 0)[0] zmin_loc = zmin_loc_temp # points = remove_3dpoint(points,zmin_loc) N = 5 slice(N, points) slice0 = slice.slices[0] x0 = slice0[:, 0] y0 = slice0[:, 1] z0 = slice0[:, 2] slice1 = slice.slices[1] x1 = slice1[:, 0] y1 = slice1[:, 1] z1 = slice1[:, 2] slice2 = slice.slices[2] x2 = slice2[:, 0] y2 = slice2[:, 1] z2 = slice2[:, 2] slice3 = slice.slices[3] x3 = slice3[:, 0] y3 = slice3[:, 1] z3 = slice3[:, 2] slice4 = slice.slices[4] x4 = slice4[:, 0] y4 = slice4[:, 1] z4 = slice4[:, 2] print(np.shape(points)) ranges = slice.bins diameter = x0.max() - x0.min() radius = diameter height = z0.max() diameter1 = x1.max() - x1.min() radius1 = diameter1 height1 = z1.max() diameter2 = x2.max() - x2.min() radius2 = diameter2 height2 = z2.max() diameter3 = x3.max() - x3.min() radius3 = diameter3 height3 = z3.max() diameter4 = x4.max() - x4.min() radius4 = diameter4 / 2 height4 = x4.max() # Generate a cylindrical surface using the shapes component cylinder = surface.cylinder(radius, height) # vis_config = VisMPL.VisConfig(ctrlpts=True) # vis_comp = VisMPL.VisSurface(config=vis_config) # cylinder.vis = vis_comp # cylinder.render() cyl_points = cylinder.evalpts print("*****************") # print(len(cyl_points)) print("*****************") cylinder1 = surface.cylinder(radius1, height1) cyl_points1 = cylinder1.evalpts # vis_config = VisMPL.VisConfig(ctrlpts=True) # vis_comp = VisMPL.VisSurface(config=vis_config) # cylinder1.vis = vis_comp # cylinder1.render() cylinder2 = surface.cylinder(radius2, height2) cyl_points2 = cylinder2.evalpts # vis_config = VisMPL.VisConfig(ctrlpts=True) # vis_comp = VisMPL.VisSurface(config=vis_config) # cylinder2.vis = vis_comp # cylinder2.render() cylinder3 = surface.cylinder(radius3, height3) cyl_points3 = cylinder3.evalpts # vis_config = VisMPL.VisConfig(ctrlpts=True) # vis_comp = VisMPL.VisSurface(config=vis_config) # cylinder2.vis = vis_comp # cylinder2.render() cylinder4 = surface.cylinder(radius4, height4) cyl_points4 = cylinder4.evalpts # vis_config = VisMPL.VisConfig(ctrlpts=True) # vis_comp = VisMPL.VisSurface(config=vis_config) # cylinder4.vis = vis_comp # cylinder4.render() #try using points from the surface not the control points cylinder_cpts = np.array(cylinder.ctrlpts) cylinder_cpts1 = np.array(cylinder1.ctrlpts) cylinder_cpts2 = np.array(cylinder2.ctrlpts) cylinder_cpts3 = np.array(cylinder3.ctrlpts) cylinder_cpts4 = np.array(cylinder4.ctrlpts) a = np.array(cdist(np.array(cyl_points), slice0)).min(axis=0) b = np.array(cdist(np.array(cyl_points1), slice1)).min(axis=0) c = np.array(cdist(np.array(cyl_points2), slice2)).min(axis=0) d = np.array(cdist(np.array(cyl_points3), slice3)).min(axis=0) e = np.array(cdist(np.array(cyl_points4), slice4)).min(axis=0) test = np.zeros((len(cylinder_cpts), 3)) test1 = np.zeros((len(cylinder_cpts1), 3)) test2 = np.zeros((len(cylinder_cpts2), 3)) test3 = np.zeros((len(cylinder_cpts3), 3)) test4 = np.zeros((len(cylinder_cpts4), 3)) for i in range(0, len(cylinder_cpts)): test[i] = (cylinder_cpts[i] / np.linalg.norm(cylinder_cpts[i])) * a[i] test1[i] = (cylinder_cpts1[i] / np.linalg.norm(cylinder_cpts1[i])) * b[i] test2[i] = (cylinder_cpts2[i] / np.linalg.norm(cylinder_cpts2[i])) * c[i] test3[i] = (cylinder_cpts3[i] / np.linalg.norm(cylinder_cpts3[i])) * d[i] test4[i] = (cylinder_cpts4[i] / np.linalg.norm(cylinder_cpts4[i])) * e[i] test_zeros_loc = np.where(test[:, 2] == 0)[0] test1_zeros_loc = np.where(test1[:, 2] == 0)[0] test2_zeros_loc = np.where(test2[:, 2] == 0)[0] test3_zeros_loc = np.where(test3[:, 2] == 0)[0] test4_zeros_loc = np.where(test4[:, 2] == 0)[0] test = remove_3dpoint(test, test_zeros_loc) test1 = remove_3dpoint(test1, test1_zeros_loc) test2 = remove_3dpoint(test2, test2_zeros_loc) test3 = remove_3dpoint(test3, test3_zeros_loc) test4 = remove_3dpoint(test4, test4_zeros_loc) test = np.array( [test[:, 0], test[:, 1], np.ones(len(test[:, 2])) * ranges[0]]).T test1 = np.array( [test1[:, 0], test1[:, 1], np.ones(len(test1[:, 2])) * ranges[1]]).T test2 = np.array( [test2[:, 0], test2[:, 1], np.ones(len(test2[:, 2])) * ranges[2]]).T test3 = np.array( [test3[:, 0], test3[:, 1], np.ones(len(test3[:, 2])) * ranges[3]]).T test4 = np.array( [test4[:, 0], test4[:, 1], np.ones(len(test4[:, 2])) * ranges[4]]).T # for i in range(0,len(test1)): # test1[i] = test1[i] + [0,0,height] # test2[i] = test2[i]+[0,0,height1] # test3[i] = test3[i]+[0,0,height2] test = remove_3dpoint(test, len(test) - 1) test1 = remove_3dpoint(test1, len(test1) - 1) test2 = remove_3dpoint(test2, len(test2) - 1) test3 = remove_3dpoint(test3, len(test3) - 1) test4 = remove_3dpoint(test4, len(test4) - 1) # test = np.insert(test,[0,len(test)],[[0,0,-5],[0,0,ranges[0]]],axis=0) # test1 = np.insert(test1,[0,len(test1)],[0,0,ranges[1]],axis=0) # test2 = np.insert(test2,[0,len(test2)],[0,0,ranges[2]],axis=0) test = np.insert( test, [len(test) - 2, len(test) - 1, len(test)], [test[0], test[1], test[2]], axis=0) test1 = np.insert( test1, [len(test1) - 2, len(test1) - 1, len(test1)], [test1[0], test1[1], test1[2]], axis=0) test2 = np.insert( test2, [len(test2) - 2, len(test2) - 1, len(test2)], [test2[0], test2[1], test2[2]], axis=0) test3 = np.insert( test3, [len(test3) - 2, len(test3) - 1, len(test3)], [test3[0], test3[1], test3[2]], axis=0) test = np.insert( test4, [len(test4) - 2, len(test4) - 1, len(test4)], [test4[0], test4[1], test4[2]], axis=0) # print(test) # print(test1) # print(test2) # print(test3) X = np.row_stack((test, test1, test2, test3, test4)) print(X) # np.random.shuffle(X) np.savetxt("cpts_test.csv", X, delimiter=",") # np.savetxt("cpts_test1.csv", test1, delimiter=",") fig = plt.figure() ax = plt.axes(projection="3d") ax.scatter3D(test[:, 0], test[:, 1], np.ones(len(test[:, 2])) * ranges[0], color='red') ax.scatter3D(test1[:, 0], test1[:, 1], test1[:, 2], color='blue') ax.scatter3D(test2[:, 0], test2[:, 1], test2[:, 2], color='green') ax.scatter3D(test3[:, 0], test3[:, 1], test3[:, 2], color='yellow') ax.scatter3D(test4[:, 0], test4[:, 1], test4[:, 2], color='purple') # ax.scatter3D(cylinder_cpts[:,0],cylinder_cpts[:,1],cylinder_cpts[:,2]) # ax.scatter3D(cylinder_cpts1[:,0],cylinder_cpts1[:,1],cylinder_cpts1[:,2]) # try fitting a NURBS Surface surf = NURBS.Surface() surf.delta = 0.03 p_ctrlpts = exchange.import_csv("cpts_test.csv") print(len(p_ctrlpts)) p_weights = np.ones((len(p_ctrlpts))) p_size_u = 9 p_size_v = 5 p_degree_u = 3 p_degree_v = 3 t_ctrlptsw = compat.combine_ctrlpts_weights(p_ctrlpts, p_weights) n_ctrlptsw = compat.flip_ctrlpts_u(t_ctrlptsw, p_size_u, p_size_v) n_knotvector_u = utils.generate_knot_vector(p_degree_u, p_size_u) n_knotvector_v = utils.generate_knot_vector(p_degree_v, p_size_v) surf.degree_u = p_degree_u surf.degree_v = p_degree_v surf.set_ctrlpts(n_ctrlptsw, p_size_u, p_size_v) surf.knotvector_u = n_knotvector_u surf.knotvector_v = n_knotvector_v vis_config = vis.VisConfig(ctrlpts=True, axes=True, legend=True) surf.vis = vis.VisSurface(vis_config) surf.evaluate() surf.render()
# Fix file path os.chdir(os.path.dirname(os.path.realpath(__file__))) # Create a NURBS curve instance (full circle) curve = NURBS.Curve() # Set evaluation delta curve.delta = 0.01 # Set up curve curve.read_ctrlpts_from_txt("ex_curve04.cptw") curve.degree = 2 # 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] # Decompose the curve into Bezier curve segments bezier = curve.decompose() # Plot the curves using the curve container bezier.delta = 0.01 if render_curve: vis_config = VisMPL.VisConfig(figure_size=[8, 8]) vis_comp = VisMPL.VisCurve2D(vis_config) bezier.vis = vis_comp bezier.render() # Good to have something here to put a breakpoint pass
# Set degrees surf03.degree_u = 1 surf03.degree_v = 1 # Get the control points from the generated grid surf03.ctrlpts2d = sg03.grid # Set knot vectors surf03.knotvector_u = utilities.generate_knot_vector( surf03.degree_u, surf03.ctrlpts_size_u) surf03.knotvector_v = utilities.generate_knot_vector( surf03.degree_v, surf03.ctrlpts_size_v) # Construct the parametric volume pvolume = construct.construct_volume(surf01, surf02, surf03, degree=1) pvolume.vis = vis.VisVoxel(vis.VisConfig(ctrlpts=False)) pvolume.delta_u = pvolume.delta_v = 0.025 pvolume.delta_w = 0.05 pvolume.render(evalcolor="firebrick", use_mp=True, num_procs=16) # Extract surfaces from the parametric volume surfvol = construct.extract_surfaces(pvolume) # Construct the isosurface msurf = multi.SurfaceContainer(surfvol['uv'][0], surfvol['uv'][-1], surfvol['uw'][0], surfvol['uw'][-1], surfvol['vw'][0], surfvol['vw'][-1]) msurf.vis = vis.VisSurface(vis.VisConfig(ctrlpts=False)) msurf.delta = 0.05 msurf.render(evalcolor=[ "skyblue", "cadetblue", "crimson", "crimson", "crimson", "crimson"
# Set degrees surf.degree_u = 3 surf.degree_v = 3 # Get the control points from the generated grid surf.ctrlpts2d = surfgrid.grid # Set knot vectors surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u, surf.ctrlpts_size_u) surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v, surf.ctrlpts_size_v) # Set sample size of the surface surf.sample_size = 50 # Generate the visualization component and its configuration vis_config = vis.VisConfig(ctrlpts=True, legend=False) vis_comp = vis.VisSurface(vis_config) # Set visualization component of the surface surf.vis = vis_comp # Plot the surface surf.render() # Export the surface as a .stl file exchange.export_stl(surf, "bump_smoother_1pt-padding.stl") # Good to have something here to put a breakpoint pass
[0, 4, 0], [0, 8, -3], [2, 0, 6], [2, 4, 0], [2, 8, 0], [4, 0, 0], [4, 4, 0], [4, 8, 3], [6, 0, 0], [6, 4, -3], [6, 8, 0], ] surf.set_ctrlpts(control_points, 4, 3) surf.knotvector_u = [0, 0, 0, 0, 1, 1, 1, 1] surf.knotvector_v = [0, 0, 0, 1, 1, 1] # surf.delta = 0.05 surf.delta = 0.20 # 0.20 for testing, was originally 0.05 for smoothness # 0.20, with 1.0 / 0.20 = 5.0, # gives a matrix of [5x5] evalution points found by > surf.evalpts # surf.vis = vis.VisSurface() surf.vis = vis.VisSurface(vis.VisConfig(alpha=0.8)) surface_points = surf.evalpts print(surface_points) surf.render() # surface 2, to come.
# Create a NURBS surface instance surf = NURBS.Surface() # Set degress surf.degree_u = 2 surf.degree_v = 2 # Set control points surf.set_ctrlpts(*exchange.import_txt("ex_torus.cptw", two_dimensional=True)) # Set knot vectors surf.knotvector_u = [0, 0, 0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1, 1, 1] surf.knotvector_v = [0, 0, 0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1, 1, 1] # Set sample size and evaluate surface surf.sample_size = 25 surf.evaluate() # Import colormaps from matplotlib import cm # Plot the surface vis_config = VisMPL.VisConfig(ctrlpts=True, axes=True, legend=False) vis_comp = VisMPL.VisSurfTriangle(vis_config) surf.vis = vis_comp surf.render(colormap=cm.coolwarm) # Good to have something here to put a breakpoint pass