def plot_box(corner1=(0.1, 0.1, 0.1), corner2=(0.5, 0.5, 0.5), color='red'): c1 = np.array(corner1) c2 = np.array(corner2) c = np.stack([c1, c2]) points = np.array([ [c[0, 0], c[0, 1], c[0, 2]], [c[1, 0], c[0, 1], c[0, 2]], [c[1, 0], c[1, 1], c[0, 2]], [c[0, 0], c[1, 1], c[0, 2]], [c[0, 0], c[0, 1], c[1, 2]], [c[1, 0], c[0, 1], c[1, 2]], [c[1, 0], c[1, 1], c[1, 2]], [c[0, 0], c[1, 1], c[1, 2]], ]) x = points[:, 0] y = points[:, 1] z = points[:, 2] lines = [ [0, 1], [1, 2], [2, 3], [3, 0], [4, 5], [5, 6], [6, 7], [7, 4], [0, 4], [1, 5], [2, 6], [3, 7], ] ipv.plot_trisurf(x, y, z, lines=lines, color=color)
def show_mesh(vertices, faces, color='green', width=500, height=500, colors=None): ipyvolume.figure(width=width, height=height) ipyvolume.view(0, 90) ipyvolume.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2], triangles=faces, color=color) x_min = vertices[:, 0].min() x_max = vertices[:, 0].max() y_min = vertices[:, 1].min() y_max = vertices[:, 1].max() z_min = vertices[:, 2].min() z_max = vertices[:, 2].max() xyz_max = max(x_max - x_min, y_max - y_min, z_max - z_min) ipyvolume.xlim(x_min, x_min + xyz_max) ipyvolume.ylim(y_min, y_min + xyz_max) ipyvolume.zlim(z_min, z_min + xyz_max) ipyvolume.show()
def data_points(buttons, drop): ipv.figure() ipv.scatter(all_pt[0], all_pt[1], all_pt[2], size=2, marker='sphere', color='red') for i in range(len(traces)): pairs = traces[i]['pairs'] ipv.plot_trisurf(all_pt[0], all_pt[1], all_pt[2], lines=pairs) if drop != None: if buttons == 'Analysis': x = pt55[in_names55[drop]][0] y = pt55[in_names55[drop]][1] z = pt55[in_names55[drop]][2] ipv.scatter(x, y, z, size=3, color='blue', marker='circle_2d') if buttons == 'Function data': x = pt58[in_names58[drop]][0] y = pt58[in_names58[drop]][1] z = pt58[in_names58[drop]][2] ipv.scatter(x, y, z, size=3, color='blue', marker='circle_2d') ipv.xlim(min(all_pt[0]) - 1, max(all_pt[0]) + 1) ipv.ylim(min(all_pt[1]) - 1, max(all_pt[1]) + 1) ipv.zlim(min(all_pt[2]) - 1, max(all_pt[2]) + 1) ipv.show()
def init_plane(self, z): "Plot plane for the first time. From ipw.plot_trisurf.__doc__" ipv.plot_trisurf( [0,0,1,1], [0,1,0,1], [z,z,z,z], triangles=[[0, 2, 3], [0, 3, 1]], )
def brain(draw=True, show=True, fiducial=True, flat=True, inflated=True, subject='S1', interval=1000, uv=True, color=None): import ipyvolume as ipv try: import cortex except: warnings.warn("it seems pycortex is not installed, which is needed for this example") raise xlist, ylist, zlist = [], [], [] polys_list = [] def add(pts, polys): xlist.append(pts[:,0]) ylist.append(pts[:,1]) zlist.append(pts[:,2]) polys_list.append(polys) def n(x): return (x - x.min()) / x.ptp() if fiducial or color is True: pts, polys = cortex.db.get_surf('S1', 'fiducial', merge=True) x, y, z = pts.T r = n(x) g = n(y) b = n(z) if color is True: color = np.array([r,g,b]).T.copy() else: color = None if fiducial: add(pts, polys) else: if color is False: color = None if inflated: add(*cortex.db.get_surf('S1', 'inflated', merge=True, nudge=True)) u = v = None if flat or uv: pts, polys = cortex.db.get_surf('S1', 'flat', merge=True, nudge=True) x, y, z = pts.T u = n(x) v = n(y) if flat: add(pts, polys) polys_list.sort(key=lambda x: len(x)) polys = polys_list[0] if draw: if color is None: mesh = ipv.plot_trisurf(xlist, ylist, zlist, polys, u=u, v=v) else: mesh = ipv.plot_trisurf(xlist, ylist, zlist, polys, color=color, u=u, v=v) if show: if len(x) > 1: ipv.animation_control(mesh, interval=interval) ipv.squarelim() ipv.show() return mesh else: return xlist, ylist, zlist, polys
def show_syntehtic_plant(vertices, faces, meta_data=None, size=0.5, color='green', width=500, height=500): ipyvolume.figure(width=width, height=height) ipyvolume.view(0, 90) ipyvolume.plot_trisurf(vertices[:, 0], vertices[:, 1], vertices[:, 2], triangles=faces, color=color) voxels_position = vertices if meta_data is not None: ranks = meta_data['leaf_order'] polylines = { n: list(map(numpy.array, list(zip(*meta_data['leaf_polylines'][i])))) for i, n in enumerate(ranks) } voxels = set() for leaf_order in polylines: x, y, z, r = polylines[leaf_order] polyline = numpy.array(list(zip(x, y, z))) * 10 - \ numpy.array([0, 0, 750]) plot_voxel(polyline, size=size, color="red") voxels = voxels.union(set(map(tuple, list(polyline)))) voxels = voxels.union(set(map(tuple, list(voxels_position)))) voxels_position = numpy.array(list(voxels), dtype=numpy.int) x_min = voxels_position[:, 0].min() x_max = voxels_position[:, 0].max() y_min = voxels_position[:, 1].min() y_max = voxels_position[:, 1].max() z_min = voxels_position[:, 2].min() z_max = voxels_position[:, 2].max() xyz_max = max(x_max - x_min, y_max - y_min, z_max - z_min) ipyvolume.xlim(x_min, x_min + xyz_max) ipyvolume.ylim(y_min, y_min + xyz_max) ipyvolume.zlim(z_min, z_min + xyz_max) ipyvolume.show()
def plot_line(p1=(0, 0, 0), p2=(1, 1, 1), color='red'): p1 = np.array(p1) p2 = np.array(p2) points = np.stack([p1, p2]) print(points.shape) x = points[:, 0] y = points[:, 1] z = points[:, 2] # draw lines from the first vertex to second lines = [[0, 1]] ipv.plot_trisurf(x, y, z, lines=lines, color=color)
def _plot_hemi_mesh(self, vertices, faces, color='grey'): u"""Plot triangular format Freesurfer surface of the brain hemispheres. Parameters ---------- vertices : numpy.array Array of vertex (x, y, z) coordinates, of size number_of_vertices x 3. faces : numpy.array Array defining mesh triangles, of size number_of_faces x 3. color : str | numpy.array, optional Color for each point/vertex/symbol, can be string format, examples for red:’red’, ‘#f00’, ‘#ff0000’ or ‘rgb(1,0,0), or rgb array of shape (N, 3). Default value is 'grey'. Returns ------- mesh_widget : ipyvolume.Mesh Ipyvolume object presenting the built mesh. """ x = vertices[:, 0] y = vertices[:, 1] z = vertices[:, 2] mesh = ipv.plot_trisurf(x, y, z, triangles=faces, color=color) return mesh
def plot_ipv_mesh(elephant_mesh_sub, color=[1., 0., 0., 0.2]): mesh4 = ipv.plot_trisurf(elephant_mesh_sub.vertices[:, 0], elephant_mesh_sub.vertices[:, 1], elephant_mesh_sub.vertices[:, 2], triangles=elephant_mesh_sub.faces) mesh4.color = color mesh4.material.transparent = True
def test_ipyvolume(): import ipyvolume as ipv s = 1 / 2**0.5 # 4 vertices for the tetrahedron x = np.array([1., -1, 0, 0]) y = np.array([0, 0, 1., -1]) z = np.array([-s, -s, s, s]) # and 4 surfaces (triangles), where the number refer to the vertex index triangles = [(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 3, 2)] ipv.figure() # draw the tetrahedron mesh ipv.plot_trisurf(x, y, z, triangles=triangles, color='orange') # mark the vertices ipv.scatter(x, y, z, marker='sphere', color='blue') # set limits and show ipv.xyzlim(-2, 2) ipv.show()
def SaveMeshAsHTML(cell_dir, stl_id, mesh_dir='./'): in_mesh = GetMesh(cell_dir, stl_id) IX, IY, IZ = 2, 1, 0 x, y, z = in_mesh.vertices[:,IX].astype(float), \ in_mesh.vertices[:,IY].astype(float), \ in_mesh.vertices[:,IZ].astype(float) triangles = in_mesh.faces ipv.figure() mesh = ipv.plot_trisurf(x, y, z, triangles=triangles, color='skyblue') ipv.pylab.style.axes_off() ipv.pylab.style.box_off() ipv.save(os.path.join(mesh_dir, 'mesh' + str(stl_id) + '.html'))
def _add_ray_history(history, config, lost=None): if lost is False: color = [1.0, 0.0, 0.0, 0.1] elif lost is True: color = [0.0, 0.0, 1.0, 0.1] else: color = [0.0, 0.0, 0.0, 0.1] num_elem = len(history) key_list = list(history.keys()) for ii in range(num_elem - 1): # All rays leaving this optic element. mask = history[key_list[ii]]['mask'] # This is a temporary solution to filter lost rays for # which no intersection at the next optic was calculated. # # This is not a good solution overall since it is possible # to imagine a case where we would want to retain rays at # the origin. mask &= history[key_list[ii + 1]]['origin'][:, 0] != 0.0 num_mask = np.sum(mask) if num_mask == 0: continue x0 = history[key_list[ii]]['origin'][mask, 0] y0 = history[key_list[ii]]['origin'][mask, 1] z0 = history[key_list[ii]]['origin'][mask, 2] x1 = history[key_list[ii + 1]]['origin'][mask, 0] y1 = history[key_list[ii + 1]]['origin'][mask, 1] z1 = history[key_list[ii + 1]]['origin'][mask, 2] x = np.concatenate((x0, x1)) y = np.concatenate((y0, y1)) z = np.concatenate((z0, z1)) lines = np.zeros((num_mask, 2), dtype=int) lines[:, 0] = np.arange(0, num_mask) lines[:, 1] = np.arange(num_mask, num_mask * 2) obj = ipv.plot_trisurf(x, y, z, lines=lines, color=color) obj.line_material.transparent = True obj.line_material.linewidth = 10.0
def ipv_draw_pose_3d(ipv, R, t, color='blue', camera_scale=0.15, draw_axis_indicate=True): # camera obj cam_points = np.array([[0, 0, 0], [-1, -1, 1.5], [1, -1, 1.5], [1, 1, 1.5], [-1, 1, 1.5]]) # axis indicators axis_points = np.array([[-0.5, 1, 1.5], [0.5, 1, 1.5], [0, 1.2, 1.5], [1, -0.5, 1.5], [1, 0.5, 1.5], [1.2, 0, 1.5]]) # transform camera objs... cam_points = (camera_scale * cam_points - t).dot(R) axis_points = (camera_scale * axis_points - t).dot(R) x = cam_points[:, 0] y = cam_points[:, 1] z = cam_points[:, 2] cam_wire_draw_order = np.asarray([ (0, 1, 4, 0), # left (0, 3, 2, 0), # right (0, 4, 3, 0), # top (0, 2, 1, 0) ]) # bottom x = np.take(x, cam_wire_draw_order) y = np.take(y, cam_wire_draw_order) z = np.take(z, cam_wire_draw_order) axis_triangles = np.asarray([ ( 3, 5, 4, ), # x-axis indicator (0, 1, 2) ]) # y-axis indicator mesh = ipv.plot_wireframe(x, y, z, color=color, wrapx=True) mesh2 = ipv.plot_trisurf(x=axis_points[:, 0], y=axis_points[:, 1], z=axis_points[:, 2], triangles=axis_triangles, color=color)
def draw_compas_mesh(mesh, color='white', size=1.0): """ Renders a compas mesh on a 3D canvas with ipyvolume. Parameters ---------- mesh : :class: compas.datastructures.Mesh the mesh to be shown in 3D Returns ------- an instance of ipyvolume.widgets.Mesh """ import ipyvolume as ipv # extract lists of vertices and faces vertices, faces = mesh.to_vertices_and_faces() # extract x, y and z values into separate lists x = [v[0] for v in vertices] y = [v[1] for v in vertices] z = [v[2] for v in vertices] # triangulate n-gons triangles_only = [] for f in faces: if len(f) == 3: triangles_only.append(f) else: for i in range(len(f) - 2): triangles_only.append([f[0], f[i+1], f[i+2]]) # create the ipyvolume plot ipv.figure(width=800, height=450) viewermesh = ipv.plot_trisurf(x, y, z, triangles_only, color=color) ipv.xyzlim(size) ipv.style.use('minimal') ipv.show() return viewermesh
def _plot_hemi_overlay(self, vertices, faces, color): u"""Plot overlay of the brain hemispheres with activation data. Parameters ---------- vertices : numpy.array Array of vertex (x, y, z) coordinates, of size number_of_vertices x 3. faces : numpy.array Array defining mesh triangles, of size number_of_faces x 3. color : str | numpy.array, optional Color for each point/vertex/symbol, can be string format, examples for red:’red’, ‘#f00’, ‘#ff0000’ or ‘rgb(1,0,0), or rgb array of shape (N, 3). Default value is 'grey'. Returns ------- mesh_overlay : ipyvolume.Mesh Ipyvolume object presenting the built mesh. """ x = vertices[:, 0] y = vertices[:, 1] z = vertices[:, 2] mesh_overlay = ipv.plot_trisurf(x, y, z, triangles=faces, color=color) # Tranparency and alpha blending for the new material of the mesh mat = ShaderMaterial() mat.alphaTest = 0.1 mat.blending = BlendingMode.CustomBlending mat.blendDst = BlendFactors.OneMinusSrcAlphaFactor mat.blendEquation = Equations.AddEquation mat.blendSrc = BlendFactors.SrcAlphaFactor mat.transparent = True mat.side = Side.DoubleSide mesh_overlay.material = mat return mesh_overlay
def add_surf(obj): w = obj.param['xsize'] / 2.0 h = obj.param['ysize'] / 2.0 d = obj.param['zsize'] / 2.0 points = np.zeros((8, 3)) points[0, :] = [w, h, d] points[1, :] = [w, -h, d] points[2, :] = [-w, h, d] points[3, :] = [-w, -h, d] points[4, :] = [w, h, -d] points[5, :] = [w, -h, -d] points[6, :] = [-w, h, -d] points[7, :] = [-w, -h, -d] points_ext = obj.point_to_external(points) x = points_ext[:, 0] y = points_ext[:, 1] z = points_ext[:, 2] # I am sure there is a way to automate this using a meshgrid, # but at the moment this is faster. if d > 0: triangles = ((0, 3, 1), (0, 3, 2), (4, 7, 5), (4, 7, 6), (0, 6, 2), (0, 6, 4), (0, 5, 1), (0, 5, 4), (3, 6, 2), (3, 6, 7), (3, 5, 1), (3, 5, 7)) else: triangles = ((0, 3, 1), (0, 3, 2)) ipv_obj = ipv.plot_trisurf(x, y, z, triangles=triangles, color=[1.0, 1.0, 0.0, 0.2]) ipv_obj.material.transparent = True
def graph_skeleton_and_mesh(main_mesh_verts=[], main_mesh_faces=[], unique_skeleton_verts_final=[], edges_final=[], edge_coordinates=[], other_meshes=[], other_meshes_colors=[], main_mesh_face_coloring=[], buffer=0, axis_box_off=True, html_path=""): """ Graph the final result: """ ipv.figure(figsize=(15, 15)) if (len(unique_skeleton_verts_final) > 0 and len(edges_final) > 0) or (len(edge_coordinates) > 0): if (len(edge_coordinates) > 0): unique_skeleton_verts_final, edges_final = convert_skeleton_to_nodes_edges( edge_coordinates) mesh2 = ipv.plot_trisurf(unique_skeleton_verts_final[:, 0], unique_skeleton_verts_final[:, 1], unique_skeleton_verts_final[:, 2], lines=edges_final, color='blue') mesh2.color = [0, 0., 1, 1] mesh2.material.transparent = True if len(main_mesh_verts) > 0 and len(main_mesh_faces) > 0: main_mesh = trimesh.Trimesh(vertices=main_mesh_verts, faces=main_mesh_faces) mesh3 = ipv.plot_trisurf(main_mesh.vertices[:, 0], main_mesh.vertices[:, 1], main_mesh.vertices[:, 2], triangles=main_mesh.faces) mesh3.color = [0., 1., 0., 0.2] mesh3.material.transparent = True volume_max = np.max(main_mesh.vertices, axis=0) volume_min = np.min(main_mesh.vertices, axis=0) ranges = volume_max - volume_min index = [0, 1, 2] max_index = np.argmax(ranges) min_limits = [0, 0, 0] max_limits = [0, 0, 0] for i in index: if i == max_index: min_limits[i] = volume_min[i] - buffer max_limits[i] = volume_max[i] + buffer continue else: difference = ranges[max_index] - ranges[i] min_limits[i] = volume_min[i] - difference / 2 - buffer max_limits[i] = volume_max[i] + difference / 2 + buffer #ipv.xyzlim(-2, 2) ipv.xlim(min_limits[0], max_limits[0]) ipv.ylim(min_limits[1], max_limits[1]) ipv.zlim(min_limits[2], max_limits[2]) for curr_mesh, curr_color in zip(other_meshes, other_meshes_colors): plot_ipv_mesh(curr_mesh, color=curr_color) #will go through and color the faces of the main mesh if any sent for face_array, face_color in main_mesh_face_coloring: curr_mesh = main_mesh.submesh([face_array], append=True) plot_ipv_mesh(curr_mesh, face_color) ipv.style.set_style_light() if axis_box_off: ipv.style.axes_off() ipv.style.box_off() else: ipv.style.axes_on() ipv.style.box_on() ipv.show() if html_path != "": print(f"printing to html : {html_path}") ipv.pylab.save(html_path)
def show_mesh(verts, triangles, face_colors=None, face_labels=None, face_cmap=cm.RdBu, face_reorder_colors=True, vertex_colors=None, vertex_labels=None, vertex_cmap=cm.RdBu, vertex_reorder_colors=True, vertex_normals=None, point_size_value=0.5, vector_size_value=0.5, width=800, height=600, axeslim='auto', aspect_ratio_preserve=True, verbose=0): """ vertex_normals - normals of vertices. """ if vertex_normals is not None: assert len(verts) == len( vertex_normals ), "Length incorrect. These are not normals of points, may be." x = verts[:, 0] y = verts[:, 1] z = verts[:, 2] ipv.figure(width=width, height=height) set_axes_lims(verts, axeslim=axeslim, aspect_ratio_preserve=aspect_ratio_preserve) # faces if face_labels is not None: face_color_dict = calc_colors_dict_by_labels( face_labels, cmap=face_cmap, reorder_colors=face_reorder_colors) for label in face_color_dict.keys(): triangles_set = triangles[face_labels == label] color = face_color_dict[label] _ = ipv.plot_trisurf(x, y, z, triangles=triangles_set, color=color) else: if face_colors is None: face_colors = '#f0f0f0' _ = ipv.plot_trisurf(x, y, z, triangles=triangles, color=face_colors) # vertices is_multilabels = isinstance(vertex_labels, (list, tuple)) if is_multilabels: vertex_colors_by_labels = [] for vl in vertex_labels: vertex_colors_by_labels.append( calc_colors_by_labels(vl, cmap=vertex_cmap, reorder_colors=vertex_reorder_colors)) else: vertex_colors_by_labels = calc_colors_by_labels( vertex_labels, cmap=vertex_cmap, reorder_colors=vertex_reorder_colors) vertex_colors_rgb = vertex_colors if vertex_colors_by_labels is None and vertex_colors_rgb is None: vertex_current_colors = 'red' elif vertex_colors_rgb is not None: vertex_current_colors = vertex_colors_rgb elif is_multilabels: vertex_current_colors = vertex_colors_by_labels[0] else: vertex_current_colors = vertex_colors_by_labels sc = ipv.scatter(x, y, z, size=point_size_value, marker='sphere', color=vertex_current_colors) point_size = FloatSlider(min=0, max=2, step=0.1, description='Vertex size') jslink((sc, 'size'), (point_size, 'value')) w_switch_vertex_colors = get_color_switch_widget(vertex_colors_by_labels, vertex_colors_rgb, sc) widget_list = [ipv.gcc(), point_size] # vertex normals if vertex_normals is not None: u = vertex_normals[:, 0] v = vertex_normals[:, 1] w = vertex_normals[:, 2] quiver = ipv.quiver(x, y, z, u, v, w, size=vector_size_value, marker="arrow", color='green') vector_size = FloatSlider(min=0, max=5, step=0.1, description='Nomals size') jslink((quiver, 'size'), (vector_size, 'value')) widget_list.append(vector_size) if w_switch_vertex_colors is not None: widget_list.append(w_switch_vertex_colors) return display_widgets(widget_list)
def plot_brain(brain, surface='dots', nodes=True, node_colors=False, node_groups=None, surface_color=None, node_color='red', network=None, dot_size=0.1, dot_color='gray', min_fibers=10, max_fibers=500, lowest_cmap_color=0.2, highest_cmap_color=0.7, cmap='rocket', background='light'): import ipyvolume as ipv if surface_color is None: if surface == 'dots': surface_color = 'gray' elif surface == 'full': surface_color = 'orange' if isinstance(node_colors, bool) and node_colors: node_colors = ['red', 'green', 'blue', 'violet', 'yellow'] if node_colors and node_groups is None: node_groups = brain['nodes']['label'] fig = ipv.figure() # plot surface x, y, z = [brain['surface'][key] for key in list('xyz')] if surface == 'dots': ipv.scatter(x, y, z, marker='box', color=dot_color, size=dot_size) elif surface == 'full': ipv.plot_trisurf(x, y, z, triangles=brain['surface']['tri'], color=surface_color) # plot nodes if nodes: xyz = brain['nodes']['xyz'] if node_colors: for label_idx, color in zip(np.unique(node_groups), node_colors): mask = node_groups == label_idx ipv.scatter(xyz[mask, 0], xyz[mask, 1], xyz[mask, 2], marker='sphere', color=color, size=1.5) else: ipv.scatter(xyz[:, 0], xyz[:, 1], xyz[:, 2], marker='sphere', color=node_color, size=1.5) # plot connections if network is not None: x, y, z = brain['nodes']['xyz'].T scaling = highest_cmap_color - lowest_cmap_color min_fibers_log = np.log(min_fibers) max_fibers_log = np.log(max_fibers) if hasattr(plt.cm, cmap): cmp = getattr(plt.cm, cmap) else: import seaborn as sns cmp = getattr(sns.cm, cmap) with fig.hold_sync(): for ii in range(89): for jj in range(ii, 90): if network[ii, jj] > min_fibers: float_color = (min( np.log((network[ii, jj] - min_fibers)) / (max_fibers_log - min_fibers_log), 1.) * scaling + lowest_cmap_color) line_color = cmp(float_color) ipv.plot(x[[ii, jj]], y[[ii, jj]], z[[ii, jj]], color=line_color[:3]) ipv.squarelim() ipv.style.use([background, 'minimal']) ipv.show() return fig
def add_optics(config): for key_opt in config['optics']: config_opt = config['optics'][key_opt] config_opt = xicsrt_config.config_to_numpy(config_opt) if True: w = config_opt['width'] / 2.0 h = config_opt['height'] / 2.0 cx = config_opt['xaxis'] cy = np.cross(config_opt['xaxis'], config_opt['zaxis']) point0 = w * cx + h * cy + config_opt['origin'] point1 = h * cy + config_opt['origin'] point2 = -1 * w * cx + h * cy + config_opt['origin'] point3 = w * cx + config_opt['origin'] point4 = config_opt['origin'] point5 = -1 * w * cx + config_opt['origin'] point6 = w * cx - h * cy + config_opt['origin'] point7 = -1 * h * cy + config_opt['origin'] point8 = -1 * w * cx - h * cy + config_opt['origin'] points = np.array([ point0, point1, point2, point3, point4, point5, point6, point7, point8 ]) x = points[:, 0] y = points[:, 1] z = points[:, 2] # I am sure there is a way to automate this using a meshgrid, # but at the moment this is faster. triangles = ((4, 0, 2), (4, 2, 8), (4, 6, 8), (4, 6, 0)) obj = ipv.plot_trisurf(x, y, z, triangles=triangles, color=[0.5, 0.5, 0.5, 0.5]) obj.material.transparent = True if 'crystal' in str.lower(key_opt) and 'radius' in config_opt: # Initialize the configuration. # This merges the user config that we created # with the default config config = xicsrt_config.get_config(config) # The easiest way to do coordinate transformations is # to use the raytrace objects, since they already have # everything built in. Of course we could do this # by just using some simple matrix multiplications, # but this way we can use existing code. # # We could just instantiate the objects directly as needed, # but since a dispatcher is already available in xicsrt that # does this for us, we might as well use it. This is copied # from xicsrt_raytrace.raytrace_single. name = 'crystal' section = 'optics' optics = Dispatcher(config, section) optics.instantiate() optics.setup() optics.initialize() # Get the crystal object from the dispatcher. optic_obj = optics.get_object(name) crystal_center_ext = config_opt[ 'origin'] + config_opt['zaxis'] * config_opt['radius'] crystal_center_loc = optic_obj.point_to_local(crystal_center_ext) x = np.array([crystal_center_ext[0]]) y = np.array([crystal_center_ext[1]]) z = np.array([crystal_center_ext[2]]) ipv.scatter(x, y, z, color='black', marker="sphere") # Plot the crystal circle. num = 1000 crystal_radius = config_opt['radius'] coord_loc = np.zeros((num, 3)) coord_loc[:, 0] = np.sin(np.linspace( 0.0, np.pi * 2, num)) * config_opt['radius'] + crystal_center_loc[0] coord_loc[:, 1] = crystal_center_loc[1] coord_loc[:, 2] = np.cos(np.linspace( 0.0, np.pi * 2, num)) * config_opt['radius'] + crystal_center_loc[2] coord_ext = optic_obj.point_to_external(coord_loc) x = coord_ext[:, 0] y = coord_ext[:, 1] z = coord_ext[:, 2] lines = np.zeros((num, 2), dtype=int) lines[:, 0] = np.arange(num) lines[:, 1] = np.roll(lines[:, 0], 1) obj = ipv.plot_trisurf(x, y, z, lines=lines, color=[0.0, 0.0, 0.0, 0.5]) rowland_center_ext = config_opt[ 'origin'] + config_opt['zaxis'] * config_opt['radius'] / 2 rowland_center_loc = optic_obj.point_to_local(rowland_center_ext) rowland_radius = crystal_radius / 2 coord_loc = np.zeros((num, 3)) coord_loc[:, 0] = np.sin(np.linspace( 0.0, np.pi * 2, num)) * rowland_radius + rowland_center_loc[0] coord_loc[:, 1] = rowland_center_loc[1] coord_loc[:, 2] = np.cos(np.linspace( 0.0, np.pi * 2, num)) * rowland_radius + rowland_center_loc[2] coord_ext = optic_obj.point_to_external(coord_loc) x = coord_ext[:, 0] y = coord_ext[:, 1] z = coord_ext[:, 2] lines = np.zeros((num, 2), dtype=int) lines[:, 0] = np.arange(num) lines[:, 1] = np.roll(lines[:, 0], 1) obj = ipv.plot_trisurf(x, y, z, lines=lines, color=[0.0, 0.0, 0.0, 0.5])