def test_perspective_lens(self): sc = Scene() cam = sc.add_camera(self.ds, lens_type='perspective') cam.position = self.ds.arr(np.array([1.0, 1.0, 1.0]), 'code_length') vol = VolumeSource(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.render() sc.save('test_perspective_%s.png' % self.field[1], sigma_clip=6.0)
def test_points_vr(self): ds = fake_random_ds(64) dd = ds.sphere(ds.domain_center, 0.45 * ds.domain_width[0]) ds.field_info[ds.field_list[0]].take_log = False sc = Scene() cam = sc.add_camera(ds) cam.resolution = (512, 512) vr = VolumeSource(dd, field=ds.field_list[0]) vr.transfer_function.clear() vr.transfer_function.grey_opacity = False vr.transfer_function.map_to_colormap(0.0, 1.0, scale=10., colormap="Reds") sc.add_source(vr) cam.set_width(1.8 * ds.domain_width) cam.lens.setup_box_properties(cam) # DRAW SOME POINTS npoints = 1000 vertices = np.random.random([npoints, 3]) colors = np.random.random([npoints, 4]) colors[:, 3] = 0.10 points_source = PointSource(vertices, colors=colors) sc.add_source(points_source) im = sc.render() im.write_png("points.png") return im
def test_composite_vr(self): ds = fake_random_ds(64) dd = ds.sphere(ds.domain_center, 0.45 * ds.domain_width[0]) ds.field_info[ds.field_list[0]].take_log = False sc = Scene() cam = sc.add_camera(ds) cam.resolution = (512, 512) vr = VolumeSource(dd, field=ds.field_list[0]) vr.transfer_function.clear() vr.transfer_function.grey_opacity = True vr.transfer_function.map_to_colormap(0.0, 1.0, scale=10.0, colormap="Reds") sc.add_source(vr) cam.set_width(1.8 * ds.domain_width) cam.lens.setup_box_properties(cam) # Create Arbitrary Z-buffer empty = cam.lens.new_image(cam) z = np.empty(empty.shape[:2], dtype="float64") # Let's put a blue plane right through the center z[:] = cam.width[2] / 2.0 empty[:, :, 2] = 1.0 # Set blue to 1's empty[:, :, 3] = 1.0 # Set alpha to 1's zbuffer = ZBuffer(empty, z) zsource = OpaqueSource() zsource.set_zbuffer(zbuffer) sc.add_source(zsource) im = sc.render() im.write_png("composite.png")
def test_spherical_lens(self): sc = Scene() cam = sc.add_camera(self.ds, lens_type='spherical') cam.resolution = [512, 256] cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), 'code_length') vol = VolumeSource(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.render() sc.save('test_spherical_%s.png' % self.field[1], sigma_clip=6.0)
def test_plane_lens(self): dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10) sc = Scene() cam = sc.add_camera(dd, lens_type='plane-parallel') cam.set_width(self.ds.domain_width * 1e-2) v, c = self.ds.find_max('density') vol = VolumeSource(dd, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.render() sc.save('test_plane_%s.png' % self.field[1], sigma_clip=6.0)
def test_fisheye_lens(self): dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10) sc = Scene() cam = sc.add_camera(dd, lens_type='fisheye') cam.lens.fov = 360.0 cam.set_width(self.ds.domain_width) v, c = self.ds.find_max('density') cam.set_position(c - 0.0005 * self.ds.domain_width) vol = VolumeSource(dd, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.render() sc.save('test_fisheye_%s.png' % self.field[1], sigma_clip=6.0)
def test_perspective_lens(self): sc = Scene() cam = sc.add_camera(self.ds, lens_type="perspective") cam.position = self.ds.arr(np.array([1.0, 1.0, 1.0]), "code_length") vol = create_volume_source(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save(f"test_perspective_{self.field[1]}.png", sigma_clip=6.0)
def test_spherical_lens(self): sc = Scene() cam = sc.add_camera(self.ds, lens_type="spherical") cam.resolution = [256, 128] cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), "code_length") vol = VolumeSource(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save("test_spherical_%s.png" % self.field[1], sigma_clip=6.0)
def test_stereoperspective_lens(self): sc = Scene() cam = sc.add_camera(self.ds, lens_type="stereo-perspective") cam.resolution = [1024, 512] cam.position = self.ds.arr(np.array([0.7, 0.7, 0.7]), "code_length") vol = VolumeSource(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save("test_stereoperspective_%s.png" % self.field[1], sigma_clip=6.0)
def test_plane_lens(self): dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10) sc = Scene() cam = sc.add_camera(dd, lens_type="plane-parallel") cam.set_width(self.ds.domain_width * 1e-2) v, c = self.ds.find_max("density") vol = create_volume_source(dd, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save(f"test_plane_{self.field[1]}.png", sigma_clip=6.0)
def test_stereospherical_lens(self): w = (self.ds.domain_width).in_units("code_length") w = self.ds.arr(w, "code_length") sc = Scene() cam = sc.add_camera(self.ds, lens_type="stereo-spherical") cam.resolution = [256, 256] cam.position = self.ds.arr(np.array([0.6, 0.5, 0.5]), "code_length") vol = create_volume_source(self.ds, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save(f"test_stereospherical_{self.field[1]}.png", sigma_clip=6.0)
def test_fisheye_lens(self): dd = self.ds.sphere(self.ds.domain_center, self.ds.domain_width[0] / 10) sc = Scene() cam = sc.add_camera(dd, lens_type="fisheye") cam.lens.fov = 360.0 cam.set_width(self.ds.domain_width) v, c = self.ds.find_max("density") cam.set_position(c - 0.0005 * self.ds.domain_width) vol = create_volume_source(dd, field=self.field) tf = vol.transfer_function tf.grey_opacity = True sc.add_source(vol) sc.save(f"test_fisheye_{self.field[1]}.png", sigma_clip=6.0)
def test_bounding_volume_hierarchy(): ds = yt.load(fn) vertices = ds.index.meshes[0].connectivity_coords indices = ds.index.meshes[0].connectivity_indices - 1 ad = ds.all_data() field_data = ad["connect1", "diffused"] bvh = BVH(vertices, indices, field_data) sc = Scene() cam = Camera(sc) cam.set_position(np.array([8.0, 8.0, 8.0])) cam.focus = np.array([0.0, 0.0, 0.0]) origins, direction = get_rays(cam) image = np.empty(800 * 800, np.float64) test_ray_trace(image, origins, direction, bvh) image = image.reshape((800, 800)) return image
def composite_mesh_render(engine): ytcfg["yt", "ray_tracing_engine"] = engine ds = data_dir_load(hex8) sc = Scene() cam = sc.add_camera(ds) cam.focus = ds.arr([0.0, 0.0, 0.0], 'code_length') cam.set_position(ds.arr([-3.0, 3.0, -3.0], 'code_length'), ds.arr([0.0, -1.0, 0.0], 'dimensionless')) cam.set_width = ds.arr([8.0, 8.0, 8.0], 'code_length') cam.resolution = (800, 800) ms1 = MeshSource(ds, ('connect1', 'diffused')) ms2 = MeshSource(ds, ('connect2', 'diffused')) sc.add_source(ms1) sc.add_source(ms2) im = sc.render() return compare(ds, im, "%s_composite_mesh_render" % engine)
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) field = ('boxlib', 'radial_velocity') ds._get_field_info(field).take_log = False sc = Scene() # add a volume: select a sphere center = (0, 0, 0) R = (5.e8, 'cm') dd = ds.sphere(center, R) vol = VolumeSource(dd, field=field) vol.use_ghost_zones = True sc.add_source(vol) # transfer function vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6] sigma = 3.e5 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" for v in vals: tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1280, 720) cam.position = 1.5*ds.arr(np.array([5.e8, 5.e8, 5.e8]), 'cm') # look toward the center -- we are dealing with an octant center = ds.domain_left_edge normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) #sc.annotate_axes() #sc.annotate_domain(ds) sc.render() sc.save("subchandra_test.png", sigma_clip=6.0) sc.save_annotated("subchandra_test_annotated.png", text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d), dict(horizontalalignment="left")], [(0.5,0.95), "Maestro simulation of He convection on a white dwarf", dict(color="y", fontsize="24", horizontalalignment="center")]])
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) cm = "coolwarm" field = ('boxlib', 'density') ds._get_field_info(field).take_log = True sc = Scene() # add a volume: select a sphere vol = VolumeSource(ds, field=field) sc.add_source(vol) # transfer function vals = [-1, 0, 1, 2, 4, 5, 6, 7] #vals = [0.1, 1.0, 10, 100., 1.e4, 1.e5, 1.e6, 1.e7] sigma = 0.1 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" cm = "spectral" for v in vals: if v < 4: alpha = 0.1 else: alpha = 0.5 tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha) sc.get_source(0).transfer_function = tf cam = Camera(ds, lens_type="perspective") cam.resolution = (1280, 720) cam.position = 1.5*ds.arr(np.array([0.0, 5.e9, 5.e9]), 'cm') # look toward the center -- we are dealing with an octant center = 0.5*(ds.domain_left_edge + ds.domain_right_edge) normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) sc.camera = cam #sc.annotate_axes() #sc.annotate_domain(ds) pid = plotfile.split("plt")[1] sc.render() sc.save("wdmerger_{}.png".format(pid), sigma_clip=6.0) sc.save_annotated("wdmerger_annotated_{}.png".format(pid), text_annotate=[[(0.05, 0.05), "t = {:.3f}".format(float(ds.current_time.d)), dict(horizontalalignment="left")], [(0.5,0.95), "Castro simulation of merging white dwarfs", dict(color="y", fontsize="24", horizontalalignment="center")]])
def test_scene_and_camera_attributes(): ds = fake_random_ds(64, length_unit=2, bbox=np.array([[-1, 1], [-1, 1], [-1, 1]])) sc = Scene() cam = sc.add_camera(ds) # test that initial values are correct in code units assert_equal(cam.width, ds.arr([3, 3, 3], "code_length")) assert_equal(cam.position, ds.arr([1, 1, 1], "code_length")) assert_equal(cam.focus, ds.arr([0, 0, 0], "code_length")) # test setting the attributes in various ways attribute_values = [ (1, ds.arr([2, 2, 2], "code_length"),), ([1], ds.arr([2, 2, 2], "code_length"),), ([1, 2], RuntimeError,), ([1, 1, 1], ds.arr([2, 2, 2], "code_length"),), ((1, "code_length"), ds.arr([1, 1, 1], "code_length"),), (((1, "code_length"), (1, "code_length")), RuntimeError,), (((1, "cm"), (2, "cm"), (3, "cm")), ds.arr([0.5, 1, 1.5], "code_length"),), (2 * u.cm, ds.arr([1, 1, 1], "code_length"),), (ds.arr(2, "cm"), ds.arr([1, 1, 1], "code_length"),), ([2 * u.cm], ds.arr([1, 1, 1], "code_length"),), ([1, 2, 3] * u.cm, ds.arr([0.5, 1, 1.5], "code_length"),), ([1, 2] * u.cm, RuntimeError,), ([u.cm * w for w in [1, 2, 3]], ds.arr([0.5, 1, 1.5], "code_length"),), ] # define default values to avoid accidentally setting focus = position default_values = { "focus": [0, 0, 0], "position": [4, 4, 4], "width": [1, 1, 1], } attribute_list = list(default_values.keys()) for attribute in attribute_list: for other_attribute in [a for a in attribute_list if a != attribute]: setattr(cam, other_attribute, default_values[other_attribute]) for attribute_value, expected_result in attribute_values: try: # test properties setattr(cam, attribute, attribute_value) assert_almost_equal(getattr(cam, attribute), expected_result) except RuntimeError: assert expected_result is RuntimeError try: # test setters/getters getattr(cam, "set_%s" % attribute)(attribute_value) assert_almost_equal( getattr(cam, "get_%s" % attribute)(), expected_result ) except RuntimeError: assert expected_result is RuntimeError resolution_values = ( (512, (512, 512),), ((512, 512), (512, 512),), ((256, 512), (256, 512),), ((256, 256, 256), RuntimeError), ) for resolution_value, expected_result in resolution_values: try: # test properties cam.resolution = resolution_value assert_equal(cam.resolution, expected_result) except RuntimeError: assert expected_result is RuntimeError try: # test setters/getters cam.set_resolution(resolution_value) assert_equal(cam.get_resolution(), expected_result) except RuntimeError: assert expected_result is RuntimeError for lens_type in valid_lens_types: cam.set_lens(lens_type) # See issue #1287 cam.focus = [0, 0, 0] cam_pos = [1, 0, 0] north_vector = [0, 1, 0] cam.set_position(cam_pos, north_vector) cam_pos = [0, 1, 0] north_vector = [0, 0, 1] cam.set_position(cam_pos, north_vector)
import yt from yt.visualization.volume_rendering.api import Scene, VolumeSource import numpy as np field = ("gas", "density") # normal_vector points from camera to the center of tbe final projection. # Now we look at the positive x direction. normal_vector = [1., 0., 0.] # north_vector defines the "top" direction of the projection, which is # positive z direction here. north_vector = [0., 0., 1.] # Follow the simple_volume_rendering cookbook for the first part of this. ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030") sc = Scene() vol = VolumeSource(ds, field=field) tf = vol.transfer_function tf.grey_opacity = True # Plane-parallel lens cam = sc.add_camera(ds, lens_type='plane-parallel') # Set the resolution of tbe final projection. cam.resolution = [250, 250] # Set the location of the camera to be (x=0.2, y=0.5, z=0.5) # For plane-parallel lens, the location info along the normal_vector (here # is x=0.2) is ignored. cam.position = ds.arr(np.array([0.2, 0.5, 0.5]), 'code_length') # Set the orientation of the camera. cam.switch_orientation(normal_vector=normal_vector, north_vector=north_vector) # Set the width of the camera, where width[0] and width[1] specify the length and
def doit(plotfile, fname): ds = yt.load(plotfile) cm = "gist_rainbow" if fname == "vz": field = ('gas', 'velocity_z') use_log = False vals = [-1.e7, -5.e6, 5.e6, 1.e7] sigma = 5.e5 fmt = None cm = "coolwarm" elif fname == "magvel": field = ('gas', 'velocity_magnitude') use_log = True vals = [1.e5, 3.16e5, 1.e6, 3.16e6, 1.e7] sigma = 0.1 elif fname == "enucdot": field = ('boxlib', 'enucdot') use_log = True vals = [1.e16, 3.162e16, 1.e17, 3.162e17, 1.e18] vals = list(10.0**numpy.array([16.5, 17.0, 17.5, 18.0, 18.5])) sigma = 0.05 fmt = "%.3g" # this is hackish, but there seems to be no better way to set whether # you are rendering logs ds._get_field_info(field).take_log = use_log # hack periodicity ds.periodicity = (True, True, True) mi = min(vals) ma = max(vals) if use_log: mi, ma = np.log10(mi), np.log10(ma) print mi, ma # setup the scene and camera sc = Scene() cam = Camera(ds, lens_type="perspective") # Set up the camera parameters: center, looking direction, width, resolution center = (ds.domain_right_edge + ds.domain_left_edge)/2.0 xmax, ymax, zmax = ds.domain_right_edge # this shows something face on c = np.array([-8.0*xmax, center[1], center[2]]) # the normal vector should be pointing back through the center L = center.d - c L = L/np.sqrt((L**2).sum()) north_vector=[0.0,0.0,1.0] cam.position = ds.arr(c) cam.switch_orientation(normal_vector=L, north_vector=north_vector) cam.set_width(ds.domain_width*4) cam.resolution = (720,720) # create the volume source vol = VolumeSource(ds, field=field) # Instantiate the ColorTransferfunction. tf = vol.transfer_function tf = ColorTransferFunction((mi, ma)) #tf.grey_opacity=True for v in vals: if use_log: tf.sample_colormap(math.log10(v), sigma**2, colormap=cm) #, alpha=0.2) else: print v tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2) sc.camera = cam sc.add_source(vol) sc.render("test_perspective.png", clip_ratio=6.0)
def surface_mesh_render(): images = [] ds = fake_tetrahedral_ds() for field in ds.field_list: if field[0] == 'all': continue sc = Scene() sc.add_source(MeshSource(ds, field)) sc.add_camera() im = sc.render() images.append(im) ds = fake_hexahedral_ds() for field in ds.field_list: if field[0] == 'all': continue sc = Scene() sc.add_source(MeshSource(ds, field)) sc.add_camera() im = sc.render() images.append(im) return images
# Hack: because rendering likes log fields ... ## create positive_radial_velocity and negative_radial_velocity fields. ## must do this before opening dataset @derived_field(name='pos_radial_velocity', units='cm/s') def _pos_radial_velocity(field, data): return np.maximum(data[('boxlib','radial_velocity')], 1.0e-99) @derived_field(name='neg_radial_velocity', units='cm/s') def _neg_radial_velocity(field, data): return np.maximum(-data[('boxlib','radial_velocity')], 1.0e-99) # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (0.25e8, 'cm')) # Create Scene sc = Scene() # Create Sources so_enuc = VolumeSource(core, ('boxlib','enucdot')) so_pos_vrad = VolumeSource(core, 'pos_radial_velocity') so_neg_vrad = VolumeSource(core, 'neg_radial_velocity') # Assign Transfer Functions to Sources tfh_en = TransferFunctionHelper(ds) tfh_en.set_field(('boxlib','enucdot')) tfh_en.set_log(True) tfh_en.set_bounds() tfh_en.build_transfer_function() tfh_en.tf.add_layers(10, colormap='black_green', w=0.01) tfh_en.grey_opacity = False tfh_en.plot('{}_tfun_enuc.png'.format(args.infile), profile_field=('boxlib','enucdot'))
# initialize the yt-specific data structure (ds) # for more info read: # http://yt-project.org/docs/dev/reference/api/generated/yt.frontends.stream.data_structures.load_uniform_grid.html?highlight=load_uniform_grid # please note here the length unit should be different for three axis # i used the unit for z-axis here for all three # since yt's unit system only support one uniform unit for the 3-D space ds = yt.load_uniform_grid(data, dom.shape, length_unit=0.20800511, bbox=bbox, nprocs=64) # initialize the yt scene sc = Scene() vol = VolumeSource(ds, field=field) # camera position #hc = ds.arr([hx, hy, hz], 'cm') # hydrogen location hc = ds.arr([19.13987520, 19.13987520, 82.13300000], 'cm') # hydrogen location # Find the bounds in log space of for your field dd = ds.all_data() mi, ma = dd.quantities.extrema(field) if use_log: mi, ma = np.log10(mi), np.log10(ma) # instantiating the ColorTransferfunction tf = yt.ColorTransferFunction((mi, ma)) '''
def test_composite_vr(self): ds = fake_random_ds(64) dd = ds.sphere(ds.domain_center, 0.45*ds.domain_width[0]) ds.field_info[ds.field_list[0]].take_log=False sc = Scene() cam = sc.add_camera(ds) cam.resolution = (512, 512) vr = VolumeSource(dd, field=ds.field_list[0]) vr.transfer_function.clear() vr.transfer_function.grey_opacity=True vr.transfer_function.map_to_colormap(0.0, 1.0, scale=3.0, colormap="Reds") sc.add_source(vr) cam.set_width( 1.8*ds.domain_width ) cam.lens.setup_box_properties(cam) # DRAW SOME LINES npoints = 100 vertices = np.random.random([npoints, 2, 3]) colors = np.random.random([npoints, 4]) colors[:, 3] = 0.10 box_source = BoxSource(ds.domain_left_edge, ds.domain_right_edge, color=[1.0, 1.0, 1.0, 1.0]) sc.add_source(box_source) LE = ds.domain_left_edge + np.array([0.1,0.,0.3])*ds.domain_left_edge.uq RE = ds.domain_right_edge-np.array([0.1,0.2,0.3])*ds.domain_left_edge.uq color = np.array([0.0, 1.0, 0.0, 0.10]) box_source = BoxSource(LE, RE, color=color) sc.add_source(box_source) line_source = LineSource(vertices, colors) sc.add_source(line_source) im = sc.render() im = ImageArray(im.d) im.write_png("composite.png") return im
import numpy as np import yt from yt.visualization.volume_rendering.api import Scene, create_volume_source ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030") # create a scene and add volume sources to it sc = Scene() # Add density field = "density" vol = create_volume_source(ds, field=field) vol.use_ghost_zones = True tf = yt.ColorTransferFunction([-28, -25]) tf.clear() tf.add_layers(4, 0.02, alpha=np.logspace(-3, -1, 4), colormap="winter") vol.set_transfer_function(tf) sc.add_source(vol) # Add temperature field = "temperature" vol2 = create_volume_source(ds, field=field) vol2.use_ghost_zones = True
def test_orientation(): ds = fake_vr_orientation_test_ds() sc = Scene() vol = VolumeSource(ds, field=('gas', 'density')) sc.add_source(vol) tf = vol.transfer_function tf = ColorTransferFunction((0.1, 1.0)) tf.sample_colormap(1.0, 0.01, colormap="coolwarm") tf.sample_colormap(0.8, 0.01, colormap="coolwarm") tf.sample_colormap(0.6, 0.01, colormap="coolwarm") tf.sample_colormap(0.3, 0.01, colormap="coolwarm") n_frames = 1 orientations = [[-0.3, -0.1, 0.8]] theta = np.pi / n_frames decimals = 12 test_name = "vr_orientation" for lens_type in ['plane-parallel', 'perspective']: frame = 0 cam = sc.add_camera(ds, lens_type=lens_type) cam.resolution = (1000, 1000) cam.position = ds.arr(np.array([-4., 0., 0.]), 'code_length') cam.switch_orientation(normal_vector=[1., 0., 0.], north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width * 2.) desc = '%s_%04d' % (lens_type, frame) test1 = VRImageComparisonTest(sc, ds, desc, decimals) test1.answer_name = test_name yield test1 for i in range(n_frames): frame += 1 center = ds.arr([0, 0, 0], 'code_length') cam.yaw(theta, rot_center=center) desc = 'yaw_%s_%04d' % (lens_type, frame) test2 = VRImageComparisonTest(sc, ds, desc, decimals) test2.answer_name = test_name yield test2 for i in range(n_frames): frame += 1 theta = np.pi / n_frames center = ds.arr([0, 0, 0], 'code_length') cam.pitch(theta, rot_center=center) desc = 'pitch_%s_%04d' % (lens_type, frame) test3 = VRImageComparisonTest(sc, ds, desc, decimals) test3.answer_name = test_name yield test3 for i in range(n_frames): frame += 1 theta = np.pi / n_frames center = ds.arr([0, 0, 0], 'code_length') cam.roll(theta, rot_center=center) desc = 'roll_%s_%04d' % (lens_type, frame) test4 = VRImageComparisonTest(sc, ds, desc, decimals) test4.answer_name = test_name yield test4 center = [0.5, 0.5, 0.5] width = [1.0, 1.0, 1.0] for i, orientation in enumerate(orientations): image = off_axis_projection(ds, center, orientation, width, 512, "density", no_ghost=False) def offaxis_image_func(filename_prefix): return image.write_image(filename_prefix) test5 = GenericImageTest(ds, offaxis_image_func, decimals) test5.prefix = "oap_orientation_{}".format(i) test5.answer_name = test_name yield test5
import yt from yt.visualization.volume_rendering.api import Scene, VolumeSource filePath = "Sedov_3d/sedov_hdf5_chk_0003" ds = yt.load(filePath) ds.periodicity = (True, True, True) sc = Scene() # set up camera cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = [400, 400] cam.position = ds.arr([1, 1, 1], "cm") cam.switch_orientation() # add rendering of density field dens = VolumeSource(ds, field="dens") dens.use_ghost_zones = True sc.add_source(dens) sc.save("density.png", sigma_clip=6) # add rendering of x-velocity field vel = VolumeSource(ds, field="velx") vel.use_ghost_zones = True sc.add_source(vel) sc.save("density_any_velocity.png", sigma_clip=6)
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) field = ('boxlib', 'density') ds._get_field_info(field).take_log = True sc = Scene() # add a volume: select a sphere vol = VolumeSource(ds, field=field) vol.use_ghost_zones = True sc.add_source(vol) # transfer function vals = [-1, 0, 1, 2, 3, 4, 5, 6, 7] #vals = [0.1, 1.0, 10, 100., 1.e4, 1.e5, 1.e6, 1.e7] sigma = 0.1 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" cm = "spectral" for v in vals: if v < 3: alpha = 0.1 else: alpha = 0.5 tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1920, 1080) cam.position = 1.5 * ds.arr(np.array([0.0, 5.e9, 5.e9]), 'cm') # look toward the center -- we are dealing with an octant center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge) normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) #sc.annotate_axes() #sc.annotate_domain(ds) pid = plotfile.split("plt")[1] sc.render() sc.save("wdmerger_{}_new.png".format(pid), sigma_clip=6.0) sc.save_annotated( "wdmerger_annotated_{}_new.png".format(pid), text_annotate= [[(0.05, 0.05), "t = {:.3f} s".format(float(ds.current_time.d)), dict(horizontalalignment="left")], [(0.5, 0.95), "Castro simulation of merging white dwarfs (0.6 $M_\odot$ + 0.9 $M_\odot$)", dict(color="y", fontsize="22", horizontalalignment="center")], [(0.95, 0.05), "M. Katz et al.", dict(color="w", fontsize="16", horizontalalignment="right")]])
'--alpha_ones', action='store_true', help='If supplied, set the transfer function values to ones.') parser.add_argument('-res', '--resolution', type=int, default=2048, help='Resolution for output plot.') args = parser.parse_args() # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (args.rup, 'cm')) # Create Scene sc = Scene() # Create Sources so_circum_vel = VolumeSource(core, ('boxlib', 'circum_velocity')) mag_vel_bounds = np.array([1.0e1, 1.0e6]) mag_vel_sigma = 0.08 nlayers = 6 if args.alpha_ones: alphavec = np.ones(nlayers) else: alphavec = np.logspace(-5, 0, nlayers) tfh = TransferFunctionHelper(ds) tfh.set_field(('boxlib', 'circum_velocity'))
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) field = ('boxlib', 'radial_velocity') ds._get_field_info(field).take_log = False sc = Scene() # add a volume: select a sphere center = (0, 0, 0) R = (5.e8, 'cm') dd = ds.sphere(center, R) vol = VolumeSource(dd, field=field) vol.use_ghost_zones = True sc.add_source(vol) # transfer function vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6] sigma = 3.e5 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" for v in vals: tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1280, 720) cam.position = 1.5 * ds.arr(np.array([5.e8, 5.e8, 5.e8]), 'cm') # look toward the center -- we are dealing with an octant center = ds.domain_left_edge normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) #sc.annotate_axes() #sc.annotate_domain(ds) sc.render() sc.save("subchandra_test.png", sigma_clip=6.0) sc.save_annotated( "subchandra_test_annotated.png", text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d), dict(horizontalalignment="left")], [(0.5, 0.95), "Maestro simulation of He convection on a white dwarf", dict(color="y", fontsize="24", horizontalalignment="center")]])
parser.add_argument('-alpha_ones', '--alpha_ones', action='store_true', help='If supplied, set the transfer function values to ones.') parser.add_argument('-res', '--resolution', type=int, default=2048, help='Resolution for output plot.') parser.add_argument('-dry', '--dry_run', action='store_true', help='Plot only the transfer functions and quit.') args = parser.parse_args() # Workaround @derived_field(name='abs_ye_asymmetry', units='') def _abs_ye_asymmetry(field, data): return np.absolute(data['electron_fraction_asymmetry']) # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (args.rup, 'cm')) # Create Scene sc = Scene() # Create Sources so = VolumeSource(core, 'abs_ye_asymmetry') bounds = np.array([args.ye_asym_minimum, args.ye_asym_maximum]) log_min = np.log10(args.ye_asym_minimum) log_max = np.log10(args.ye_asym_maximum) sigma = args.ye_sigma nlayers = args.num_layers if args.alpha_ones: alphavec = np.ones(nlayers) else: alphavec = np.logspace(-3, 0, num=nlayers, endpoint=True)
def test_lazy_volume_source_construction(self): sc = Scene() source = create_volume_source(self.ds.all_data(), "density") assert source._volume is None assert source._transfer_function is None source.tfh.bounds = (0.1, 1) source.set_log(False) assert not source.log_field assert source.transfer_function.x_bounds == [0.1, 1] assert source._volume is None source.set_log(True) assert source.log_field assert source.transfer_function.x_bounds == [-1, 0] assert source._volume is None source.transfer_function = None source.tfh.bounds = None ad = self.ds.all_data() np.testing.assert_allclose( source.transfer_function.x_bounds, np.log10(ad.quantities.extrema("density")), ) assert source.tfh.log == source.log_field source.set_field("velocity_x") source.set_log(False) assert source.transfer_function.x_bounds == list( ad.quantities.extrema("velocity_x") ) assert source._volume is None source.set_field("density") assert source.volume is not None assert not source.volume._initialized assert source.volume.fields is None del source.volume assert source._volume is None sc.add_source(source) sc.add_camera() sc.render() assert source.volume is not None assert source.volume._initialized assert source.volume.fields == [("gas", "density")] assert source.volume.log_fields == [True] source.set_field("velocity_x") source.set_log(False) sc.render() assert source.volume is not None assert source.volume._initialized assert source.volume.fields == [("gas", "velocity_x")] assert source.volume.log_fields == [False]
# Hack: because rendering likes log fields ... ## create positive_radial_velocity and negative_radial_velocity fields. ## must do this before opening dataset @derived_field(name='pos_radial_velocity', units='cm/s') def _pos_radial_velocity(field, data): return np.maximum(data[('boxlib','radial_velocity')], 1.0e-99) @derived_field(name='neg_radial_velocity', units='cm/s') def _neg_radial_velocity(field, data): return np.maximum(-data[('boxlib','radial_velocity')], 1.0e-99) # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (args.rup, 'cm')) # Create Scene sc = Scene() # Create Sources #so_enuc = VolumeSource(core, ('boxlib','enucdot')) so_pos_vrad = VolumeSource(core, 'pos_radial_velocity') so_neg_vrad = VolumeSource(core, 'neg_radial_velocity') # Assign Transfer Functions to Sources # tfh_en = TransferFunctionHelper(ds) # tfh_en.set_field(('boxlib','enucdot')) # tfh_en.set_log(True) # tfh_en.set_bounds() # tfh_en.build_transfer_function() # tfh_en.tf.add_layers(10, colormap='black_green', w=0.01) # tfh_en.grey_opacity = False # tfh_en.plot('{}_tfun_enuc.png'.format(args.infile), profile_field=('boxlib','enucdot'))
import yt from yt.visualization.volume_rendering.api import Scene, create_volume_source field = ("gas", "density") # normal_vector points from camera to the center of the final projection. # Now we look at the positive x direction. normal_vector = [1.0, 0.0, 0.0] # north_vector defines the "top" direction of the projection, which is # positive z direction here. north_vector = [0.0, 0.0, 1.0] # Follow the simple_volume_rendering cookbook for the first part of this. ds = yt.load("IsolatedGalaxy/galaxy0030/galaxy0030") sc = Scene() vol = create_volume_source(ds, field=field) tf = vol.transfer_function tf.grey_opacity = True # Plane-parallel lens cam = sc.add_camera(ds, lens_type="plane-parallel") # Set the resolution of the final projection. cam.resolution = [250, 250] # Set the location of the camera to be (x=0.2, y=0.5, z=0.5) # For plane-parallel lens, the location info along the normal_vector (here # is x=0.2) is ignored. cam.position = ds.arr(np.array([0.2, 0.5, 0.5]), "code_length") # Set the orientation of the camera. cam.switch_orientation(normal_vector=normal_vector, north_vector=north_vector) # Set the width of the camera, where width[0] and width[1] specify the length and
# Hack: because rendering likes log fields ... ## create positive_radial_velocity and negative_radial_velocity fields. ## must do this before opening dataset @derived_field(name='pos_enucdot', units='erg/(g*s)') def _pos_radial_velocity(field, data): return np.maximum(data[('boxlib','enucdot')], yt.YTQuantity(1.0e-99, 'erg/(g*s)')) @derived_field(name='neg_enucdot', units='erg/(g*s)') def _neg_radial_velocity(field, data): return np.maximum(-data[('boxlib','enucdot')], yt.YTQuantity(1.0e-99, 'erg/(g*s)')) # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (args.rup, 'cm')) # Create Scene sc = Scene() # Create Sources so_pos_enuc = VolumeSource(core, 'pos_enucdot') so_neg_enuc = VolumeSource(core, 'neg_enucdot') # Get maximum values for alpha settings pos_maxv = np.ceil(np.log10(core.max('pos_enucdot'))) neg_maxv = np.ceil(np.log10(core.max('neg_enucdot'))) rat_neg_pos = 10.0**(neg_maxv-pos_maxv) # Assign Transfer Functions to Sources mag_enuc_sigma = 0.1 tfh = TransferFunctionHelper(ds) tfh.set_field('pos_enucdot')
def vol_render_density(outfile, ds): """Volume render the density given a yt dataset.""" import numpy as np import yt import matplotlib matplotlib.use('agg') from yt.visualization.volume_rendering.api import Scene, VolumeSource import matplotlib.pyplot as plt ds.periodicity = (True, True, True) field = ('boxlib', 'density') ds._get_field_info(field).take_log = True sc = Scene() # Add a volume: select a sphere vol = VolumeSource(ds, field=field) vol.use_ghost_zones = True sc.add_source(vol) # Transfer function vals = [-1, 0, 1, 2, 3, 4, 5, 6, 7] sigma = 0.1 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "spectral" for v in vals: if v < 3: alpha = 0.1 else: alpha = 0.5 tf.sample_colormap(v, sigma**2, colormap=cm, alpha=alpha) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1920, 1080) center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge) width = ds.domain_width # Set the camera so that we're looking down on the xy plane from a 45 # degree angle. We reverse the y-coordinate since yt seems to use the # opposite orientation convention to us (where the primary should be # on the left along the x-axis). We'll scale the camera position based # on a zoom factor proportional to the width of the domain. zoom_factor = 0.75 cam_position = np.array([ center[0], center[1] - zoom_factor * width[1], center[2] + zoom_factor * width[2] ]) cam.position = zoom_factor * ds.arr(cam_position, 'cm') # Set the normal vector so that we look toward the center. normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0.0, 0.0, 1.0]) cam.set_width(width) # Render the image. sc.render() # Save the image without annotation. sc.save(outfile, sigma_clip=6.0) # Save the image with a colorbar. sc.save_annotated(outfile.replace(".png", "_colorbar.png"), sigma_clip=6.0) # Save the image with a colorbar and the current time. sc.save_annotated(outfile.replace(".png", "_colorbar_time.png"), sigma_clip=6.0, text_annotate=[[ (0.05, 0.925), "t = {:.2f} s".format(float(ds.current_time.d)), dict(horizontalalignment="left", fontsize="20") ]])
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) field = ('gas', 'velocity_z') ds._get_field_info(field).take_log = False sc = Scene() # add a volume: select a sphere #center = (0, 0, 0) #R = (5.e8, 'cm') #dd = ds.sphere(center, R) vol = VolumeSource(ds, field=field) vol.use_ghost_zones = True sc.add_source(vol) # transfer function vals = [-1.e7, -5.e6, 5.e6, 1.e7] sigma = 5.e5 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" for v in vals: tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1920, 1080) center = 0.5*(ds.domain_left_edge + ds.domain_right_edge) cam.position = [2.5*ds.domain_right_edge[0], 2.5*ds.domain_right_edge[1], center[2]+0.25*ds.domain_right_edge[2]] # look toward the center -- we are dealing with an octant normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) sc.camera = cam #sc.annotate_axes(alpha=0.05) #sc.annotate_domain(ds, color=np.array([0.05, 0.05, 0.05, 0.05])) #sc.annotate_grids(ds, alpha=0.05) sc.render() sc.save("{}_radvel".format(plotfile), sigma_clip=4.0) sc.save_annotated("{}_radvel_annotated.png".format(plotfile), sigma_clip=4.0, text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d), dict(horizontalalignment="left")], [(0.5,0.95), "Maestro simulation of convection in a mixed H/He XRB", dict(color="y", fontsize="24", horizontalalignment="center")]])
args = parser.parse_args() # Open Dataset ds = yt.load(args.infile) core = ds.sphere(ds.domain_center, (args.rup, 'cm')) # Load urca-specific fields ushell_fields = UrcaShellFields() ushell_fields.setup(ds) # Get the field from the dataset field, field_short_name = DatasetHelpers.get_field(ds, args.field) assert (field) # Create Scene sc = Scene() # Create Sources so = VolumeSource(core, field) bounds = np.array([args.minimum, args.maximum]) log_min = np.log10(args.minimum) log_max = np.log10(args.maximum) sigma = args.sigma nlayers = args.num_layers if args.alpha_ones: alphavec = np.ones(nlayers) else: alphavec = np.logspace(-3, 0, num=nlayers, endpoint=True)
def test_orientation(): ds = fake_vr_orientation_test_ds() sc = Scene() vol = create_volume_source(ds, field=("gas", "density")) sc.add_source(vol) tf = vol.transfer_function tf = ColorTransferFunction((0.1, 1.0)) tf.sample_colormap(1.0, 0.01, colormap="coolwarm") tf.sample_colormap(0.8, 0.01, colormap="coolwarm") tf.sample_colormap(0.6, 0.01, colormap="coolwarm") tf.sample_colormap(0.3, 0.01, colormap="coolwarm") n_frames = 1 orientations = [[-0.3, -0.1, 0.8]] theta = np.pi / n_frames test_name = "vr_orientation" for lens_type, decimals in [("perspective", 12), ("plane-parallel", 2)]: # set a much lower precision for plane-parallel tests, see # https://github.com/yt-project/yt/issue/3069 # https://github.com/yt-project/yt/pull/3068 # https://github.com/yt-project/yt/pull/3294 frame = 0 cam = sc.add_camera(ds, lens_type=lens_type) cam.resolution = (1000, 1000) cam.position = ds.arr(np.array([-4.0, 0.0, 0.0]), "code_length") cam.switch_orientation(normal_vector=[1.0, 0.0, 0.0], north_vector=[0.0, 0.0, 1.0]) cam.set_width(ds.domain_width * 2.0) desc = "%s_%04d" % (lens_type, frame) test1 = VRImageComparisonTest(sc, ds, desc, decimals) test1.answer_name = test_name yield test1 for _ in range(n_frames): frame += 1 center = ds.arr([0, 0, 0], "code_length") cam.yaw(theta, rot_center=center) desc = "yaw_%s_%04d" % (lens_type, frame) test2 = VRImageComparisonTest(sc, ds, desc, decimals) test2.answer_name = test_name yield test2 for _ in range(n_frames): frame += 1 theta = np.pi / n_frames center = ds.arr([0, 0, 0], "code_length") cam.pitch(theta, rot_center=center) desc = "pitch_%s_%04d" % (lens_type, frame) test3 = VRImageComparisonTest(sc, ds, desc, decimals) test3.answer_name = test_name yield test3 for _ in range(n_frames): frame += 1 theta = np.pi / n_frames center = ds.arr([0, 0, 0], "code_length") cam.roll(theta, rot_center=center) desc = "roll_%s_%04d" % (lens_type, frame) test4 = VRImageComparisonTest(sc, ds, desc, decimals) test4.answer_name = test_name yield test4 center = [0.5, 0.5, 0.5] width = [1.0, 1.0, 1.0] for i, orientation in enumerate(orientations): image = off_axis_projection(ds, center, orientation, width, 512, ("gas", "density"), no_ghost=False) def offaxis_image_func(filename_prefix): return image.write_image(filename_prefix) test5 = GenericImageTest(ds, offaxis_image_func, decimals) test5.prefix = f"oap_orientation_{i}" test5.answer_name = test_name yield test5
def doit(plotfile): ds = yt.load(plotfile) ds.periodicity = (True, True, True) field = ('boxlib', 'radial_velocity') ds._get_field_info(field).take_log = False sc = Scene() # add a volume: select a sphere #center = (0, 0, 0) #R = (5.e8, 'cm') #dd = ds.sphere(center, R) vol = VolumeSource(ds, field=field) vol.use_ghost_zones = True sc.add_source(vol) # transfer function vals = [-5.e6, -2.5e6, -1.25e6, 1.25e6, 2.5e6, 5.e6] sigma = 3.e5 tf = yt.ColorTransferFunction((min(vals), max(vals))) tf.clear() cm = "coolwarm" for v in vals: tf.sample_colormap(v, sigma**2, colormap=cm) #, alpha=0.2) sc.get_source(0).transfer_function = tf cam = sc.add_camera(ds, lens_type="perspective") cam.resolution = (1080, 1080) cam.position = 1.0*ds.domain_right_edge # look toward the center -- we set this depending on whether the plotfile # indicates it was an octant try: octant = ds.parameters["octant"] except: octant = True if octant: center = ds.domain_left_edge else: center = 0.5*(ds.domain_left_edge + ds.domain_right_edge) # unit vector connecting center and camera normal = (center - cam.position) normal /= np.sqrt(normal.dot(normal)) cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.]) cam.set_width(ds.domain_width) #sc.annotate_axes(alpha=0.05) #sc.annotate_domain(ds, color=np.array([0.05, 0.05, 0.05, 0.05])) #sc.annotate_grids(ds, alpha=0.05) sc.render() sc.save("{}_radvel".format(plotfile), sigma_clip=6.0) sc.save_annotated("{}_radvel_annotated.png".format(plotfile), text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d), dict(horizontalalignment="left")], [(0.5,0.95), "Maestro simulation of He convection on a white dwarf", dict(color="y", fontsize="24", horizontalalignment="center")]])