def build_geomdl(cls, degree_u, degree_v, knotvector_u, knotvector_v, control_points, weights, normalize_knots=False): def convert_row(verts_row, weights_row): return [(x * w, y * w, z * w, w) for (x, y, z), w in zip(verts_row, weights_row)] if weights is None: surf = BSpline.Surface(normalize_kv=normalize_knots) else: surf = NURBS.Surface(normalize_kv=normalize_knots) surf.degree_u = degree_u surf.degree_v = degree_v if weights is None: ctrlpts = control_points else: ctrlpts = list(map(convert_row, control_points, weights)) surf.ctrlpts2d = ctrlpts surf.knotvector_u = knotvector_u surf.knotvector_v = knotvector_v result = SvGeomdlSurface(surf) result.u_bounds = surf.knotvector_u[0], surf.knotvector_u[-1] result.v_bounds = surf.knotvector_v[0], surf.knotvector_v[-1] return result
def createNURBSSurface(self, pts, corsequences, sagsequences, degree=3): # Dimensions of the control points grid npoints_u = len(corsequences) npoints_v = len(sagsequences) # Weights vector weights = [1] * (npoints_u * npoints_v) # Combine weights vector with the control points list t_ctrlptsw = compat.combine_ctrlpts_weights(pts, weights) # Since NURBS-Python uses v-row order, we need to convert the exported ones n_ctrlptsw = compat.change_ctrlpts_row_order(t_ctrlptsw, npoints_u, npoints_v) # Since we have no information on knot vectors, let's auto-generate them n_knotvector_u = utils.generate_knot_vector(degree, npoints_u) n_knotvector_v = utils.generate_knot_vector(degree, npoints_v) # Create a NURBS surface instance surf = NURBS.Surface() # Using __call__ method to fill the surface object surf(degree, degree, npoints_u, npoints_v, n_ctrlptsw, n_knotvector_u, n_knotvector_v) return surf
def cylinder(radius=1, height=1): """ Generates a NURBS cylindrical surface. The cylindrical surface example is kindly contributed by John-Eric Dufour. :param radius: radius of the cylinder :type radius: int, float :param height: height of the cylinder :type height: int, float :return: a NURBS surface :rtype: NURBS.Surface """ if radius <= 0 or height <= 0: raise ValueError("Radius and/or height cannot be less than and equal to zero") # Control points for a base cylinder control_points = [[[1.0, 0.0, 0.0, 1.0], [0.7071, 0.7071, 0.0, 0.7071], [0.0, 1.0, 0.0, 1.0], [-0.7071, 0.7071, 0.0, 0.7071], [-1.0, 0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0, 0.7071], [0.0, -1.0, 0.0, 1.0], [0.7071, -0.7071, 0.0, 0.7071], [1.0, 0.0, 0.0, 1.0]], [[1.0, 0.0, 1.0, 1.0], [0.7071, 0.7071, 0.7071, 0.7071], [0.0, 1.0, 1.0, 1.0], [-0.7071, 0.7071, 0.7071, 0.7071], [-1.0, 0.0, 1.0, 1.0], [-0.7071, -0.7071, 0.7071, 0.7071], [0.0, -1.0, 1.0, 1.0], [0.7071, -0.7071, 0.7071, 0.7071], [1.0, 0.0, 1.0, 1.0]]] # Set height if height != 1: ctrlpts_top = [] for point in control_points[1]: npt = point npt[2] = npt[2] * height ctrlpts_top.append(npt) control_points[1] = ctrlpts_top # Set radius ctrlpts = [] if radius != 1: for row in control_points: temp = [] for point in row: npt = [i * radius for i in point[0:2]] npt.append(point[2]) npt.append(point[3]) temp.append(npt) ctrlpts.append(temp) else: ctrlpts = control_points # Generate the surface surface = NURBS.Surface() surface.degree_u = 1 surface.degree_v = 2 surface.ctrlpts2d = ctrlpts surface.knotvector_u = [0.0, 0.0, 1.0, 1.0] surface.knotvector_v = [0.0, 0.0, 0.0, 0.25, 0.25, 0.5, 0.5, 0.75, 0.75, 1.0, 1.0, 1.0] # Return the generated surface return surface
def __init__(self, geomData): self.surf = NURBS.Surface() self.surf.degree_u = geomData['degree_u'] self.surf.degree_v = geomData['degree_v'] self.surf.ctrlpts_size_u = geomData['ctrlpts_size_u'] self.surf.ctrlpts_size_v = geomData['ctrlpts_size_v'] self.surf.ctrlpts = self.getUnweightedCpts(geomData['ctrlpts'], geomData['weights']) self.surf.weights = geomData['weights'] self.surf.knotvector_u = geomData['knotvector_u'] self.surf.knotvector_v = geomData['knotvector_v']
def nurbs_surface(): """ Creates a NURBS surface instance """ surf = NURBS.Surface() surf.degree_u = 2 surf.degree_v = 2 surf.ctrlpts_size_u = 3 surf.ctrlpts_size_v = 3 surf.ctrlpts = [[0, 0, 0], [0, 1, 0], [0, 2, -3], [1, 0, 6], [1, 1, 0], [1, 2, 0], [2, 0, 0], [2, 1, 0], [2, 2, 3]] # use the auto-generated weights vector surf.knotvector_u = [0, 0, 0, 1, 1, 1] surf.knotvector_v = [0, 0, 0, 1, 1, 1] return surf
def init_nurbs(p, q, knot_u, knot_v, ctrlpts): """Create a python NURBS surface object :param p,q: degree in U and V directions :param knot_u,knot_v: knot vectors in U and V directions :param ctrlpts: control point matrix """ surf = NURBS.Surface() surf.degree_u = p surf.degree_v = q surf.ctrlpts2d = ctrlpts.tolist() surf.knotvector_u = knot_u surf.knotvector_v = knot_v return surf
def test_nurbs_surface_weights3(): surf = NURBS.Surface() ctrlpts = [[1.0, 1.0, 10.0, 1.0], [1.0, 2.0, 11.0, 1.0], [1.0, 3.0, 12.0, 1.0], [2.0, 1.0, 13.0, 1.0], [2.0, 2.0, 14.0, 0.5], [2.0, 3.0, 15.0, 1.0], [3.0, 1.0, 16.0, 0.2], [3.0, 2.0, 17.0, 1.0], [3.0, 3.0, 18.0, 1.0], [4.0, 1.0, 19.0, 1.0], [4.0, 2.0, 20.0, 1.0], [4.0, 3.0, 21.0, 1.0]] surf.ctrlpts_size_v = 3 surf.ctrlpts_size_u = 4 surf.degree_u = 2 surf.degree_v = 2 surf.ctrlptsw = ctrlpts # Check assignment assert surf.weights[4] == 0.5
def test_nurbs_surface_ctrlpts2(): surf = NURBS.Surface() ctrlpts = [[1.0, 1.0, 10.0, 1.0], [1.0, 2.0, 11.0, 1.0], [1.0, 3.0, 12.0, 1.0], [2.0, 1.0, 13.0, 1.0], [2.0, 2.0, 14.0, 1.0], [2.0, 3.0, 15.0, 1.0], [3.0, 1.0, 16.0, 1.0], [3.0, 2.0, 17.0, 1.0], [3.0, 3.0, 18.0, 1.0], [4.0, 1.0, 19.0, 1.0], [4.0, 2.0, 20.0, 1.0], [4.0, 3.0, 21.0, 1.0]] surf.ctrlpts_size_v = 3 surf.ctrlpts_size_u = 4 surf.degree_u = 2 surf.degree_v = 2 surf.ctrlptsw = ctrlpts # Check assignment assert surf.ctrlpts2d[2][1] == [3.0, 2.0, 17.0, 1.0]
def nurbs_surface(): """ Creates a NURBS Surface instance """ # Create a surface instance surf = NURBS.Surface() # Set degrees surf.degree_u = 3 surf.degree_v = 3 # Set weighted control points surf.set_ctrlpts(CONTROL_POINTS, 6, 6) # Set knot vectors surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] return surf
def test_nurbs_surface_knot_vector_v(): surf = NURBS.Surface() ctrlpts = [[1.0, 1.0, 10.0, 1.0], [1.0, 2.0, 11.0, 1.0], [1.0, 3.0, 12.0, 1.0], [2.0, 1.0, 13.0, 1.0], [2.0, 2.0, 14.0, 1.0], [2.0, 3.0, 15.0, 1.0], [3.0, 1.0, 16.0, 1.0], [3.0, 2.0, 17.0, 1.0], [3.0, 3.0, 18.0, 1.0], [4.0, 1.0, 19.0, 1.0], [4.0, 2.0, 20.0, 1.0], [4.0, 3.0, 21.0, 1.0]] surf.ctrlpts_size_v = 3 surf.ctrlpts_size_u = 4 surf.degree_u = 2 surf.degree_v = 2 surf.ctrlptsw = ctrlpts surf.knotvector_u = [0.0, 0.0, 0.0, 0.5, 1.0, 1.0, 1.0] surf.knotvector_v = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0] assert surf.knotvector_v == [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
def nurbs_surface2(): """ Creates a NURBS Surface instance (alternative control points) """ # Create a surface instance surf = NURBS.Surface() # Set degrees surf.degree_u = 3 surf.degree_v = 3 # Set weighted control points surf.ctrlpts_size_u = 6 surf.ctrlpts_size_v = 6 surf.ctrlptsw = CONTROL_POINTS2 # Set knot vectors surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] return surf
def load_spline_surf(self, spline): # Create a BSpline surface if spline["v_rational"] or spline["u_rational"]: surf = NURBS.Surface() control_points = np.array(spline["poles"]) size_u, size_v = control_points.shape[0], control_points.shape[1] # Set degrees surf.degree_u = spline["u_degree"] surf.degree_v = spline["v_degree"] # Set control points surf.ctrlpts2d = np.concatenate( [control_points, np.ones((size_u, size_v, 1))], 2).tolist() surf.knotvector_v = spline["v_knots"] surf.knotvector_u = spline["u_knots"] weights = spline["weights"] l = [] for i in weights: l += i surf.weights = l return surf else: surf = BSpline.Surface() # Set degrees surf.degree_u = spline["u_degree"] surf.degree_v = spline["v_degree"] # Set control points surf.ctrlpts2d = spline["poles"] # Set knot vectors surf.knotvector_u = spline["u_knots"] surf.knotvector_v = spline["v_knots"] return surf
] return content_arr except IOError as e: print("An error occurred: {}".format(e.args[-1])) raise e # duck1.nurbs # Process control points and weights d2_ctrlpts = exchange.import_txt("duck1.ctrlpts", separator=" ") d1_weights = read_weights("duck1.weights") d1_ctrlptsw = compatibility.combine_ctrlpts_weights(d2_ctrlpts, d1_weights) # Create a NURBS surface duck1 = NURBS.Surface() duck1.name = "body" duck1.order_u = 4 duck1.order_v = 4 duck1.ctrlpts_size_u = 14 duck1.ctrlpts_size_v = 13 duck1.ctrlptsw = d1_ctrlptsw duck1.knotvector_u = [ -1.5708, -1.5708, -1.5708, -1.5708, -1.0472, -0.523599, 0, 0.523599, 0.808217, 1.04015, 1.0472, 1.24824, 1.29714, 1.46148, 1.5708, 1.5708, 1.5708, 1.5708 ] duck1.knotvector_v = [ -3.14159, -3.14159, -3.14159, -3.14159, -2.61799, -2.0944, -1.0472, -0.523599, 6.66134e-016, 0.523599, 1.0472, 2.0944, 2.61799, 3.14159, 3.14159, 3.14159, 3.14159
# # Prepare data for import # 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
def make_surface(self, face, degree_u, degree_v, vertices, planes, vert_weights, tangent_weights, face_weight, edge_weights_dict, edge_planes_dict): """ V0 ------ [E01] --- [E0C] --- [E02] --- V1 | | | | | | | | | | | | | | | [E11] --- [F1] ---- [E0F] --- [F2] --- [E21] | | | | | | | | | | | | | | | [E1C] --- [E1F] --- [CC] --- [E2F] --- [E2C] | | | | | | | | | | | | | | | [E12] --- [F3] ---- [E3F] --- [F4] --- [E22] | | | | | | | | | | | | | | | V3 ------ [E31] --- [E3C] --- [E32] --- V2 """ tangent_weights = [w / 3.0 for w in tangent_weights] vertices = [Vector(v) for v in vertices] def mk_edge_point(i, j): return (vertices[j] - vertices[i]) * tangent_weights[i] + vertices[i] def mk_face_corner_point(i, j, k): dv1 = (vertices[j] - vertices[i]) * tangent_weights[i] dv2 = (vertices[k] - vertices[i]) * tangent_weights[i] #m = face_weight return planes[i].projection_of_point(vertices[i] + dv1 + dv2) # edge planes e0p = edge_planes_dict[(face[0], face[1])] e1p = edge_planes_dict[(face[0], face[3])] e2p = edge_planes_dict[(face[1], face[2])] e3p = edge_planes_dict[(face[2], face[3])] def mk_edge_center_point(ep1, ep2): return (ep1 + ep2) / 2.0 def mk_face_edge_point(edge_plane, edge_point, edge_vec, vec1, vec2): length = (vec1.length + vec2.length) / 2.0 vec = edge_plane.normal.cross(edge_vec) #print("EV: %s, N: %s, L: %s, Res: %s" % (edge_vec, edge_plane.normal, length, vec)) vec = length * vec.normalized() return edge_point + vec e01 = planes[0].projection_of_point(mk_edge_point(0, 1)) e02 = planes[1].projection_of_point(mk_edge_point(1, 0)) e11 = planes[0].projection_of_point(mk_edge_point(0, 3)) e21 = planes[1].projection_of_point(mk_edge_point(1, 2)) f1 = mk_face_corner_point(0, 1, 3) f2 = mk_face_corner_point(1, 0, 2) e12 = planes[3].projection_of_point(mk_edge_point(3, 0)) e31 = planes[3].projection_of_point(mk_edge_point(3, 2)) e32 = planes[2].projection_of_point(mk_edge_point(2, 3)) e22 = planes[2].projection_of_point(mk_edge_point(2, 1)) f3 = mk_face_corner_point(3, 0, 2) f4 = mk_face_corner_point(2, 3, 1) e0c = mk_edge_center_point(e01, e02) e1c = mk_edge_center_point(e11, e12) e2c = mk_edge_center_point(e21, e22) e3c = mk_edge_center_point(e31, e32) e0f = mk_face_edge_point(e0p, e0c, (vertices[1] - vertices[0]), (f1 - e01), (f2 - e02)) e1f = mk_face_edge_point(e1p, e1c, (vertices[0] - vertices[3]), (f3 - e12), (f1 - e11)) e2f = mk_face_edge_point(e2p, e2c, (vertices[2] - vertices[1]), (f2 - e21), (f4 - e22)) e3f = mk_face_edge_point(e3p, e3c, (vertices[3] - vertices[2]), (f3 - e31), (f4 - e32)) cc = center([f1, e0f, f2, e2f, f4, e3f, f3, e1f]) control_points = [ vertices[0], e01, e0c, e02, vertices[1], e11, f1, e0f, f2, e21, e1c, e1f, cc, e2f, e2c, e12, f3, e3f, f4, e22, vertices[3], e31, e3c, e32, vertices[2] ] # edge point weights e0w = edge_weights_dict[(face[0], face[1])] e1w = edge_weights_dict[(face[0], face[3])] e2w = edge_weights_dict[(face[1], face[2])] e3w = edge_weights_dict[(face[2], face[3])] weights = [ vert_weights[0], e0w, e0w, e0w, vert_weights[1], e1w, face_weight, face_weight, face_weight, e2w, e1w, face_weight, face_weight, face_weight, e2w, e1w, face_weight, face_weight, face_weight, e2w, vert_weights[3], e3w, e3w, e3w, vert_weights[2] ] surface = NURBS.Surface() surface.degree_u = degree_u surface.degree_v = degree_v surface.ctrlpts_size_u = 5 surface.ctrlpts_size_v = 5 surface.ctrlpts = control_points surface.weights = weights surface.knotvector_u = knotvector.generate(surface.degree_u, 5) surface.knotvector_v = knotvector.generate(surface.degree_v, 5) new_surf = SvExGeomdlSurface(surface) return new_surf, control_points, weights
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()
def test_bspline_surface_degree_u(): surf = NURBS.Surface() surf.degree_u = 7 # Check assignment assert surf.degree_u == 7
def process(self): vertices_s = self.inputs['ControlPoints'].sv_get() has_weights = self.inputs['Weights'].is_linked weights_s = self.inputs['Weights'].sv_get(default=[[1.0]]) samples_s = self.inputs['Samples'].sv_get() u_size_s = self.inputs['USize'].sv_get() knots_u_s = self.inputs['KnotsU'].sv_get(default=[[]]) knots_v_s = self.inputs['KnotsV'].sv_get(default=[[]]) degree_u_s = self.inputs['DegreeU'].sv_get() degree_v_s = self.inputs['DegreeV'].sv_get() if self.input_mode == '1D': vertices_s = ensure_nesting_level(vertices_s, 3) else: vertices_s = ensure_nesting_level(vertices_s, 4) def convert_row(verts_row, weights_row): return [(x, y, z, w) for (x, y, z), w in zip(verts_row, weights_row)] verts_out = [] edges_out = [] faces_out = [] surfaces_out = [] inputs = zip_long_repeat(vertices_s, weights_s, knots_u_s, knots_v_s, degree_u_s, degree_v_s, samples_s, u_size_s) for vertices, weights, knots_u, knots_v, degree_u, degree_v, samples, u_size in inputs: if isinstance(samples, (list, tuple)): samples = samples[0] if isinstance(degree_u, (tuple, list)): degree_u = degree_u[0] if isinstance(degree_v, (tuple, list)): degree_v = degree_v[0] if isinstance(u_size, (list, tuple)): u_size = u_size[0] if self.input_mode == '1D': fullList(weights, len(vertices)) else: if isinstance(weights[0], (int, float)): weights = [weights] fullList(weights, len(vertices)) for verts_u, weights_u in zip(vertices, weights): fullList(weights_u, len(verts_u)) # Generate surface if self.surface_mode == 'NURBS': surf = NURBS.Surface(normalize_kv=self.normalize_knots) else: # BSPLINE surf = BSpline.Surface(normalize_kv=self.normalize_knots) surf.degree_u = degree_u surf.degree_v = degree_v if self.input_mode == '1D': n_v = u_size n_u = len(vertices) // n_v vertices = grouper(vertices, n_u) weights = grouper(weights, n_u) if self.knot_mode == 'AUTO': if self.is_cyclic_v: for row_idx in range(len(vertices)): vertices[row_idx].extend( vertices[row_idx][:degree_v + 1]) weights[row_idx].extend( weights[row_idx][:degree_v + 1]) if self.is_cyclic_u: vertices.extend(vertices[:degree_u + 1]) weights.extend(weights[:degree_u + 1]) self.debug("UxV: %s x %s", len(vertices), len(vertices[0])) # Control points if self.surface_mode == 'NURBS': ctrlpts = list(map(convert_row, vertices, weights)) surf.ctrlpts2d = ctrlpts else: surf.ctrlpts2d = vertices n_u_total = len(vertices) n_v_total = len(vertices[0]) if self.knot_mode == 'AUTO': if self.is_cyclic_u: knots_u = list(range(n_u_total + degree_u + 1)) else: knots_u = knotvector.generate(surf.degree_u, n_u_total) self.debug("Auto knots U: %s", knots_u) surf.knotvector_u = knots_u if self.is_cyclic_v: knots_v = list(range(n_v_total + degree_v + 1)) else: knots_v = knotvector.generate(surf.degree_v, n_v_total) self.debug("Auto knots V: %s", knots_v) surf.knotvector_v = knots_v else: surf.knotvector_u = knots_u surf.knotvector_v = knots_v new_surf = SvExGeomdlSurface(surf) if self.is_cyclic_u: u_min = surf.knotvector_u[degree_u] u_max = surf.knotvector_u[-degree_u - 2] new_surf.u_bounds = u_min, u_max print("U:", new_surf.u_bounds) else: u_min = min(surf.knotvector_u) u_max = max(surf.knotvector_u) new_surf.u_bounds = u_min, u_max if self.is_cyclic_v: v_min = surf.knotvector_v[degree_v] v_max = surf.knotvector_v[-degree_v - 2] new_surf.v_bounds = v_min, v_max print("V:", new_surf.v_bounds) else: v_min = min(surf.knotvector_v) v_max = max(surf.knotvector_v) new_surf.v_bounds = v_min, v_max surfaces_out.append(new_surf) if self.make_grid: surf.sample_size = samples surf.tessellate() new_verts = [vert.data for vert in surf.vertices] new_faces = [f.data for f in surf.faces] else: new_verts = [] new_faces = [] verts_out.append(new_verts) faces_out.append(new_faces) if self.make_grid: self.outputs['Vertices'].sv_set(verts_out) self.outputs['Faces'].sv_set(faces_out) self.outputs['Surface'].sv_set(surfaces_out)
def test_nurbs_surface_degree_v(): surf = NURBS.Surface() surf.degree_v = 4 # Check assignment assert surf.degree_v == 4