def FCC(L_x, L_y, L_z, Color='red'):
Ax = []
Ay = []
Az = []
#for each layer of the atom in the x direction. the *2-1 is so that L_x is the number of unit cells
for O in range(L_x * 2 - 1):
#for each layer in the y direction.
for S in range(L_y * 2 - 1):
#for each layer in the z direction.
for A in range(L_z * 2 - 1):
if (O + S + A) % 2 == 0:
#the 0.5 is becasue L_xyz was multiplied by 2
Ax.append(float(O * .5))
Ay.append(float(S * .5))
Az.append(float(A * .5))
elif S % 2 == 1 and O % 2 == 1 and A % 2 == 0:
Ax.append(float(O * .5))
Ay.append(float(S * .5))
Az.append(float(A * .5))
#if there should not be an atom
#in theory this could be used to remove other atoms to make cubic or BCC structure
#the x, y, z limits
ipv.xyzlim(0, 10) #define as a function highest of L_xyz
ipv.scatter(np.array(Ax),
np.array(Ay),
np.array(Az),
marker='sphere',
size=6.5,
color=Color)
ipv.show()
def ShowAnimation3D(self, size=15):
ipv.figure()
ipv.style.use("dark")
x_Part = []
y_Part = []
z_Part = []
for Part in self.Parts:
temp_x = Part.x
temp_y = Part.y
temp_z = Part.z
x_Part.append(temp_x)
y_Part.append(temp_y)
z_Part.append(temp_z)
x = combine(self.speed * 5, *x_Part)
y = combine(self.speed * 5, *y_Part)
z = combine(self.speed * 5, *z_Part)
u = ipv.scatter(x, y, z, marker="sphere", size=10, color="green")
ipv.animation_control(u, interval=100)
ipv.xyzlim(-size, size)
ipv.show()
def on_select_to_plot(self, change):
"""Call-back function for plotting a 3D visualisaiton of the segmentation"""
#if the selected file has changed, import image, segmentation and global mask and plot
if change['new'] != change['old']:
print('new: ' + str(change['new']))
print('old: ' + str(change['old']))
image = skimage.io.imread(self.folder_name + '/' +
self.select_file_to_plot.value,
plugin='tifffile')
image2 = skimage.io.imread(
self.folder_name + '/' +
os.path.splitext(self.select_file_to_plot.value)[0] +
'_label.tif',
plugin='tifffile')
image3 = skimage.io.imread(
self.folder_name + '/' +
os.path.splitext(self.select_file_to_plot.value)[0] +
'_region.tif',
plugin='tifffile')
#create ipyvolume figure
ipv.figure()
volume_image = ipv.volshow(image[0, :, :, :, 1],
extent=[[0, 1024], [0, 1024], [-20,
20]],
level=[0.3, 0.2, 0.2],
opacity=[0.2, 0, 0])
volume_seg = ipv.plot_isosurface(np.swapaxes(image2 > 0, 0, 2),
level=0.5,
controls=True,
color='green',
extent=[[0, 1024], [0, 1024],
[-20, 20]])
volume_reg = ipv.volshow(image3,
extent=[[0, 1024], [0, 1024], [-20, 20]],
level=[0.3, 0.2, 1],
opacity=[0.0, 0, 0.5])
volume_reg.brightness = 10
volume_image.brightness = 10
volume_image.opacity = 100
ipv.xyzlim(0, 1024)
ipv.zlim(-500, 500)
ipv.style.background_color('black')
#create additional controls to show/hide segmentation
color = ColorPicker(description='Segmentation color')
visible = ipw.Checkbox()
jslink((volume_seg, 'color'), (color, 'value'))
jslink((volume_seg, 'visible'), (visible, 'value'))
ipv.show()
with self.out:
clear_output(wait=True)
display(VBox([ipv.gcc(), color, visible]))
viewer = napari.Viewer(ndisplay=3)
viewer.add_image(image, colormap='red')
viewer.add_image(image2, colormap='green', blending='additive')
viewer.add_image(image3, colormap='blue', blending='additive')
def browse_history(history,
coords=["x", "y", "z"],
start=None,
stop=None,
size=None,
**draw_specs_kw):
times = history.slice(start, stop, size)
num_frames = times.size
draw_specs = sheet_spec()
spec_updater(draw_specs, draw_specs_kw)
sheet = history.retrieve(0)
ipv.clear()
fig, meshes = sheet_view(sheet, coords, **draw_specs_kw)
lim_inf = sheet.vert_df[sheet.coords].min().min()
lim_sup = sheet.vert_df[sheet.coords].max().max()
ipv.xyzlim(lim_inf, lim_sup)
def set_frame(i=0):
fig.animation = 0
t = times[i]
meshes = _get_meshes(history.retrieve(t), coords, draw_specs)
update_view(fig, meshes)
ipv.show()
interact(set_frame, i=(0, num_frames - 1))
def _display_sphere(
self,
fluxes,
distances,
theta,
phi,
cmap="magma",
distance_transform=None,
use_log=False,
fig=None,
background_color="white",
show=True,
**kwargs,
):
if len(fluxes) == 0:
log.warning("There are no detections to display")
return
if fig is None:
fig = ipv.figure()
ipv.pylab.style.box_off()
ipv.pylab.style.axes_off()
ipv.pylab.style.set_style_dark()
ipv.pylab.style.background_color(background_color)
if distance_transform is not None:
distance = distance_transform(distances)
else:
distance = distances
x, y, z = _create_sphere_variables(self._r_max, distance, theta, phi)
_, colors = array_to_cmap(fluxes, cmap, use_log=True)
ipv.scatter(x, y, z, color=colors, marker="sphere", **kwargs)
r_value = fig
if show:
ipv.xyzlim(self._r_max)
fig.camera.up = [1, 0, 0]
control = pythreejs.OrbitControls(controlling=fig.camera)
fig.controls = control
control.autoRotate = True
fig.render_continuous = True
# control.autoRotate = True
# toggle_rotate = widgets.ToggleButton(description="Rotate")
# widgets.jslink((control, "autoRotate"), (toggle_rotate, "value"))
# r_value = toggle_rotate
return fig
def NACL(L_x, L_y=None, L_z=None, ColorNa='red', ColorCl='green'):
if L_y == None:
L_y = L_x
if L_z == None:
L_z = L_x
if L_x > L_y:
Max = L_x
else:
Max = L_y
if L_z > Max:
Max = L_z #defined as a function highest of L_xyz
#define a list of positions to append to
Clx = []
Cly = []
Clz = []
Nax = []
Nay = []
Naz = []
#for each layer of the atom in the x direction. the *2-1 is so that L_x is the number of unit cells
for O in range(L_x * 2 - 1):
#for each layer in the y direction.
for S in range(L_y * 2 - 1):
#for each layer in the z direction.
for A in range(L_z * 2 - 1):
#if in this position there shoud be a Cl atom
if (O + S + A) % 2 == 0:
#the 0.5 is becasue L_xyz was multiplied by 2
Clx.append(float(O * .5))
Cly.append(float(S * .5))
Clz.append(float(A * .5))
#if there should be a Na atom
elif (O + S + A) % 2 == 1:
Nax.append(float(O * .5))
Nay.append(float(S * .5))
Naz.append(float(A * .5))
#if there should not be an atom
#in theory this could be used to remove other atoms to make cubic or BCC structure
#the x, y, z limits
ipv.xyzlim(0, Max)
#the color and size the Na and Cl atoms
ipv.scatter(np.array(Clx),
np.array(Cly),
np.array(Clz),
marker='sphere',
size=6.5,
color=ColorCl)
ipv.scatter(
np.array(Nax),
np.array(Nay),
np.array(Naz),
marker='sphere',
size=4,
color=ColorNa,
)
ipv.show()
def plot_milkyway(R_sun=8, size=100):
mw_image = PIL.Image.open(milkyway_image.fetch())
rescale = 40
t = np.linspace(0, 1, 100)
xmw = np.linspace(0, 1, 10)
ymw = np.linspace(0, 1, 10)
xmw, ymw = np.meshgrid(xmw, ymw)
zmw = xmw * 0 + 0.01
mw = mesh = ipv.plot_mesh((xmw-0.5)*rescale, (ymw-0.5)*rescale+R_sun, zmw, u=xmw, v=ymw, texture=mw_image, wireframe=False)
mw.material.blending = pythreejs.BlendingMode.CustomBlending
mw.material.blendSrc = pythreejs.BlendFactors.SrcColorFactor
mw.material.blendDst = pythreejs.BlendFactors.OneFactor
mw.material.blendEquation = 'AddEquation'
mw.material.transparent = True
mw.material.depthWrite = False
mw.material.alphaTest = 0.1
ipv.xyzlim(size)
return mesh
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 SC(L_x, L_y, L_z, Color='red'):
Ax = []
Ay = []
Az = []
for O in range(L_x):
#for each layer in the y direction.
for S in range(L_y):
#for each layer in the z direction.
for A in range(L_z):
Ax.append(float(O))
Ay.append(float(S))
Az.append(float(A))
#the x, y, z limits
ipv.xyzlim(0, 10) #define as a function highest of L_xyz
ipv.scatter(np.array(Ax),
np.array(Ay),
np.array(Az),
marker='sphere',
size=6.5,
color=Color)
ipv.show()
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 sheet_view(sheet, coords=["x", "y", "z"], **draw_specs_kw):
"""
Creates a javascript renderer of the edge lines to be displayed
in Jupyter Notebooks
Returns
-------
fig: a :class:`ipyvolume.widgets.Figure` widget
mesh: a :class:`ipyvolume.widgets.Mesh` mesh widget
"""
ipv.style.use(["dark", "minimal"])
draw_specs = sheet_spec()
spec_updater(draw_specs, draw_specs_kw)
fig = ipv.gcf()
edge_spec = draw_specs["edge"]
if edge_spec["visible"]:
edges = edge_mesh(sheet, coords, **edge_spec)
fig.meshes = fig.meshes + [edges]
else:
edges = None
face_spec = draw_specs["face"]
if face_spec["visible"]:
faces = face_mesh(sheet, coords, **face_spec)
fig.meshes = fig.meshes + [faces]
else:
faces = None
box_size = max(*(np.ptp(sheet.vert_df[u]) for u in sheet.coords))
border = 0.05 * box_size
lim_inf = sheet.vert_df[sheet.coords].min().min() - border
lim_sup = sheet.vert_df[sheet.coords].max().max() + border
ipv.xyzlim(lim_inf, lim_sup)
return fig, (edges, faces)
def view_ipv(sheet, coords=["x", "y", "z"], **edge_specs):
"""
Creates a javascript renderer of the edge lines to be displayed
in Jupyter Notebooks
Returns
-------
fig: a :class:`ipyvolume.widgets.Figure` widget
mesh: a :class:`ipyvolume.widgets.Mesh` mesh widget
"""
warnings.warn("`view_ipv` is deprecated, use the more generic `sheet_view`")
mesh = edge_mesh(sheet, coords, **edge_specs)
fig = ipv.gcf()
fig.meshes = fig.meshes + [mesh]
box_size = max(*(np.ptp(sheet.vert_df[u]) for u in sheet.coords))
border = 0.05 * box_size
lim_inf = sheet.vert_df[sheet.coords].min().min() - border
lim_sup = sheet.vert_df[sheet.coords].max().max() + border
ipv.xyzlim(lim_inf, lim_sup)
return fig, mesh
def sheet_view(sheet, coords=["x", "y", "z"], **draw_specs_kw):
"""
Creates a javascript renderer of the edge lines to be displayed
in Jupyter Notebooks
Returns
-------
fig: a :class:`ipyvolume.widgets.Figure` widget
mesh: a :class:`ipyvolume.widgets.Mesh` mesh widget
"""
# ipv.style.use(["dark", "minimal"])
draw_specs = sheet_spec()
spec_updater(draw_specs, draw_specs_kw)
fig = ipv.gcf()
fig.meshes = fig.meshes + _get_meshes(sheet, coords, draw_specs)
box_size = max(*(np.ptp(sheet.vert_df[u]) for u in sheet.coords))
border = 0.05 * box_size
lim_inf = sheet.vert_df[sheet.coords].min().min() - border
lim_sup = sheet.vert_df[sheet.coords].max().max() + border
ipv.xyzlim(lim_inf, lim_sup)
return fig, fig.meshes
def get_globe(topofile, df, size=None, key=None):
"""Return an ipywidget with an interactive globe.
Arguments:
topofile: filename of a TopoJSON file to render. This file is expected to have its
major regions arranged as a list in ['objects']['areas']['geometries'].
df: dataframe where each row will be turned into an animation frame and columns
are expected to match the major regions in the topofile.
size: in integer pixels
key: string key to pass to ipyvolume, allows replacement of earlier charts
"""
with open(topofile, 'r') as fid:
topo = json.loads(fid.read())
(width, height) = (size, size) if size is not None else (500, 500)
ipv.pylab.clear()
fig = ipv.figure(width=width, height=height, key=key, controls=True)
# Make a simple globe
x, y, z = np.array([[0.], [0.], [0.]])
ipv.scatter(x, y, z, size=100, color='blue', marker="sphere")
# draw raised outlines for each area
animate = []
for area in topo['objects']['areas']['geometries']:
name = area['id']
if name not in df.columns:
continue
lines = _extract_lines(topo, name=name)
x = []
y = []
z = []
triangles = []
data = df.loc[:, name].fillna(0.0)
for (year, row) in df.iterrows():
x_t = [0]
y_t = [0]
z_t = [0]
tri_t = []
offset = 1
total = row.get('Total', row.get('World', 1.0))
val = row.get(name, 0.0)
radius = 1.01 + (((val / total) * 0.15) if total > 0.0 else 0.0)
for line in lines:
xyz = [
_latlon2xyz(lat, lon, radius=radius) for (lon, lat) in line
]
x1, y1, z1 = [list(t) for t in zip(*xyz)]
x_t.extend(x1 + [0])
y_t.extend(y1 + [0])
z_t.extend(z1 + [0])
for _ in range(0, len(x1)):
tri_t.append([0, offset, offset + 1])
offset += 1
offset += 1
x.append(x_t)
y.append(y_t)
z.append(z_t)
triangles.append(tri_t)
color = ui.color.webcolor_to_hex(ui.color.get_region_color(name))
s = ipv.scatter(x=-np.array(x),
y=np.array(z),
z=np.array(y),
color=color,
size=0.5,
connected=True,
marker='sphere')
s.material.visible = False
animate.append(s)
s = ipv.pylab.plot_trisurf(-np.array(x),
np.array(z),
np.array(y),
color=color,
triangles=triangles)
animate.append(s)
ipv.animation_control(animate, interval=100)
ipv.xyzlim(-1, 1)
ipv.style.box_on()
ipv.style.axes_off()
return ipv.gcc()
def on_select_to_plot(self, b):
"""Call-back function for plotting a 3D visualisaiton of the segmentation"""
self.out.clear_output()
image = skimage.io.imread(self.folders.cur_dir.as_posix() + '/' +
self.folders.file_list.value[0],
plugin='tifffile')
image2 = skimage.io.imread(
self.folders.cur_dir.as_posix() + '/' +
os.path.splitext(self.folders.file_list.value[0])[0] +
'_label.tif',
plugin='tifffile')
image3 = skimage.io.imread(
self.folders.cur_dir.as_posix() + '/' +
os.path.splitext(self.folders.file_list.value[0])[0] +
'_region.tif',
plugin='tifffile')
scalez = 1024 / (int(self.scalingfactor.value))
xy_extent = [0, 1024]
#create ipyvolume figure
with self.out:
ipv.figure()
self.volume_image = ipv.volshow(
image[0, :, :, :, 1],
extent=[xy_extent, xy_extent, [-scalez, scalez]],
level=[0.3, 0.2, 0.2],
opacity=[0.2, 0, 0],
controls=False)
self.volume_seg = ipv.plot_isosurface(
np.swapaxes(image2 > 0, 0, 2),
level=0.5,
controls=False,
color='green',
extent=[xy_extent, xy_extent, [-scalez, scalez]])
self.volume_reg = ipv.plot_isosurface(
np.swapaxes(image3 > 0, 0, 2),
level=0.5,
controls=False,
color='blue',
extent=[xy_extent, xy_extent, [-scalez, scalez]])
self.volume_reg.brightness = 10
self.volume_image.brightness = 10
self.volume_image.opacity = 100
ipv.xyzlim(0, 1024)
ipv.zlim(-500, 500)
ipv.style.background_color('white')
minval_data = ipw.IntSlider(min=0,
max=255,
value=255,
description='min val')
maxval_data = ipw.IntSlider(min=0,
max=255,
value=255,
description='max val')
brightness_data = ipw.FloatSlider(min=0,
max=100,
value=7.0,
description='brightness')
opacity_data = ipw.FloatSlider(min=0,
max=100,
value=7.0,
description='opacity')
level_data = ipw.FloatSlider(min=0,
max=1,
value=0.3,
step=0.01,
description='level')
levelwidth_data = ipw.FloatSlider(min=0,
max=1,
value=0.1,
step=0.01,
description='level width')
color = ColorPicker(description='Segmentation color')
color2 = ColorPicker(description='Segmentation color')
visible_seg = ipw.Checkbox()
visible_reg = ipw.Checkbox()
jslink((self.volume_image, 'show_min'), (minval_data, 'value'))
jslink((self.volume_image, 'show_max'), (maxval_data, 'value'))
jslink((self.volume_image, 'brightness'),
(brightness_data, 'value'))
jslink((self.volume_image.tf, 'opacity1'), (opacity_data, 'value'))
jslink((self.volume_image.tf, 'level1'), (level_data, 'value'))
jslink((self.volume_image.tf, 'width1'),
(levelwidth_data, 'value'))
jslink((self.volume_seg, 'color'), (color, 'value'))
jslink((self.volume_reg, 'color'), (color2, 'value'))
jslink((self.volume_seg, 'visible'), (visible_seg, 'value'))
jslink((self.volume_reg, 'visible'), (visible_reg, 'value'))
ipv.show()
image_controls = HBox([
VBox([minval_data, maxval_data]),
VBox([
brightness_data, opacity_data, level_data, levelwidth_data
])
])
display(
VBox([
HBox([color, visible_seg]),
HBox([color2, visible_reg]), image_controls
]))
def animate_in_space(
position_interpolator,
n_step=200,
show_detector_pointing=False,
show_earth=True,
show_sun=False,
show_moon=False,
background_color="#01000F",
detector_scaling_factor=20000.0,
show_stars=False,
show_inactive=False,
earth_time="night",
realistic=True,
interval=200,
):
"""
Animiate fermi in Space!
:param position_interpolator:
:param n_step:
:param show_detector_pointing:
:param show_earth:
:param show_sun:
:param show_moon:
:param background_color:
:param detector_scaling_factor:
:param show_stars:
:returns:
:rtype:
"""
fig = ipv.figure()
ipv.pylab.style.box_off()
ipv.pylab.style.axes_off()
ipv.pylab.style.set_style_dark()
ipv.pylab.style.background_color(background_color)
tmin, tmax = position_interpolator.minmax_time()
time = np.linspace(tmin, tmax, n_step)
artists = []
distances = [15000]
if show_earth:
astro_times = [position_interpolator.astro_time(t) for t in time]
earth = Earth(
earth_time=earth_time, realistic=realistic, astro_time=astro_times,
)
tmp = earth.plot()
if realistic:
artists.append(tmp)
if show_sun:
xs = []
ys = []
zs = []
for t in time:
sun_pos = position_interpolator.sun_position(t)
x, y, z = sun_pos.cartesian.xyz.to("km").value
xs.append(x)
ys.append(y)
zs.append(z)
sol = Sol(np.array(xs), np.array(ys), np.array(zs))
distances.append(compute_distance(x, y, z, sol.radius))
artists.append(sol.plot())
if show_moon:
xs = []
ys = []
zs = []
for t in time:
moon_pos = position_interpolator.moon_position(t)
x, y, z = moon_pos.cartesian.xyz.to("km").value
xs.append(x)
ys.append(y)
zs.append(z)
moon = Moon(np.array(xs), np.array(ys), np.array(zs))
distances.append(compute_distance(x, y, z, moon.radius))
artists.append(moon.plot())
# now get fermi position
sxs = []
sys = []
szs = []
x_off = []
y_off = []
z_off = []
if show_detector_pointing:
distances.append(detector_scaling_factor)
gbm = GBM(
position_interpolator.quaternion(tmin), position_interpolator.sc_pos(tmin),
)
dets_xo = {}
dets_yo = {}
dets_zo = {}
dets_xp = {}
dets_yp = {}
dets_zp = {}
for k, _ in gbm.detectors.items():
dets_xo[k] = []
dets_yo[k] = []
dets_zo[k] = []
dets_xp[k] = []
dets_yp[k] = []
dets_zp[k] = []
for t in time:
sx, sy, sz = position_interpolator.sc_pos(t)
sxs.append(sx)
sys.append(sy)
szs.append(sz)
if not position_interpolator.is_fermi_active(t):
x_off.append(sx)
y_off.append(sy)
z_off.append(sz)
if show_detector_pointing:
gbm.set_quaternion(position_interpolator.quaternion(t))
for k, v in gbm.detectors.items():
x, y, z = v.center_icrs.cartesian.xyz.value * max(distances)
dets_xo[k].append(sx)
dets_yo[k].append(sy)
dets_zo[k].append(sz)
dets_xp[k].append(sx + x)
dets_yp[k].append(sy + y)
dets_zp[k].append(sz + z)
if show_detector_pointing:
for k, v in gbm.detectors.items():
dets_xo[k] = np.array(dets_xo[k])
dets_yo[k] = np.array(dets_yo[k])
dets_zo[k] = np.array(dets_zo[k])
dets_xp[k] = np.array(dets_xp[k])
dets_yp[k] = np.array(dets_yp[k])
dets_zp[k] = np.array(dets_zp[k])
color = _det_colors[k]
cone = Cone(
dets_xo[k],
dets_yo[k],
dets_zo[k],
dets_xp[k],
dets_yp[k],
dets_zp[k],
_open_angle,
)
artists.append(cone.plot(color=color))
# artists.append(ipv.pylab.plot(dets_x[k], dets_y[k], dets_z[k], color=color))
sxs = np.array(sxs)
sys = np.array(sys)
szs = np.array(szs)
if show_inactive:
ipv.pylab.scatter(
np.array(x_off),
np.array(y_off),
np.array(z_off),
color="#DC1212",
alpha=0.5,
marke="circle_2d",
size=1,
)
# fermi = FermiPoint(sxs, sys, szs)
# artists.append(fermi.plot())
fermi_real = Fermi(
position_interpolator.quaternion(time),
sc_pos=position_interpolator.sc_pos(time),
transform_to_space=True,
)
artists.extend(fermi_real.plot_fermi_ipy())
if show_stars:
sf = StarField(n_stars=200, distance=max(distances) - 2)
sf.plot()
ipv.xyzlim(max(distances))
ipv.animation_control(artists, interval=interval)
ipv.show()
return fig
def plot_in_space(
position_interpolator,
time,
show_detector_pointing=False,
show_earth=True,
show_sun=False,
show_moon=False,
background_color="#01000F",
detector_scaling_factor=20000.0,
show_stars=False,
show_orbit=True,
realistic=True,
earth_time="night",
sky_points=None,
min_distance=8000,
):
"""
Plot Fermi in Space!
:param position_interpolator:
:param time:
:param show_detector_pointing:
:param show_earth:
:param show_sun:
:param show_moon:
:param background_color:
:param detector_scaling_factor:
:returns:
:rtype:
"""
fig = ipv.figure(width=800, height=600)
ipv.pylab.style.box_off()
ipv.pylab.style.axes_off()
ipv.pylab.style.set_style_dark()
ipv.pylab.style.background_color(background_color)
distances = [min_distance]
if sky_points is not None:
sky_points = np.atleast_1d(sky_points)
if show_orbit:
tmin, tmax = position_interpolator.minmax_time()
tt = np.linspace(tmin, tmax, 500)
sc_pos = position_interpolator.sc_pos(tt)
ipv.plot(sc_pos[:, 0], sc_pos[:, 1], sc_pos[:, 2], lw=0.5)
if show_earth:
earth = Earth(
earth_time=earth_time,
realistic=realistic,
astro_time=position_interpolator.astro_time(time),
)
earth.plot()
if show_sun:
sun_pos = position_interpolator.sun_position(time)
x, y, z = sun_pos.cartesian.xyz.to("km").value
sol = Sol(x, y, z)
distances.append(compute_distance(x, y, z, sol.radius))
sol.plot()
if show_moon:
moon_pos = position_interpolator.moon_position(time)
x, y, z = moon_pos.cartesian.xyz.to("km").value
moon = Moon(x, y, z, realistic=True)
distances.append(compute_distance(x, y, z, moon.radius))
moon.plot()
# now get fermi position
sx, sy, sz = position_interpolator.sc_pos(time)
fermi_real = Fermi(
position_interpolator.quaternion(time),
sc_pos=position_interpolator.sc_pos(time),
transform_to_space=True,
)
fermi_real.plot_fermi_ipy()
if show_detector_pointing:
distances.append(detector_scaling_factor)
gbm = GBM(
position_interpolator.quaternion(time), position_interpolator.sc_pos(time),
)
for k, v in gbm.detectors.items():
x, y, z = v.center_icrs.cartesian.xyz.value * max(distances)
# x_line = np.array([sx, sx + x])
# y_line = np.array([sy, sy + y])
# z_line = np.array([sz, sz + z])
color = _det_colors[k]
cone = Cone(sx, sy, sz, sx + x, sy + y, sz + z, _open_angle)
cone.plot(color=color)
# ipv.pylab.plot(x_line, y_line, z_line, color=color)
if sky_points is not None:
for sp in sky_points:
sp.plot(sx, sy, sz, max(distances))
# distances.append(sp.distance)
if show_stars:
sf = StarField(n_stars=100, distance=max(distances) - 2)
sf.plot()
# move the camera here
fig.camera.position = tuple(
position_interpolator.sc_pos(time)
/ np.linalg.norm(position_interpolator.sc_pos(time))
)
ipv.xyzlim(max(distances))
ipv.show()
return fig
def display(
self,
earth_time="day",
obs_time="2010-01-01T00:00:00",
names=None,
size=10,
color="yellow",
):
fig = ipv.figure()
ipv.pylab.style.box_off()
ipv.pylab.style.axes_off()
ipv.pylab.style.set_style_dark()
ipv.pylab.style.background_color("black")
tt = atime.Time(obs_time)
earth = Earth(earth_time=earth_time, realistic=True, astro_time=tt,)
earth.plot()
x = []
y = []
z = []
distances = []
for name, sat in self._satellites.items():
add_sat = False
if names is not None:
if name in names:
add_sat = True
else:
add_sat = True
if add_sat:
x.append(sat.xyz[0])
y.append(sat.xyz[1])
z.append(sat.xyz[2])
distances.append(sat.true_alt)
ipv.pylab.scatter(
np.array(x),
np.array(y),
np.array(z),
marker="sphere",
color=color,
size=size,
)
ipv.xyzlim(max(distances))
ipv.show()
return fig
import ipyvolume import ipyvolume as ipv import vaex ds = vaex.example() N = 1000 ipv.figure() quiver = ipv.scatter(ds.data.x[:N], ds.data.y[:N], ds.data.z[:N]) ipv.xyzlim(-30,30) ipv.show()
