def fgsm_attack(request): #标准化数据 input = ( (255 - np.array(eval(request.POST.get('inputs')), dtype=np.float32)) / 255.0).reshape(1, 28, 28, 1) X_adv = make_fgsm(sess, env, input, epochs=12, eps=0.02).tolist() # print(X_adv[0]) X_tmp = np.empty((10, 28, 28)) X_tmp[0] = np.squeeze(X_adv[0]) # print(X_tmp[0]) fig = plt.figure(figsize=(1, 1.2)) gs = gridspec.GridSpec(1, 1, wspace=0.05, hspace=0.05) ax = fig.add_subplot(gs[0, 0]) # 分别画子图 ax.imshow(X_tmp[0], cmap='gray', interpolation='none') # 展示预测错的对抗样本 ax.set_xticks([]) ax.set_yticks([]) plugins.connect(fig, plugins.MousePosition(fontsize=14)) # mpld3.show() os.makedirs('img', exist_ok=True) plt.savefig('img/fgsm_mnist.png') # return HttpResponse(json.dumps(X_adv)) # print(mpld3.fig_to_html(fig)) return HttpResponse(mpld3.fig_to_html(fig))
def mpld3_enable_notebook(): """Change the default plugins, enable ipython notebook mode and return mpld3 module.""" import mpld3 from mpld3 import plugins as plugs plugs.DEFAULT_PLUGINS = [plugs.Reset(), plugs.Zoom(), plugs.BoxZoom(), plugs.MousePosition()] mpld3.enable_notebook() return mpld3
def plot(request, title): fig = plt.figure(figsize=(4,4)) ax = plt.gca() if title == None: x = np.linspace(-2, 2, 20) y = x[:, None] X = np.zeros((20, 20, 4)) X[:, :, 0] = np.exp(- (x - 1) ** 2 - (y) ** 2) X[:, :, 1] = np.exp(- (x + 0.71) ** 2 - (y - 0.71) ** 2) X[:, :, 2] = np.exp(- (x + 0.71) ** 2 - (y + 0.71) ** 2) X[:, :, 3] = np.exp(-0.25 * (x ** 2 + y ** 2)) im = ax.imshow(X, extent=(10, 20, 10, 20), origin='lower', zorder=1, interpolation='nearest') fig.colorbar(im, ax=ax) ax.set_title('An Image', size=20) plugins.connect(fig, plugins.MousePosition(fontsize=14)) plot_string = mpld3.fig_to_html(fig, d3_url=None, mpld3_url=None, no_extras=False, template_type='general', figid=None, use_http=False) return HttpResponse(plot_string, status=200) else: plot_string = r.get('user_' + str(0) + '_plot_' + title) return HttpResponse(plot_string, status=200)
def draw_spectrum(spectrum, dummy=False): rmf = pf.open('rmf_62bands.fits') src_spectrum = spectrum[8].data E_min = rmf[3].data['E_min'] E_max = rmf[3].data['E_max'] msk = src_spectrum['RATE'] > 0. y = src_spectrum['RATE'] / (E_max - E_min) x = (E_max + E_min) dx = np.log10(np.e) * (E_max - E_min) / x x = np.log10(x) dy = src_spectrum['STAT_ERR'] / (E_max - E_min) dy = np.log10(np.e) * dy / y y = np.log10(y) fig, ax = plt.subplots(figsize=(4, 2.8)) ax.set_xlabel('log(E) keV') ax.set_ylabel('log(counts/s/keV)') ax.errorbar(x[msk], y[msk], yerr=dy[msk] * 0.5, xerr=dx[msk] * 0.5, fmt='o') #print (x,y,dy) plugins.connect(fig, plugins.MousePosition(fontsize=14)) return mpld3.fig_to_dict(fig)
def graphic(request, fun, iterations, lowerbound, upperbound): import matplotlib.pyplot as plt, mpld3 import matplotlib.figure as fg import matplotlib import mpld3 from mpld3 import plugins, utils from matplotlib.patches import Polygon # Ver atributos de un objeto # from pprint import pprint # pprint(vars(fig)) #limite inferior a=float(lowerbound) #limite superior b=float(upperbound) fig, ax = plt.subplots(figsize=(11,6.5)) x = np.linspace(a, b, 1000) #fig.subplots_adjust(right=2,top=1.1) #paso de la funcion a graficar y=eval(fun) #iteraciones n=int(iterations) # Propiedades de la linea que es definida por la funcion ax.plot(x,y, lw=5, alpha=0.7) # Add grid to figure ax.grid(True, alpha=0.3) # Dibujar area bajo la curva ix = np.linspace(a, b) iy = ix verts = [(a, 0)] + list(zip(x, y)) + [(b, 0)] poly = Polygon(verts, facecolor='0.8', edgecolor='0.5') ax.add_patch(poly) #muestra la posicion del puntero en la grafica plugins.connect(fig, plugins.MousePosition(fontsize=14)) # For transform it to HTML g = mpld3.fig_to_html(fig) return HttpResponse(g)
def create_plot(): fig, ax = plt.subplots(2, 2, sharex='col', sharey='row') fig.subplots_adjust(hspace=0.3) for i in range(2): for j in range(2): txt = '({i}, {j})'.format(i=i, j=j) ax[i, j].set_title(txt, size=14) ax[i, j].text(0.5, 0.5, txt, size=40, ha='center') ax[i, j].grid(True, color='lightgray') ax[i, j].set_xlabel('xlabel') ax[i, j].set_ylabel('ylabel') plugins.connect(fig, plugins.MousePosition()) return fig
def produceHeroDistribution(self, hero_vector, hero_count_in_features): sum_vector = np.sum(hero_vector, axis=0) dire_side = sum_vector[:hero_count_in_features] radiant_side = sum_vector[hero_count_in_features:] hero_sum = np.add(dire_side, radiant_side) x = list(range(1, len(hero_sum) + 1)) self.hero_distribution = hero_sum plt.bar(x, hero_sum, align="center") plt.xlabel("HeroID") plt.ylabel("Frequency") plt.title("Hero pick distribution") fig = plt.gcf() tooltip = plugins.MousePosition(fontsize=14) plugins.connect(fig, tooltip) self.chart1 = mpld3.fig_to_dict(fig)
def make_html_plot_for_file(filename, my_title): my_fontsize = 20 # read in csv file if os.stat(filename).st_size: data = np.genfromtxt(filename, delimiter=',') else: # empty data file data = np.zeros([2, 2]) if len(data.shape) == 1: return "<h2> " + my_title + " has no data </h2>" x = data[:, 0] fig, ax = plt.subplots(figsize=(10, 5)) for k in range(1, data.shape[1]): y = data[:, k] # sort data x_sorted = [x1 for (x1, y1) in sorted(zip(x, y))] y_sorted = [y1 for (x1, y1) in sorted(zip(x, y))] lines = ax.plot(x_sorted, y_sorted, '.-', markersize=15, label='ion ' + str(k - 1)) plt.legend(fontsize=my_fontsize, loc='best') plt.title(my_title, fontsize=my_fontsize) ax.grid() plt.xticks(fontsize=my_fontsize) plt.yticks(fontsize=my_fontsize) plt.xlim([np.min(x), np.max(x)]) #90% of the time that this function takes is taken up after this line plugins.clear(fig) plugins.connect(fig, plugins.Reset(), plugins.BoxZoom(), plugins.Zoom(enabled=True), plugins.MousePosition(fontsize=my_fontsize)) java_txt = mpld3.fig_to_html(fig) plt.close() return java_txt
def prepare_image_data(image_data): im = np.array(image_data, dtype=np.uint8) # Create figure and axes fig,ax = plt.subplots(1) # Adjust the width = 15 height = width * image_data.size[1] / image_data.size[0] fig.set_size_inches(width, int(height), forward=True) plugins.connect(fig, plugins.MousePosition(fontsize=14)) mpld3.enable_notebook() # Display the image ax.imshow(im) return ax
def draw_fig(image_array, image_header, catalog=None, plot=False): from astropy import wcs from astropy.wcs import WCS from astropy import units as u import astropy.coordinates as coord fig, (ax) = plt.subplots(1, 1, figsize=(4, 3), subplot_kw={'projection': WCS(image_header)}) im = ax.imshow(image_array, origin='lower', zorder=1, interpolation='none', aspect='equal') if catalog is not None: lon = coord.Angle(catalog['RA_FIN'] * u.deg) lat = coord.Angle(catalog['DEC_FIN'] * u.deg) w = wcs.WCS(image_header) pixcrd = w.wcs_world2pix(np.column_stack((lon, lat)), 1) ax.plot(pixcrd[:, 0], pixcrd[:, 1], 'o', mfc='none') for ID in xrange(catalog.size): ax.annotate('%s' % catalog[ID]['NAME'], xy=(pixcrd[:, 0][ID], pixcrd[:, 1][ID]), color='white') ax.set_xlabel('RA') ax.set_ylabel('DEC') fig.colorbar(im, ax=ax) if plot == True: plt.show() plugins.connect(fig, plugins.MousePosition(fontsize=14)) return mpld3.fig_to_dict(fig)
def about(): fig, ax = plt.subplots() x = np.linspace(-2, 2, 20) y = x[:, None] X = np.zeros((20, 20, 4)) X[:, :, 0] = np.exp(-(x - 1)**2 - (y)**2) X[:, :, 1] = np.exp(-(x + 0.71)**2 - (y - 0.71)**2) X[:, :, 2] = np.exp(-(x + 0.71)**2 - (y + 0.71)**2) X[:, :, 3] = np.exp(-0.25 * (x**2 + y**2)) im = ax.imshow(X, extent=(10, 20, 10, 20), origin='lower', zorder=1, interpolation='nearest') fig.colorbar(im, ax=ax) ax.set_title('An Image', size=20) plugins.connect(fig, plugins.MousePosition(fontsize=14)) return render_template('about.html', plot=mpld3.fig_to_html(fig))
def draw_dummy(dummy=True): fig, ax = plt.subplots(figsize=(4, 3)) if dummy == True: x = np.linspace(-2, 2, 200) y = x[:, None] image = np.zeros((200, 200, 4)) image[:, :, 0] = np.exp(-(x - 1)**2 - (y)**2) image[:, :, 1] = np.exp(-(x + 0.71)**2 - (y - 0.71)**2) image[:, :, 2] = np.exp(-(x + 0.71)**2 - (y + 0.71)**2) image[:, :, 3] = np.exp(-0.25 * (x**2 + y**2)) im = ax.imshow(image, origin='lower', zorder=1, interpolation='none', aspect='equal') fig.colorbar(im, ax=ax) plugins.connect(fig, plugins.MousePosition(fontsize=14)) return mpld3.fig_to_dict(fig)
def plot_signal(sample_rate, samples, size): [width, height] = size N = len(samples) fig = plt.figure() fig.set_figwidth(width) fig.set_figheight(height) samples = signal.decimate(samples, 300, ftype='fir') T = N / sample_rate dT = T / len(samples) time = np.arange(0, len(samples), dtype=float) time = np.multiply(time, dT) #labels = ["Point {0}".format(i) for i in range(len(samples))] #tooltip = plugins.PointLabelTooltip(samples) plt.plot(time, samples) plt.title('Sygnał') plt.xlabel('Czas [s]') plt.ylabel('Ciśnienie [Pa]') plt.grid() plt.tight_layout() #plugins.connect(fig, plugins.PointHTMLTooltip(samples)) plugins.connect(fig, plugins.MousePosition()) return mpld3.fig_to_html(fig, template_type="general")
def render(self, idf, filename='output.html'): progress_inst = helpers.Progress(idf.opt) self.progress = progress_inst.progress if idf.opt['outputFilename']: filename = idf.opt['outputFilename'] if idf.opt['outputAs'] == 'html': # write matplotlib/d3 plots to html file import matplotlib import matplotlib.pyplot as plt, mpld3 import matplotlib.axes from mpld3 import plugins from jinja2 import Environment, FileSystemLoader elif idf.opt['outputAs'] in ['pdf', 'interactive', 'tikz']: # show plots in separate matplotlib windows import matplotlib if idf.opt['outputAs'] == 'pdf': from matplotlib.backends.backend_pdf import PdfPages pp = PdfPages(filename) import matplotlib.pyplot as plt import matplotlib.axes else: print("No proper output method given. Not plotting.") return font_size = 10 if idf.opt['outputAs'] in ['pdf', 'tikz']: if idf.opt['plotPerJoint']: font_size = 30 else: font_size = 12 matplotlib.rcParams.update({'font.size': font_size}) matplotlib.rcParams.update({'axes.labelsize': font_size - 5}) matplotlib.rcParams.update({'axes.linewidth': font_size / 15.}) matplotlib.rcParams.update({'axes.titlesize': font_size - 2}) matplotlib.rcParams.update({'legend.fontsize': font_size - 2}) matplotlib.rcParams.update({'xtick.labelsize': font_size - 5}) matplotlib.rcParams.update({'ytick.labelsize': font_size - 5}) matplotlib.rcParams.update({'lines.linewidth': font_size / 15.}) matplotlib.rcParams.update({'patch.linewidth': font_size / 15.}) matplotlib.rcParams.update({'grid.linewidth': font_size / 20.}) # skip some samples so graphs don't get too large/detailed TODO: change skip so that some # maximum number of points is plotted (determined by screen etc.) skip = 5 #create figures and plots figures = list() for ds in self.progress(range(len(self.datasets))): group = self.datasets[ds] fig, axes = plt.subplots(len(group['dataset']), sharex=True, sharey=True) # scale unified scaling figures to same ranges and add some margin if group['unified_scaling']: ymin = 0 ymax = 0 for i in range(len(group['dataset'])): ymin = np.min( (np.min(group['dataset'][i]['data']), ymin)) * 1.05 ymax = np.max( (np.max(group['dataset'][i]['data']), ymax)) * 1.05 #plot each group of data for d_i in range(len(group['dataset'])): d = group['dataset'][d_i] if not issubclass(type(axes), matplotlib.axes.SubplotBase): ax = axes[d_i] else: ax = axes axes = [axes] if idf.opt['outputAs'] != 'tikz': ax.set_title(d['title']) if group['unified_scaling']: ax.set_ylim([ymin, ymax]) for data_i in range(0, len(d['data'])): if len(d['data'][data_i].shape) > 1: #data matrices for i in range(0, d['data'][data_i].shape[1]): l = group['labels'][i] if data_i == 0 else '' if i < 6 and 'contains_base' in group and group[ 'contains_base']: ls = 'dashed' else: ls = '-' dashes = () # type: Tuple if idf.opt['plotErrors']: if idf.opt['plotPrioriTorques']: n = 3 else: n = 2 if i == n: ls = 'dashed' dashes = (3, 0.5) ax.plot(d['time'][::skip], d['data'][data_i][::skip, i], label=l, color=colors[i], alpha=1 - (data_i / 2.0), linestyle=ls, dashes=dashes) else: #data vector ax.plot(d['time'][::skip], d['data'][data_i][::skip], label=group['labels'][d_i], color=colors[0], alpha=1 - (data_i / 2.0)) ax.grid(which='both', linestyle="dotted", alpha=0.8) if 'y_label' in group: ax.set_ylabel(group['y_label']) if idf.opt['outputAs'] != 'tikz': ax.set_xlabel("Time (s)") plt.setp([a.get_xticklabels() for a in axes[:-1]], visible=False) #plt.setp([a.get_yticklabels() for a in axes], fontsize=8) if idf.opt['plotLegend']: handles, labels = ax.get_legend_handles_labels() if idf.opt['outputAs'] == 'html': #TODO: show legend properly (see mpld3 bug #274) #leg = fig.legend(handles, labels, loc='upper right', fancybox=True, fontsize=10, title='') leg = axes[0].legend(handles, labels, loc='upper right', fancybox=True, fontsize=10, title='', prop={'size': 8}) else: leg = plt.figlegend(handles, labels, loc='upper right', fancybox=True, fontsize=font_size, title='', prop={'size': font_size - 3}) leg.draggable() fig.subplots_adjust(hspace=2) fig.set_tight_layout(True) if idf.opt['outputAs'] == 'html': plugins.clear(fig) plugins.connect(fig, plugins.Reset(), plugins.BoxZoom(), plugins.Zoom(enabled=False), plugins.MousePosition(fontsize=14, fmt=".5g")) figures.append(mpld3.fig_to_html(fig)) elif idf.opt['outputAs'] == 'interactive': plt.show(block=False) elif idf.opt['outputAs'] == 'pdf': pp.savefig(plt.gcf()) elif idf.opt['outputAs'] == 'tikz': from matplotlib2tikz import save as tikz_save tikz_save('{}_{}_{}.tex'.format( filename, group['dataset'][0]['title'].replace('_', '-'), ds // idf.model.num_dofs), figureheight='\\figureheight', figurewidth='\\figurewidth', show_info=False) if idf.opt['outputAs'] == 'html': path = os.path.dirname(os.path.abspath(__file__)) template_environment = Environment( autoescape=False, loader=FileSystemLoader(os.path.join(path, '../output')), trim_blocks=False) context = {'figures': figures, 'text': self.text} outfile = os.path.join(path, '..', 'output', filename) import codecs with codecs.open(outfile, 'w', 'utf-8') as f: html = template_environment.get_template( "templates/index.html").render(context) f.write(html) print("Saved output at file://{}".format(outfile)) elif idf.opt['outputAs'] == 'interactive': #keep non-blocking plot windows open plt.show() elif idf.opt['outputAs'] == 'pdf': pp.close()
def makePlot(self, noTightLayout=False, figHeight='100%', figWidth='100%', centeredStyle=None): current_figure = plt.gcf() if self.usesMPLD3(): plugins.connect(current_figure, plugins.MousePosition(fontsize=14)) if self.outputType == PlotSaveTYPE.HTML_STRING: if centeredStyle == None: centeredStyle = self.centeredStyle outString = mpld3.fig_to_html(current_figure, template_type='notebook', d3_url=self.d3js, mpld3_url=self.mpld3js, figHeight=figHeight, figWidth=figWidth, styles=centeredStyle) self.createdPlots.append(outString) plt.close(current_figure) return if self.outputType == PlotSaveTYPE.D3: mpld3.show(current_figure) if self.save_to_file: exactFilename = self.save_file + ".%02d." + PlotSaveTYPE.getFileExtension( self.outputType) exactFilename = exactFilename % self.saved_plot self.saved_plot += 1 if self.outputType == PlotSaveTYPE.HTML: mpld3.save_html(current_figure, exactFilename, template_type='simple', d3_url=self.d3js, mpld3_url=self.mpld3js) elif self.outputType == PlotSaveTYPE.JSON: mpld3.save_json(current_figure, exactFilename, d3_url=self.d3js, mpld3_url=self.mpld3js) elif self.outputType == PlotSaveTYPE.PNG: plt.savefig(exactFilename, transparent=self.transparent_bg, bbox_inches='tight') self.createdPlots.append(exactFilename) else: # if self.outputType == PlotSaveTYPE.MPL if not noTightLayout: legends = current_figure.legends makeTightLayout = True for lgd in legends + [ ax.legend_ for ax in current_figure.axes ]: if lgd == None: continue lgd.set_draggable(True) makeTightLayout = makeTightLayout and lgd._bbox_to_anchor == None if makeTightLayout: plt.tight_layout() plt.show() plt.close(current_figure)
def Plot(filename, fixed_axis, axis_value, levels=30, amp_min=0, amp_max=2500, color="magma", save=False, file_prefix="", show=True, xmin=None, xmax=None, ymin=None, ymax=None, figsize=(6.4, 4.8)): # Check fixed_axis has a valid value if fixed_axis not in ["x", "y", "z", "X", "Y", "Z"]: print("Error: Fixed axis must be x, y or z.") exit(0) _x, _y, _z, _amplitude = np.loadtxt(os.path.dirname(__file__) + '/' + filename, delimiter=",").T # Count the number of measurements we have for the given fixed_axis value if fixed_axis in ["x", "X"]: n = np.count_nonzero(_x == axis_value) elif fixed_axis in ["y", "Y"]: n = np.count_nonzero(_y == axis_value) else: n = np.count_nonzero(_z == axis_value) # Check if we have any measurements if n <= 0: exit(0) # Take the other values for the given fixed axis value x_axis = [] y_axis = [] amplitude = [] # Update our internal representation of the data for i in range(len(_amplitude)): if fixed_axis in ["x", "X"]: if _x[i] == axis_value: x_axis += [_z[i]] y_axis += [_y[i]] amplitude += [_amplitude[i]] elif fixed_axis in ["y", "Y"]: if _y[i] == axis_value: x_axis += [_x[i]] y_axis += [_z[i]] amplitude += [_amplitude[i]] else: if _z[i] == axis_value: x_axis += [_x[i]] y_axis += [_y[i]] amplitude += [_amplitude[i]] # Convert from Python arrays to Numpy arrays x = np.array(x_axis) y = np.array(y_axis) amplitude = np.array(amplitude) # Create a linear space for interpolating between x and z axes values xi = np.linspace(x.min() if xmin == None else xmin, x.max() if xmax == None else xmax, 1000) yi = np.linspace(y.min() if ymin == None else ymin, y.max() if ymax == None else ymax, 1000) # Interpolate the x and z axes to fill in the gaps between measurements amplitudei = griddata((x, y), amplitude, (xi[None, :], yi[:, None]), method='cubic') # Plot the interpolated data as a contour map if fixed_axis in ["x", "X"]: xlab = "z (m)" ylab = "y (m)" elif fixed_axis in ["y", "Y"]: xlab = "x (m)" ylab = "z (m)" else: xlab = "x (m)" ylab = "y (m)" title = filename.split("/")[-1] + "-" + fixed_axis + "=" + str( axis_value) + "m" # Create new plot figure fig, ax = plt.subplots(nrows=1, ncols=1, figsize=figsize) # Select colour if color == "magma": colormap = plt.cm.magma if color == "inferno": colormap = plt.cm.inferno if color == "plasma": colormap = plt.cm.plasma if color == "viridis": colormap = plt.cm.viridis # Create a contour plot cs = ax.contourf(xi, yi, amplitudei, levels=levels, cmap=colormap, vmin=amp_min, vmax=amp_max) ax.invert_xaxis() ax.axis('scaled') ax.set_facecolor((0.0, 0.0, 0.0)) ax.set_title(title, pad=20) ax.set_xlabel(xlab) ax.set_ylabel(ylab) # Connect to MousePosition Plugins plugins.connect(fig, plugins.MousePosition(fontsize=12)) # Create colour bar scale for the colour map cbar = fig.colorbar(cs) cbar.ax.set_ylabel("Amplitude (Pa)") if save: # Save to local computer plt.savefig(file_prefix + title + ".png", bbox_inches='tight', dpi=300, quality=100) if show: # Return JSON for visualisation g1 = json.dumps(fig_to_dict(fig), cls=NumpyEncoder) return g1
def setup_design_mode(self, grid_on=True, tick_spacing=50): self.ax.grid(b=grid_on) self.ax.xaxis.set_major_locator(mticker.MultipleLocator(tick_spacing)) self.ax.yaxis.set_major_locator(mticker.MultipleLocator(tick_spacing)) mdplugins.connect(self.fig, mdplugins.MousePosition())
def pickpoints(fig='', radius=4, color="white", x='x', y='y'): if not fig: fig = plt.gcf() plugins.connect(fig, Annotate(radius, color, x, y)) # color='htmlcolorname', radius=int plugins.connect(fig, plugins.MousePosition())
# limitations under the License. import matplotlib.pyplot as plt import mpld3 import numpy as np from mpld3 import plugins fig, ax = plt.subplots() x = np.linspace(-2, 2, 20) y = x[:, None] X = np.zeros((20, 20, 4)) X[:, :, 0] = np.exp(-(x - 1)**2 - (y)**2) X[:, :, 1] = np.exp(-(x + 0.71)**2 - (y - 0.71)**2) X[:, :, 2] = np.exp(-(x + 0.71)**2 - (y + 0.71)**2) X[:, :, 3] = np.exp(-0.25 * (x**2 + y**2)) im = ax.imshow(X, extent=(10, 20, 10, 20), origin='lower', zorder=1, interpolation='nearest') fig.colorbar(im, ax=ax) ax.set_title('An Image', size=20) plugins.connect(fig, plugins.MousePosition(fontsize=14)) mpld3.show()
def plotWavefront( wf, title, slice_numbers=False, cuts=False, interactive=False, phase=False ): # draw wavefront with common functions # if phase = True, plot phase only print("Displaying wavefront...") if slice_numbers is None: slice_numbers = range(wf_intensity.shape[-1]) if isinstance(slice_numbers, int): slice_numbers = [ slice_numbers, ] [nx, ny, xmin, xmax, ymin, ymax] = get_mesh(wf) dx = (xmax - xmin) / (nx - 1) dy = (ymax - ymin) / (ny - 1) print("stepX, stepY [um]:", dx * 1e6, dy * 1e6, "\n") if phase == True: A = wf.get_phase(slice_number=0, polarization="horizontal") label = "Phase (rad.)" else: ii = wf.get_intensity(slice_number=0, polarization="horizontal") ii = ii * wf.params.photonEnergy / J2EV # *1e3 imax = numpy.max(ii) if wf.params.wEFieldUnit != "arbitrary": print( "Total power (integrated over full range): %g [GW]" % (ii.sum(axis=0).sum(axis=0) * dx * dy * 1e6 * 1e-9) ) print( "Peak power calculated using FWHM: %g [GW]" % ( imax * 1e-9 * 1e6 * 2 * numpy.pi * (calculate_fwhm_x(wf) / 2.35) * (calculate_fwhm_y(wf) / 2.35) ) ) print("Max irradiance: %g [GW/mm^2]" % (imax * 1e-9)) label = "Irradiance (W/$mm^2$)" else: ii = ii / imax label = "Irradiance (a.u.)" A = ii [x1, x2, y1, y2] = wf.get_limits() if interactive == True: import mpld3 from mpld3 import plugins import matplotlib.pyplot as plt fig, ax = plt.subplots() im = ax.imshow(ii, extent=[x1 * 1e3, x2 * 1e3, y1 * 1e3, y2 * 1e3]) fig.colorbar(im, ax=ax) fig = plt.figure() ax.set_title(title, size=20) plugins.connect(fig, plugins.MousePosition(fontsize=14)) mpld3.show() # mpld3.display(fig) else: pylab.figure(figsize=(21, 6)) pylab.imshow(A, extent=[x1 * 1e3, x2 * 1e3, y1 * 1e3, y2 * 1e3]) pylab.set_cmap("hot") pylab.axis("tight") pylab.colorbar(orientation="horizontal") pylab.xlabel("x (mm)") pylab.ylabel("y (mm)") pylab.axes().set_aspect(0.5) pylab.title(title) pylab.show()