def intersect_surface_plane_msquares(surface, plane, need_points=True, samples_u=50, samples_v=50): u_min, u_max = surface.get_u_min(), surface.get_u_max() v_min, v_max = surface.get_v_min(), surface.get_v_max() u_range = np.linspace(u_min, u_max, num=samples_u) v_range = np.linspace(v_min, v_max, num=samples_v) us, vs = np.meshgrid(u_range, v_range, indexing='ij') us, vs = us.flatten(), vs.flatten() surface_points = surface.evaluate_array(us, vs) normal = np.array(plane.normal) p2 = np.apply_along_axis(lambda p: normal.dot(p), 1, surface_points) data = p2 + plane.d data = data.reshape((samples_u, samples_v)) contours = measure.find_contours(data, level=0.0) u_size = (u_max - u_min) / samples_u v_size = (v_max - v_min) / samples_v uv_points, _, _ = make_contours(samples_u, samples_v, u_min, u_size, v_min, v_size, 0, contours, make_faces=False, connect_bounds=False) if need_points: points = [] for uv_i in uv_points: us_i = [p[0] for p in uv_i] vs_i = [p[1] for p in uv_i] ps = surface.evaluate_array(np.array(us_i), np.array(vs_i)).tolist() points.append(ps) else: points = [] return uv_points, points
def process(self): if not any(socket.is_linked for socket in self.outputs): return fields_s = self.inputs['Field'].sv_get() surface_s = self.inputs['Surface'].sv_get() samples_u_s = self.inputs['SamplesU'].sv_get() samples_v_s = self.inputs['SamplesV'].sv_get() value_s = self.inputs['Value'].sv_get() fields_s = ensure_nesting_level(fields_s, 2, data_types=(SvScalarField, )) surface_s = ensure_nesting_level(surface_s, 2, data_types=(SvSurface, )) samples_u_s = ensure_nesting_level(samples_u_s, 2) samples_v_s = ensure_nesting_level(samples_v_s, 2) value_s = ensure_nesting_level(value_s, 2) verts_out = [] edges_out = [] uv_verts_out = [] for field_i, surface_i, samples_u_i, samples_v_i, value_i in zip_long_repeat( fields_s, surface_s, samples_u_s, samples_v_s, value_s): for field, surface, samples_u, samples_v, value in zip_long_repeat( field_i, surface_i, samples_u_i, samples_v_i, value_i): surface_verts = [] surface_uv = [] surface_edges = [] u_min, u_max = surface.get_u_min(), surface.get_u_max() v_min, v_max = surface.get_v_min(), surface.get_v_max() u_range = np.linspace(u_min, u_max, num=samples_u) v_range = np.linspace(v_min, v_max, num=samples_v) us, vs = np.meshgrid(u_range, v_range, indexing='ij') us, vs = us.flatten(), vs.flatten() surface_points = surface.evaluate_array(us, vs) xs = surface_points[:, 0] ys = surface_points[:, 1] zs = surface_points[:, 2] field_values = field.evaluate_grid(xs, ys, zs) field_values = field_values.reshape((samples_u, samples_v)) contours = measure.find_contours(field_values, level=value) u_size = (u_max - u_min) / samples_u v_size = (v_max - v_min) / samples_v uv_contours, new_edges, _ = make_contours( samples_u, samples_v, u_min, u_size, v_min, v_size, 0, contours, make_faces=True, connect_bounds=self.connect_bounds) if uv_contours: for uv_points in uv_contours: us = np.array([p[0] for p in uv_points]) vs = np.array([p[1] for p in uv_points]) new_verts = surface.evaluate_array(us, vs).tolist() surface_uv.append(uv_points) surface_verts.append(new_verts) surface_edges.extend(new_edges) if self.join: surface_verts, surface_edges, _ = mesh_join( surface_verts, surface_edges, [[]] * len(surface_edges)) surface_uv = sum(surface_uv, []) verts_out.append(surface_verts) uv_verts_out.append(surface_uv) edges_out.append(surface_edges) else: verts_out.append([]) uv_verts_out.append([]) edges_out.append([]) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) if 'UVVertices' in self.outputs: self.outputs['UVVertices'].sv_set(uv_verts_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return field_s = self.inputs['Field'].sv_get() bounds_s = self.inputs['Bounds'].sv_get() samples_xy_s = self.inputs['SamplesXY'].sv_get() samples_z_s = self.inputs['SamplesZ'].sv_get() samples_value_s = self.inputs['ValueSamples'].sv_get() verts_out = [] edges_out = [] faces_out = [] inputs = zip_long_repeat(field_s, bounds_s, samples_xy_s, samples_z_s, samples_value_s) for field, bounds, samples_xy, samples_z, samples_value in inputs: if isinstance(samples_xy, (list, tuple)): samples_xy = samples_xy[0] if isinstance(samples_z, (list, tuple)): samples_z = samples_z[0] if isinstance(samples_value, (list, tuple)): samples_value = samples_value[0] b1, b2 = self.get_bounds(bounds) min_x, max_x = b1[0], b2[0] min_y, max_y = b1[1], b2[1] min_z, max_z = b1[2], b2[2] x_size = (max_x - min_x) / samples_xy y_size = (max_y - min_y) / samples_xy x_range = np.linspace(min_x, max_x, num=samples_xy) y_range = np.linspace(min_y, max_y, num=samples_xy) z_range = np.linspace(min_z, max_z, num=samples_z) xs, ys, zs = np.meshgrid(x_range, y_range, z_range, indexing='ij') xs, ys, zs = xs.flatten(), ys.flatten(), zs.flatten() field_values = field.evaluate_grid(xs, ys, zs) min_field = field_values.min() max_field = field_values.max() field_values = field_values.reshape( (samples_xy, samples_xy, samples_z)) field_stops = np.linspace(min_field, max_field, num=samples_value) new_verts = [] new_edges = [] new_faces = [] for i in range(samples_z): z_value = zs[i] z_verts = [] z_edges = [] z_faces = [] for j in range(samples_value): value = field_stops[j] contours = measure.find_contours(field_values[:, :, i], level=value) value_verts, value_edges, value_faces = make_contours( samples_xy, samples_xy, min_x, x_size, min_y, y_size, z_value, contours, make_faces=self.make_faces, connect_bounds=self.connect_bounds) if value_verts: z_verts.extend(value_verts) z_edges.extend(value_edges) z_faces.extend(value_faces) new_verts.extend(z_verts) new_edges.extend(z_edges) new_faces.extend(z_faces) if self.join: new_verts, new_edges, new_faces = mesh_join( new_verts, new_edges, new_faces) verts_out.append(new_verts) edges_out.append(new_edges) faces_out.append(new_faces) else: verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) self.outputs['Faces'].sv_set(faces_out)
def process(self): if not any(socket.is_linked for socket in self.outputs): return fields_s = self.inputs['Field'].sv_get() min_x_s = self.inputs['MinX'].sv_get() max_x_s = self.inputs['MaxX'].sv_get() min_y_s = self.inputs['MinY'].sv_get() max_y_s = self.inputs['MaxY'].sv_get() value_s = self.inputs['Value'].sv_get() z_value_s = self.inputs['Z'].sv_get() samples_s = self.inputs['Samples'].sv_get() matrix_s = self.inputs['Matrix'].sv_get(default=[Matrix()]) value_s = ensure_nesting_level(value_s, 2) z_value_s = ensure_nesting_level(z_value_s, 2) input_level = get_data_nesting_level(fields_s, data_types=(SvScalarField, )) nested_output = input_level > 1 fields_s = ensure_nesting_level(fields_s, 2, data_types=(SvScalarField, )) matrix_s = ensure_nesting_level(matrix_s, 2, data_types=(Matrix, )) parameters = zip_long_repeat(fields_s, matrix_s, min_x_s, max_x_s, min_y_s, max_y_s, z_value_s, value_s, samples_s) verts_out = [] edges_out = [] faces_out = [] for field_i, matrix_i, min_x_i, max_x_i, min_y_i, max_y_i, z_value_i, value_i, samples_i in parameters: new_verts = [] new_edges = [] new_faces = [] objects = zip_long_repeat(field_i, matrix_i, min_x_i, max_x_i, min_y_i, max_y_i, z_value_i, value_i, samples_i) for field, matrix, min_x, max_x, min_y, max_y, z_value, value, samples in objects: has_matrix = matrix != Matrix() x_range = np.linspace(min_x, max_x, num=samples) y_range = np.linspace(min_y, max_y, num=samples) z_range = np.array([z_value]) xs, ys, zs = np.meshgrid(x_range, y_range, z_range, indexing='ij') xs, ys, zs = xs.flatten(), ys.flatten(), zs.flatten() if has_matrix: xs, ys, zs = self.apply_matrix(matrix, xs, ys, zs) field_values = field.evaluate_grid(xs, ys, zs) field_values = field_values.reshape((samples, samples)) contours = measure.find_contours(field_values, level=value) x_size = (max_x - min_x) / samples y_size = (max_y - min_y) / samples value_verts, value_edges, value_faces = make_contours( samples, samples, min_x, x_size, min_y, y_size, z_value, contours, make_faces=self.make_faces, connect_bounds=self.connect_bounds) if has_matrix: new_verts = self.unapply_matrix(matrix, new_verts) if self.join: new_verts.extend(value_verts) new_edges.extend(value_edges) new_faces.extend(value_faces) else: new_verts.append(value_verts) new_edges.append(value_edges) new_faces.append(value_faces) if nested_output: verts_out.append(new_verts) edges_out.append(new_edges) faces_out.append(new_faces) else: verts_out.extend(new_verts) edges_out.extend(new_edges) faces_out.extend(new_faces) self.outputs['Vertices'].sv_set(verts_out) self.outputs['Edges'].sv_set(edges_out) self.outputs['Faces'].sv_set(faces_out)