def test_stereoperspective_lens(self):
sc = Scene()
cam = sc.add_camera(self.ds, lens_type="stereo-perspective")
cam.resolution = [256, 128]
cam.position = self.ds.arr(np.array([0.7, 0.7, 0.7]), "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_stereoperspective_{self.field[1]}.png", 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 = 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_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(f"test_spherical_{self.field[1]}.png", 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_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 surface_mesh_render():
images = []
ds = fake_tetrahedral_ds()
for field in ds.field_list:
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:
sc = Scene()
sc.add_source(MeshSource(ds, field))
sc.add_camera()
im = sc.render()
images.append(im)
return images
def doit(plotfile):
ds = yt.load(plotfile)
ds.periodicity = (True, True, True)
cm = "coolwarm"
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)
sc.add_source(vol)
# transfer function
vals = [-5.e5, -2.5e5, -1.25e5, 1.25e5, 2.5e5, 5.e5]
sigma = 3.e4
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 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.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)
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 = VolumeSource(self.ds, field=self.field)
tf = vol.transfer_function
tf.grey_opacity = True
sc.add_source(vol)
sc.save("test_stereospherical_%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 = 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_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 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 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 = create_volume_source(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, 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
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
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):
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")]])
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")]])
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 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
decimals = 12
test_name = "vr_orientation"
for lens_type in [
"perspective",
# final name VRImageComparison_UniformGridData_vr_pitch_plane-parallel_0002
# deactivated because of a random failure since numpy 0.20.0 and 0.20.1
# "plane-parallel"
]:
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,
"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 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]
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
# for spherical, youtube recommends an "equirectangular" aspect ratio
# (2:1), suggested resolution of 8192 x 4096
# see: https://support.google.com/youtube/answer/6178631?hl=en
#
# also see: http://yt-project.org/docs/dev/cookbook/complex_plots.html#various-lens-types-for-volume-rendering
# the 2:1 is 2*pi in phi and pi in theta
cam = sc.add_camera(ds, lens_type="spherical")
#cam.resolution = (8192, 4096)
cam.resolution = (4096, 2048)
# look toward the +x initially
cam.focus = ds.arr(np.array([ds.domain_left_edge[0], 0.0, 0.0]), 'cm')
# center of the domain -- eventually we might want to do the
# center of mass
cam.position = ds.arr(np.array([0.0, 0.0, 0.0]), 'cm')
# define up
cam.north_vector = np.array([0., 0., 1.])
normal = (cam.focus - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.])
# there is no such thing as a camera width -- the entire volume is rendered
#cam.set_width(ds.domain_width)
#sc.annotate_axes()
#sc.annotate_domain(ds)
pid = plotfile.split("plt")[1]
sc.render()
sc.save("wdmerger_{}_spherical.png".format(pid), sigma_clip=6.0)
def doit(plotfile):
ds = CastroDataset(plotfile)
ds._periodicity = (True, True, True)
field = ('boxlib', 'enuc')
ds._get_field_info(field).take_log = True
sc = Scene()
# add a volume: select a sphere
#center = (0, 0, 0)
#R = (5.e8, 'cm')
#dd = ds.sphere(center, R)
vol = create_volume_source(ds.all_data(), field=field)
sc.add_source(vol)
# transfer function
vals = [16.5, 17.0, 17.5, 18.0, 18.5, 19.0, 19.5]
sigma = 0.1
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cmap = "viridis"
for v in vals:
if v < 19.0:
alpha = 0.25
else:
alpha = 0.75
tf.sample_colormap(v, sigma**2, alpha=alpha, colormap=cmap)
sc.get_source(0).transfer_function = tf
cam = sc.add_camera(ds, lens_type="perspective")
cam.resolution = (1920, 1280)
# view 1
cam.position = [
0.75 * ds.domain_right_edge[0],
0.5 * (ds.domain_left_edge[1] + ds.domain_right_edge[1]),
ds.domain_right_edge[2]
] # + 0.25 * (ds.domain_right_edge[2] - ds.domain_left_edge[2])]
# look toward the center
center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge)
# set the center in the vertical direction to be the height of the underlying base layer
center[-1] = 2000 * cm
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.])
cam.set_width(3 * ds.domain_width)
cam.zoom(3.0)
sc.camera = cam
sc.save_annotated(
"{}_Hnuc_annotated_side.png".format(plotfile),
text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5, 0.95),
"Castro simulation of XRB flame spreading",
dict(color="y",
fontsize="24",
horizontalalignment="center")]])
# view 2
dx = ds.domain_right_edge[0] - ds.domain_left_edge[0]
cam.position = [
0.5 * (ds.domain_left_edge[0] + ds.domain_right_edge[0]) + 0.0001 * dx,
0.5 * (ds.domain_left_edge[1] + ds.domain_right_edge[1]),
ds.domain_right_edge[2]
] # + 0.25 * (ds.domain_right_edge[2] - ds.domain_left_edge[2])]
# look toward the center
center = 0.5 * (ds.domain_left_edge + ds.domain_right_edge)
# set the center in the vertical direction to be the height of the underlying base layer
center[-1] = 2000 * cm
normal = (center - cam.position)
normal /= np.sqrt(normal.dot(normal))
cam.switch_orientation(normal_vector=normal, north_vector=[0., 0., 1.])
cam.set_width(3 * ds.domain_width)
cam.zoom(0.6)
sc.camera = cam
sc.save_annotated(
"{}_Hnuc_annotated_top.png".format(plotfile),
text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5, 0.95),
"Castro simulation of XRB flame spreading",
dict(color="y",
fontsize="24",
horizontalalignment="center")]])
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
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)
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 = ('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")]])
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', 'Hnuc')
ds._get_field_info(field).take_log = True
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)
sc.add_source(vol)
# transfer function
vals = [14, 14.5, 15, 15.5, 16]
sigma = 0.1
tf = yt.ColorTransferFunction((min(vals), max(vals)))
tf.clear()
cm = "viridis"
for v in vals:
if v < 15.5:
alpha = 0.1
else:
alpha = 0.75
tf.sample_colormap(v, sigma**2, alpha=alpha, colormap=cm)
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 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(0.5 * ds.domain_width)
cam.zoom(1.5)
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("{}_Hnuc".format(plotfile), sigma_clip=4.0)
sc.save_annotated(
"{}_Hnuc_annotated.png".format(plotfile),
text_annotate=[[(0.05, 0.05), "t = {}".format(ds.current_time.d),
dict(horizontalalignment="left")],
[(0.5, 0.95), "MAESTROeX simulation of ECSN convection",
dict(color="y",
fontsize="24",
horizontalalignment="center")]])
