def plotNURBSSurfaces(self, left_pts, right_pts, corsequences, lsagsequences, rsagsequences, degree=3, visualization_type=-1): left_surface = self.createNURBSSurface(pts=left_pts, corsequences=corsequences, sagsequences=lsagsequences) right_surface = self.createNURBSSurface(pts=right_pts, corsequences=corsequences, sagsequences=rsagsequences) # Create a MultiSurface surfaces = Multi.MultiSurface() surfaces.add(left_surface) surfaces.add(right_surface) # Set visualization component if visualization_type == 0: surfaces.delta = 0.01 vis_comp = VisMPL.VisSurfScatter() elif visualization_type == 1: vis_comp = VisMPL.VisSurface() elif visualization_type == 2: vis_comp = VisMPL.VisSurfWireframe() else: vis_comp = VisMPL.VisSurfTriangle() surfaces.vis = vis_comp # Render the surface surfaces.render()
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_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_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_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_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_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_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_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_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_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 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 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 plotBsplineSurface(self, pts, corsequences, lsagsequences=[], rsagsequences=[], degree=3, visualization_type=-1, side=2): # side = 0 (Left) | side = 1 (Right) if side == 0: lsurface = self.createBsplineSurface(pts=pts, corsequences=corsequences, sagsequences=lsagsequences) # Set visualization component if visualization_type == 0: lsurface.delta = 0.01 vis_comp = VisMPL.VisSurfScatter() elif visualization_type == 1: vis_comp = VisMPL.VisSurface() elif visualization_type == 2: vis_comp = VisMPL.VisSurfWireframe() else: vis_comp = VisMPL.VisSurfTriangle() lsurface.vis = vis_comp # Render the surface lsurface.render() else: rsurface = self.createBsplineSurface(pts=pts, corsequences=corsequences, sagsequences=rsagsequences) # Set visualization component if visualization_type == 0: rsurface.delta = 0.01 vis_comp = VisMPL.VisSurfScatter() elif visualization_type == 1: vis_comp = VisMPL.VisSurface() elif visualization_type == 2: vis_comp = VisMPL.VisSurfWireframe() else: vis_comp = VisMPL.VisSurfTriangle() rsurface.vis = vis_comp # Render the surface rsurface.render()
def draw_curve(self, 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.VisCurve3D() curve.vis = vis_comp curve.render()
def test_deriv_surf_fig(bspline_surface): fname = "test-derivative_surface.png" data = operations.derivative_surface(bspline_surface) multi_shape = multi.SurfaceContainer(data) multi_shape.vis = VisMPL.VisSurface() 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 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
def draw_curves(self, curvespts): # Try to load the visualization module try: render_curve = True from geomdl.visualization import VisMPL except ImportError: render_curve = False # Plot the curves using the curve container curves = Multi.MultiCurve() curves.delta = 0.01 for curve in curvespts: curves.add(curve) if render_curve: vis_comp = VisMPL.VisCurve3D() curves.vis = vis_comp curves.render()
t_ctrlptsw = compat.combine_ctrlpts_weights(p_ctrlpts, p_weights) n_ctrlptsw = compat.flip_ctrlpts_u(t_ctrlptsw, p_size_u, p_size_v) # Since we have no information on knot vectors, let's auto-generate them 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) # # Import surface to NURBS-Python # surf = NURBS.Surface() surf.degree_u = p_degree_u surf.degree_v = p_degree_v surf.ctrlpts_size_u = p_size_u surf.ctrlpts_size_v = p_size_v surf.ctrlptsw = n_ctrlptsw surf.knotvector_u = n_knotvector_u surf.knotvector_v = n_knotvector_v # Set evaluation delta surf.delta = 0.05 # Set visualization component vis_comp = VisMPL.VisSurfTriangle() surf.vis = vis_comp # Render the surface surf.render()
for j in range(curve_geometry.NbPoles): data = model_part.GetNode(j + 1).X, model_part.GetNode( j + 1).Y, model_part.GetNode(j + 1).Z ctlpts_list.write( str(model_part.GetNode(j + 1).X) + ',' + str(model_part.GetNode(j + 1).Y) + ',' + str(model_part.GetNode(j + 1).Z) + '\n') ctlpts_list.close() plot_curve.ctrlpts = exchange.import_txt( "C:\_Masterarbeit\BeamValidation\python_base\Balken\ctlpts_list.txt") plot_curve.knotvector = utilities.generate_knot_vector( plot_curve.degree, len(plot_curve.ctrlpts)) # Set evaluation delta # plot_curve.delta = 0.001 # plot_curve.evaluate # add to mulit_curve multi_curve.add(plot_curve) # Set evaluation delta multi_curve.delta = 0.001 # multi_curve.evaluate # plot the controlpoint polygon and the evaluated curve vis_comp = VisMPL.VisCurve3D() multi_curve.vis = vis_comp multi_curve multi_curve.render(cpcolor='black', evalcolor='red') # multi_curve.render() pass
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()
# 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)
points = np.array([[math.cos(u)*math.cos(v), math.cos(v)*math.sin(u),math.sin(v)] for u in np.linspace(0,2*math.pi,num=30) for v in np.linspace(-math.pi/2,math.pi/2,num=30)]) # print(points) # fig = plt.figure() # ax = Axes3D(fig) # ax.plot(points[:,0],points[:,1],points[:,2],'o',markersize=2) # plt.show() surf = approximate_surface(points.tolist(),30,30,3,3,ctrlpts_size_u=10,ctrlpts_size_v=10) surf.delta = 0.05 surf.vis = VisMPL.VisSurfWireframe() # surf.render() div = 100 evalpts = np.array([surf.evaluate_list([(u,v) for v in np.linspace(0,1,div)]) for u in np.linspace(0,1,div)]) print(evalpts.shape) fig = plt.figure() ax = Axes3D(fig) # all_points = np.reshape(evalpts,(div*div,3)) # ax.plot(all_points[:,0],all_points[:,1],all_points[:,2],'o',markersize=2) # points33 = np.reshape(evalpts[10:13,10:13,:],(9,3)) # ax.plot(points33[:,0],points33[:,1],points33[:,2],'o',markersize=2)
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
# 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