def plot_mesh(value_mesh_list, w1_mesh, w2_mesh, save, show_box, show_axes): ipv.clear() figs = [] for mesh in value_mesh_list: fig = ipv.pylab.figure() fig.camera.up = (0, 0, 1) fig.camera.position = (-2, 1, -0.5) fig.camera_control = "trackball" if not show_axes: ipv.style.box_off() else: ipv.xlabel("w1") ipv.ylabel("w2") ipv.zlabel("f_lambda") if not show_box: ipv.pylab.style.axes_off() ipv.pylab.zlim(mesh.min(), mesh.max()) ptp = (mesh - mesh.min()).ptp() col = [] for m in mesh: znorm = (m - m.min()) / (m.max() - m.min() + 1e-8) color = np.asarray([[interpolate(darker(colors_alpha[0], 1.5 * x + 0.75), darker(colors_alpha[1], 1.5 * (1 - x) + 0.75), x) for x in y] for y in znorm]) col.append(color) color = np.array(col) surf = ipv.plot_surface(w1_mesh, w2_mesh, mesh, color=color[..., :3]) ipv.animation_control(surf, interval=400) figs.append(fig) ipv.show() if save: ipv.save(f'renders/{datetime.datetime.now().strftime("%m%d-%H%M")}.html', offline=True) return figs
def ipv_animate(particles, velocities, particleColors, particleSizes, paramRanges): nTimesteps = particles.shape[0] nParticles = particles.shape[1] # determine quiver sizes and colors veloQuiverSizes = np.zeros((nTimesteps, nParticles, 1)) for iTimestep in range(nTimesteps): veloQuiverSizes[iTimestep, :, 0] = np.linalg.norm(velocities[iTimestep, :, :], axis=1) veloQuiverSizes = np.clip(veloQuiverSizes, 0, 2) quiverColors = np.ones( (nTimesteps, nParticles, 4)) * .8 #veloQuiverSizes/3 ipv.figure() #bPlots = ipv.scatter( best[:, :, 0], best[:, :, 1], best[:, :, 2], marker = 'sphere', size=2, color = 'red' ) pPlots = ipv.scatter(particles[:, :, 0], particles[:, :, 1], particles[:, :, 2], marker='sphere', size=particleSizes, color=particleColors) #qvPlots = ipv.quiver( particles[:, :, 0], particles[:, :, 1], particles[:, :, 2], velocities[:, :, 0], velocities[:, :, 1], velocities[:, :, 2], size=veloQuiverSizes[:,:,0]*3, color=quiverColors) ipv.animation_control([pPlots], interval=600) ipv.xlim(paramRanges[0][1], paramRanges[0][2]) ipv.ylim(paramRanges[1][1], paramRanges[1][2]) ipv.zlim(paramRanges[2][1], paramRanges[2][2]) 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 particleSimulate(num_particles, box_size, total_time, time_step, particle_radius, grav=False, save=False): print("Running simulation...") """Run the simulation and extract the x,y,z coordinates to plot the particle's path""" particle_list = initialize_particles(num_particles, box_size, time_step, grav) #Generate starting points x = np.zeros([total_time, num_particles, 1]) y = np.zeros([total_time, num_particles, 1]) z = np.zeros([total_time, num_particles, 1]) time = 0 #print(str(tot_eng(particle_list))) #Used to track the total energy of the particles while time < total_time: #Loop through iterations of particle movements #Check to see if bouncing occurs isbounce(particle_list, particle_radius, time_step) for i in range(len(particle_list)): particle_list[i].pos_update(time_step) #Update position x[time, i] = particle_list[i].pos[0] y[time, i] = particle_list[i].pos[1] z[time, i] = particle_list[i].pos[2] time += 1 if (time / total_time) * 100 % 10 == 0: print(str(time / total_time * 100) + "% complete") """Plot the results of all of the particle movements""" colors = [] for i in range(num_particles): colors.append( [np.random.random(), np.random.random(), np.random.random()]) ipv.figure() s = ipv.scatter(x, z, y, color=colors, size=7, marker="sphere") ipv.animation_control(s, interval=1) ipv.xlim(-1, box_size + 1) ipv.ylim(-1, box_size + 1) ipv.zlim(-1, box_size + 1) ipv.style.axes_off() ipv.show() if save == True: print("Saving the video of the simulation in the current directory...") ipv.save('./particle_sim.html')
def brain(draw=True, show=True, fiducial=True, flat=True, inflated=True, subject='S1', interval=1000, uv=True, color=None): import ipyvolume as ipv try: import cortex except: warnings.warn("it seems pycortex is not installed, which is needed for this example") raise xlist, ylist, zlist = [], [], [] polys_list = [] def add(pts, polys): xlist.append(pts[:,0]) ylist.append(pts[:,1]) zlist.append(pts[:,2]) polys_list.append(polys) def n(x): return (x - x.min()) / x.ptp() if fiducial or color is True: pts, polys = cortex.db.get_surf('S1', 'fiducial', merge=True) x, y, z = pts.T r = n(x) g = n(y) b = n(z) if color is True: color = np.array([r,g,b]).T.copy() else: color = None if fiducial: add(pts, polys) else: if color is False: color = None if inflated: add(*cortex.db.get_surf('S1', 'inflated', merge=True, nudge=True)) u = v = None if flat or uv: pts, polys = cortex.db.get_surf('S1', 'flat', merge=True, nudge=True) x, y, z = pts.T u = n(x) v = n(y) if flat: add(pts, polys) polys_list.sort(key=lambda x: len(x)) polys = polys_list[0] if draw: if color is None: mesh = ipv.plot_trisurf(xlist, ylist, zlist, polys, u=u, v=v) else: mesh = ipv.plot_trisurf(xlist, ylist, zlist, polys, color=color, u=u, v=v) if show: if len(x) > 1: ipv.animation_control(mesh, interval=interval) ipv.squarelim() ipv.show() return mesh else: return xlist, ylist, zlist, polys
def aniplot(folder, frame): if frame is None: frame = len( fnmatch.filter(os.listdir('/u/yali/' + folder + '/test/output'), '*.hdf5')) x = [] y = [] z = [] vx = [] vy = [] vz = [] v = [] for i in np.arange(frame): fname = str(format(i, '03d')) f = h5py.File("/u/yali/" + folder + "/test/output/snapshot_" + fname + ".hdf5", 'r') # Read-only access to the file #intE = [] #density = [] x.append(f['PartType0']['Coordinates'][:, 0]) y.append(f['PartType0']['Coordinates'][:, 1]) z.append(f['PartType0']['Coordinates'][:, 2]) #intE.append(f['Partype0']['InternalEnergy'][:]) vx.append(f['PartType0']['Velocities'][:, 0]) vy.append(f['PartType0']['Velocities'][:, 1]) vz.append(f['PartType0']['Velocities'][:, 2]) #density.append(f['PartType0']['Density'][:]) # and normalize x = np.array(x) y = np.array(y) z = np.array(z) vx = np.array(vx) vy = np.array(vy) vz = np.array(vz) v = np.array(np.sqrt(vx**2 + vy**2 + vz**2)) v -= v.min() v /= v.max() # map the normalized values to rgba colors cmap = cm.Reds colors = np.array([cmap(k) for k in v]) colors.shape # plot animation fig = ipv.figure() ipv.style.use('dark') # use just rgb colors, not rgba quiver = ipv.quiver(x, y, z, vx, vy, vz, size=5, color=colors[:, :, :3]) # create the animation widgets/slider ipv.animation_control(quiver, interval=500) ipv.show()
def animate_rollout_quiver(positions, vector): """Takes positions & vector(acceleration or velocity) and renders 3d quiver animation""" num_steps = len(positions) num_particles = positions[0].size(0) data = np.zeros((6, num_steps, num_particles)) for s in range(num_steps): pos = positions[s].numpy() v = vector[s].numpy() for i in range(3): data[i][s] = pos[:, i] data[i + 3][s] = v[:, i] fig = ipv.figure() color = [(1, 0, 0) if i < 64 else (0, 0, 1) for i in range(len(pos))] s = ipv.quiver(*data, color=color, size=5) ipv.animation_control(s) ipv.show()
def animate_rollout(rollout): """Takes rollout positions and renders a 3d animation""" x, y, z = [], [], [] for i, step in enumerate(rollout): pos = step.numpy() x.append(pos[:, 0]) y.append(pos[:, 1]) z.append(pos[:, 2]) fig = ipv.figure() color = [(1, 0, 0) if i < 64 else (0, 0, 1) for i in range(len(pos))] s = ipv.scatter(np.array(x), np.array(y), np.array(z), color=color, size=5, marker='sphere') ipv.animation_control(s) ipv.show()
def plot_particle_learning(nTimesteps, nParticles, testData_pDF, bestParamIndex, predictionHistory): nTestSamples = testData_pDF.shape[0] colorStack = np.ones( (nTimesteps, nParticles, nTestSamples, 4)) * [1, 0, 0, 1] for iTimestep in range(nTimesteps): for iParticle in range(nParticles): colorStack[iTimestep, iParticle, :, 0] = predictionHistory[iTimestep, iParticle, :] nTestSamples = testData_pDF.shape[0] testDataRepeated = np.zeros((nTimesteps, nParticles, nTestSamples, 3)) xNP = testData_pDF['x'].values yNP = testData_pDF['y'].values zNP = testData_pDF['z'].values for iTimestep in range(nTimesteps): for iParticle in range(nParticles): testDataRepeated[iTimestep, iParticle, :, 0] = xNP testDataRepeated[iTimestep, iParticle, :, 1] = yNP testDataRepeated[iTimestep, iParticle, :, 2] = zNP ipv.figure() nTimestepsToPlot = bestParamIndex[0] + 1 bestParticle = bestParamIndex[1] predictionPlots = ipv.scatter(testDataRepeated[0:nTimestepsToPlot, bestParticle, :, 0], testDataRepeated[0:nTimestepsToPlot, bestParticle, :, 1], testDataRepeated[0:nTimestepsToPlot, bestParticle, :, 2], color=colorStack[0:nTimestepsToPlot, bestParticle, :, :], marker='sphere', size=.25) ipv.animation_control([predictionPlots], interval=600) ipv.pylab.squarelim() ipv.show() '''
def hpo_animate(particles, particleSizes, particleColors, paramRanges, nTimesteps=1): nParticles = particles.shape[1] colorStack = np.ones((nTimesteps, nTimesteps * nParticles, 4)) * .9 colorStackLines = np.ones((nTimesteps, nTimesteps * nParticles, 4)) * .5 for iTimestep in range(nTimesteps): colorStack[iTimestep, :, 0:3] = numpy.matlib.repmat(particleColors[0, :, :], nTimesteps, 1) colorStackLines[iTimestep, :, 0:3] = numpy.matlib.repmat(particleColors[0, :, :], nTimesteps, 1) colorStackLines[iTimestep, :, 3] = .6 # alpha ipv.figure() pplot = ipv.scatter(particles[0:nTimesteps, :, 0], particles[0:nTimesteps, :, 1], particles[0:nTimesteps, :, 2], marker='sphere', size=particleSizes, color=colorStack[:, :, :]) for iParticle in range(nParticles): plines = ipv.plot(particles[0:nTimesteps, iParticle, 0], particles[0:nTimesteps, iParticle, 1], particles[0:nTimesteps, iParticle, 2], color=colorStackLines[:, iParticle, :]) ipv.animation_control([pplot], interval=600) ipv.xlim(paramRanges[0][1] - .5, paramRanges[0][2] + .5) ipv.ylim(paramRanges[1][1] - .1, paramRanges[1][2] + .1) ipv.zlim(paramRanges[2][1] - .1, paramRanges[2][2] + .1) ipv.show()
def __init__(self, brain): if brain.data['time'] is None: raise ValueError('Brain class instance does not have time data.') self._brain = brain time = brain.data['time'] time_idx = brain.data['time_idx'] overlays = tuple(brain.overlays.values()) control = ipv.animation_control(overlays, len(time), add=False, interval=500) slider = control.children[1] slider.readout = False slider.value = time_idx label = widgets.Label(self._get_label(time[time_idx])) # hadler for changing of selected time moment def slider_handler(change): k = brain.data['k'] b = brain.data['b'] lut = brain.data['lut'] time_idx_new = int(change.new) for v in brain.views: for h in brain.hemis: act_data = brain.data[h + '_array'][:, time_idx_new] smooth_mat = brain.data[h + '_smooth_mat'] act_data = smooth_mat.dot(act_data) act_data = k * act_data + b act_data = np.clip(act_data, 0, 1) act_color_new = lut(act_data) brain.overlays[h + '_' + v].color = act_color_new # change label value label.value = self._get_label(time[time_idx_new]) slider.observe(slider_handler, names='value') control = widgets.HBox((*control.children, label)) ipv.gcc().children += (control,)
def test_animation_control(): fig = ipv.figure() n_points = 3 n_frames = 4 ar = np.zeros(n_points) ar_frames = np.zeros((n_frames, n_points)) colors = np.zeros((n_points, 3)) colors_frames = np.zeros((n_frames, n_points, 3)) scalar = 2 s = ipv.scatter(x=scalar, y=scalar, z=scalar) with pytest.raises(ValueError): # no animation present slider = ipv.animation_control(s, add=False).children[1] s = ipv.scatter(x=ar, y=scalar, z=scalar) slider = ipv.animation_control(s, add=False).children[1] assert slider.max == n_points - 1 s = ipv.scatter(x=ar_frames, y=scalar, z=scalar) slider = ipv.animation_control(s, add=False).children[1] assert slider.max == n_frames - 1 s = ipv.scatter(x=scalar, y=scalar, z=scalar, color=colors_frames) slider = ipv.animation_control(s, add=False).children[1] assert slider.max == n_frames - 1 Nx, Ny = 10, 7 x = np.arange(Nx) y = np.arange(Ny) x, y = np.meshgrid(x, y) z = x + y m = ipv.plot_surface(x, y, z) with pytest.raises(ValueError): # no animation present slider = ipv.animation_control(m, add=False).children[1] z = [x + y * k for k in range(n_frames)] m = ipv.plot_surface(x, y, z) slider = ipv.animation_control(m, add=False).children[1] assert slider.max == n_frames - 1
def visualize_objects(self, train_idxs=None, test_idxs=None, max_time_steps=None, train_sim=False, test_sim=True, train_marker_size=4, test_marker_size=6): """ train_idxs - numpy array из индексов объектов (sat_id) тренировочной выборки, которые надо визуализировать. Если None - берем все объекты test_idxs - numpy array из индексов объектов (sat_id) тренировочной выборки, которые надо визуализировать. Если None - берем train_idxs max_time_steps - максимальное количество измерений для одного объекта (sat_id) train_sim - если False - используем реальные данные (колонки без приставки sim) test_sim - если False - используем реальные (предсказанные) данные (для этого в датафрейм нужно добавить приставки колонки с предсказаниями без приставки sim, как в трейне) """ ipv.clear() if train_idxs is None: train_idxs = np.array(self.train_data['sat_id'].unique()) if test_idxs is None: test_idxs = train_idxs if max_time_steps is None: max_time_steps_train = self.train_data.groupby( 'sat_id').count()['epoch'].max() max_time_steps_test = self.test_data.groupby( 'sat_id').count()['epoch'].max() max_time_steps = max(max_time_steps_train, max_time_steps_test) ## подготовка трейна и теста stream_train = self._prepare_stream('train', train_idxs, max_time_steps, train_sim) stream_test = self._prepare_stream('test', test_idxs, max_time_steps, test_sim) ## визуализация stream = np.dstack([stream_train[:, :, :], stream_test[:, :, :]]) selected = stream_train.shape[2] + test_idxs self.q = ipv.quiver(*stream[:, :, :], color="green", color_selected='red', size=train_marker_size, size_selected=test_marker_size, selected=selected) ## Чтобы можно было менять размеры и цвета size = FloatSlider(min=1, max=15, step=0.2) size_selected = FloatSlider(min=1, max=15, step=0.2) color = ColorPicker() color_selected = ColorPicker() jslink((self.q, 'size'), (size, 'value')) jslink((self.q, 'size_selected'), (size_selected, 'value')) jslink((self.q, 'color'), (color, 'value')) jslink((self.q, 'color_selected'), (color_selected, 'value')) # ipv.style.use('seaborn-darkgrid') ipv.animation_control(self.q, interval=75) ipv.show( [VBox([ipv.gcc(), size, size_selected, color, color_selected])])
def viz_swarm(swarm, paramLabels=False): swarmDF, particleHistory = viz_prep(swarm) particleHistoryCopy = copy.deepcopy(particleHistory) nParticles = swarm.nParticles nAnimationFrames = list( swarmDF['nEvals'])[0] # max( sortedBarHeightsDF['nEvals'] ) particleXYZ = np.zeros((nAnimationFrames, nParticles, 3)) lastKnownLocation = {} # TODO: bestIterationNTrees # particleSizes[ iFrame, iParticle ] = particleHistoryCopy[iParticle]['bestIterationNTrees'].pop(0).copy() for iFrame in range(nAnimationFrames): for iParticle in range(nParticles): if iParticle in particleHistoryCopy.keys(): # particle exists in the particleHistory and it has parameters for the current frame if len(particleHistoryCopy[iParticle]): particleXYZ[iFrame, iParticle, :] = particleHistoryCopy[ iParticle].pop(0).copy() lastKnownLocation[iParticle] = particleXYZ[ iFrame, iParticle, :].copy() else: # particle exists but it's params have all been popped off -- use its last known location if iParticle in lastKnownLocation.keys(): particleXYZ[iFrame, iParticle, :] = lastKnownLocation[ iParticle].copy() else: # particle does not exist in the particleHistory if iParticle in lastKnownLocation.keys(): # particle has no params in current frame, attempting to use last known location particleXYZ[ iFrame, iParticle, :] = lastKnownLocation[iParticle].copy() else: print('particle never ran should we even display it') assert (False) # using initial params #particleXYZ[iFrame, iParticle, : ] = initialParticleParams[iParticle].copy() #lastKnownLocation[iParticle] = particleXYZ[iFrame, iParticle, : ].copy() ipvFig = ipv.figure(width=ipvPlotWidth, height=ipvPlotHeight) scatterPlots = ipv.scatter(particleXYZ[:, :, 0], particleXYZ[:, :, 1], particleXYZ[:, :, 2], marker='sphere', size=5, color=swarm.particleColorStack) xyzLabelsButton = widgets.Button(description="x, y, z labels") paramNamesLabelsButton = widgets.Button(description="parameter labels") ipv.animation_control([scatterPlots], interval=400) ipv.xlim(swarm.paramRanges[0][1] - .5, swarm.paramRanges[0][2] + .5) ipv.ylim(swarm.paramRanges[1][1] - .1, swarm.paramRanges[1][2] + .1) ipv.zlim(swarm.paramRanges[2][1] - .1, swarm.paramRanges[2][2] + .1) container = ipv.gcc() container.layout.align_items = 'center' comboBox = append_label_buttons(swarm, ipvFig, container) display(comboBox)
%pylab inline import ipyvolume as ipv import ipyvolume.pylab as p3 import numpy as np import rebound from rebound import hash as h from astropy.io import ascii p3.clear() ##Location of npz files produced by other script loc="./" x=np.load(loc+'x.npz') y=np.load(loc+'y.npz') z=np.load(loc+'z.npz') s2=p3.plot(x['arr_0'], y['arr_0'], z['arr_0']) # s3=p3.plot(x['arr_0'][:, 1, :], y['arr_0'][:, 1, :], z['arr_0'][:, 1, :], color='red', size=0.3, alpha='0.5') ipv.pylab.xlim(-1,1) ipv.pylab.ylim(-1,1) ipv.pylab.zlim(-1,1) ipv.pylab.view(azimuth=None, elevation=-90, distance=1.5) p3.show() ipv.animation_control(s2)
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()
import ipyvolume as ipv import numpy as np import ipywidgets as widgets from ipyvolume.widgets import quickscatter from ipyvolume.widgets import Figure import numpy as np, pandas as pd np.random.seed(0) import seaborn as sns sns.set(style="white", color_codes=True) # In[74]: x = np.array(margin) y = np.array(gp) z = np.array(spread_to_const) # In[76]: ipv.figure() s = ipv.scatter(x, y, z, marker='sphere', size=2) ipv.pylab.xlabel('Margin') ipv.pylab.ylabel('GP') ipv.pylab.zlabel('Var to Const') ipv.animation_control(s) # shows controls for animation controls ipv.show()
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