def getImage(self): figure = Figure() axes = figure.add_subplot(111) yAxes = self.signal_read() xAxes = [1] aux = 1 for x in range (0, len(yAxes)-1): aux += 1.0/self.sampleRate xAxes.append(aux) axes.plot(xAxes, yAxes) canvas = FigureCanvas(figure) figure.set_figwidth(6) figure.set_figheight(2) figure.savefig(self.fileImage) fig = QLabel() fig.setPixmap(QPixmap(self.fileImage)) fig.setFixedSize(600, 200) return fig
def reports_pie(request,scope): month, year, late , dates_gc = current_reporting_period() period = (dates_gc[0],dates_gc[1]) completed = len(scope.current_entries()) incomplete = len(scope.health_posts()) - len(scope.current_entries()) fig = Figure() ax=fig.add_subplot(111, axisbg='r') fig.set_figheight(2) fig.set_figwidth(2) fig.set_facecolor('w') labels = 'Completed', 'Incomlete' fracs = [completed,incomplete] explode=(0,0.01) pie(fracs, explode=explode, labels=None,colors=('g','r'), autopct='%1.1f%%', shadow=True) title('Reports..', bbox={'facecolor':'0.5', 'pad':5}) ax.pie(fracs, explode=explode, labels=None,colors=('#52E060','#F7976E'), shadow=True) canvas=FigureCanvas(fig) response=HttpResponse(content_type='image/png') canvas.print_png(response) return response
def test_arrow_annotation_get_window_extent(): figure = Figure(dpi=100) figure.set_figwidth(2.0) figure.set_figheight(2.0) renderer = RendererAgg(200, 200, 100) # Text annotation with arrow annotation = Annotation('', xy=(0.0, 50.0), xytext=(50.0, 50.0), xycoords='figure pixels', arrowprops={ 'facecolor': 'black', 'width': 8, 'headwidth': 10, 'shrink': 0.0 }) annotation.set_figure(figure) annotation.draw(renderer) bbox = annotation.get_window_extent() points = bbox.get_points() eq_(bbox.width, 50.0) assert_almost_equal(bbox.height, 10.0 / 0.72) eq_(points[0, 0], 0.0) eq_(points[0, 1], 50.0 - 5 / 0.72)
def tricontouring_response(tri_subset, data, request, dpi=None): """ triang_subset is a matplotlib.Tri object in lat/lon units (will be converted to projected coordinates) xmin, ymin, xmax, ymax is the bounding pox of the plot in PROJETED COORDINATES!!! request is the original getMap request object """ dpi = dpi or 80. bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] nlvls = request.GET['numcontours'] EPSG4326 = pyproj.Proj(init='EPSG:4326') tri_subset.x, tri_subset.y = pyproj.transform(EPSG4326, crs, tri_subset.x, tri_subset.y) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? if cmin is not None and cmax is not None: lvls = np.linspace(cmin, cmax, nlvls) norm = norm_func(vmin=cmin, vmax=cmax, clip=True) else: lvls = nlvls norm = norm_func() if request.GET['image_type'] == 'filledcontours': ax.tricontourf(tri_subset, data, lvls, norm=norm, cmap=colormap, extend='both') elif request.GET['image_type'] == 'contours': ax.tricontour(tri_subset, data, lvls, norm=norm, cmap=colormap, extend='both') ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def save_plot(fname, plot_name, plot): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from matplotlib.dates import DateFormatter fig = Figure() ax = fig.add_subplot(111) ax.xaxis.set_major_formatter(DateFormatter('%H:%M')) ax.set_xlabel("Time") ax.set_ylabel(plot_name) fig.set_figheight(20) fig.set_figwidth(30) fig.autofmt_xdate() handles = [] labels = [] for graph in plot: x, y = plot[graph] handles.append(ax.plot(x, y)) labels.append(graph) fig.legend(handles, labels, 1, shadow=True) canvas = FigureCanvas(fig) canvas.print_figure(fname, dpi=80)
def buildMetadataImage(self, layerInfoList, width): """ Creates the metadata caption for figures in styles that display a title only. """ # Find first non-outline layer. nonOutlineLayers = [l for l in layerInfoList if l.id != outline_layer.OUTLINE_LAYER_ID] layerInfo = nonOutlineLayers[0] if len(nonOutlineLayers) > 0 else None # Get the title of the first set of keyword data, i.e., that for the layer rather than one # of its antecedent layers or datasets. titleText = '' if layerInfo and (len(layerInfo.keywordData) > 0): titleText = layerInfo.keywordData[0].get('title', '') height = 500 dpi = 100 transparent = False figsize = (width / float(dpi), height / float(dpi)) fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=(not transparent)) renderer = Renderer(fig.dpi) text = fig.text(0.5, 0.98, titleText, fontdict=titleFont, horizontalalignment='center', verticalalignment='top') # Trim the height of the text image. extent = text.get_window_extent(renderer) textHeight = (extent.y1 - extent.y0 + 8) fig.set_figheight(textHeight / float(dpi)) return image_util.figureToImage(fig)
def tricontouring_response(tri_subset, data, request, dpi=None): """ triang_subset is a matplotlib.Tri object in lat/lon units (will be converted to projected coordinates) xmin, ymin, xmax, ymax is the bounding pox of the plot in PROJETED COORDINATES!!! request is the original getMap request object """ dpi = dpi or 80. bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] nlvls = request.GET['numcontours'] EPSG4326 = pyproj.Proj(init='EPSG:4326') tri_subset.x, tri_subset.y = pyproj.transform(EPSG4326, crs, tri_subset.x, tri_subset.y) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? if cmin is not None and cmax is not None: data[data > cmax] = cmax data[data < cmin] = cmin lvls = np.linspace(cmin, cmax, nlvls) norm = norm_func(vmin=cmin, vmax=cmax) else: lvls = nlvls norm = norm_func() if request.GET['image_type'] == 'filledcontours': ax.tricontourf(tri_subset, data, lvls, norm=norm, cmap=colormap) elif request.GET['image_type'] == 'contours': ax.tricontour(tri_subset, data, lvls, norm=norm, cmap=colormap) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) return figure_response(fig, request)
def quiver_response(lon, lat, dx, dy, request, dpi=None): dpi = dpi or 80. bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] vectorscale = request.GET['vectorscale'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] unit_vectors = None # We don't support requesting these yet, but wouldn't be hard EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) # TODO order for non-inverse? fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() mags = np.sqrt(dx**2 + dy**2) cmap = mpl.cm.get_cmap(colormap) if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? if cmin is not None and cmax is not None: mags[mags > cmax] = cmax mags[mags < cmin] = cmin norm = norm_func(vmin=cmin, vmax=cmax) else: norm = norm_func() # plot unit vectors if unit_vectors: ax.quiver(x, y, dx/mags, dy/mags, mags, cmap=cmap, norm=norm, scale=vectorscale) else: ax.quiver(x, y, dx, dy, mags, cmap=cmap, norm=norm, scale=vectorscale) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def buildMetadataImage(self, layerInfoList, width): """ Creates the metadata caption for figures in the style used by WMSViz. """ self.metadataItems = self._buildMetadataItems(layerInfoList) self.width = width width=self.width;height=1600;dpi=100;transparent=False figsize=(width / float(dpi), height / float(dpi)) fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=(not transparent)) axes = fig.add_axes([0.04, 0.04, 0.92, 0.92], frameon=True,xticks=[], yticks=[]) renderer = Renderer(fig.dpi) title, titleHeight = self._drawTitleToAxes(axes, renderer) txt, textHeight = self._drawMetadataTextToAxes(axes, renderer, self.metadataItems) # fit the axis round the text pos = axes.get_position() newpos = Bbox( [[pos.x0, pos.y1 - (titleHeight + textHeight) / height], [pos.x1, pos.y1]] ) axes.set_position(newpos ) # position the text below the title newAxisHeight = (newpos.y1 - newpos.y0) * height txt.set_position( (0.02, 0.98 - (titleHeight/newAxisHeight) )) for loc, spine in axes.spines.iteritems(): spine.set_edgecolor(borderColor) # Draw heading box headingBoxHeight = titleHeight - 1 axes.add_patch(Rectangle((0, 1.0 - (headingBoxHeight/newAxisHeight)), 1, (headingBoxHeight/newAxisHeight), facecolor=borderColor, fill = True, linewidth=0)) # reduce the figure height originalHeight = fig.get_figheight() pos = axes.get_position() topBound = 20 / float(dpi) textHeight = (pos.y1 - pos.y0) * originalHeight newHeight = topBound * 2 + textHeight # work out the new proportions for the figure border = topBound / float(newHeight) newpos = Bbox( [[pos.x0, border], [pos.x1, 1 - border]] ) axes.set_position(newpos ) fig.set_figheight(newHeight) return image_util.figureToImage(fig)
def quiver_response(lon, lat, dx, dy, request, vectorscale, unit_vectors=False, dpi=80): bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) # TODO order for non-inverse? fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() mags = np.sqrt(dx**2 + dy**2) cmap = mpl.cm.get_cmap(colormap) # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? norm = None if cmin is not None and cmax is not None: mags[mags > cmax] = cmax mags[mags < cmin] = cmin bounds = np.linspace(cmin, cmax, 15) norm = mpl.colors.BoundaryNorm(bounds, cmap.N) # plot unit vectors if unit_vectors: ax.quiver(x, y, dx/mags, dy/mags, mags, cmap=cmap, scale=vectorscale) else: ax.quiver(x, y, dx, dy, mags, cmap=cmap, norm=norm, scale=vectorscale) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def init_figure(): fig = Figure() w, h = layout.canvas_size fig.set_figwidth(w/dpi) fig.set_figheight(h/dpi) ax = fig.add_subplot(111) ax.set_xlabel("Frequency [kHz]") ax.set_ylabel("Log Mag [dBFS]") ax.set_ylim((-90, 10)) ax.grid() return fig, ax
def results(): model = load_model('./instrument_classifier_model') filename_img = str(request.form['predfiles']) filename_img = filename_img.split('/') filename_img = filename_img[-2:] filename_img = '/'.join(filename_img) filename_wav = f'./static/val/{filename_img[:-3].replace(".", "")}.wav' img = load_img(f'./static/val_set/{filename_img}', target_size=(262, 694)) img = img_to_array(img) img = img.reshape((1, ) + img.shape) prediction = model.predict(img) pred = np.argmax(prediction) key_list = list(class_dict.keys()) val_list = list(class_dict.values()) position = val_list.index(pred) predicted_name = key_list[position] actual = filename_img.split('/') actual = actual[0] fig = Figure() axis = fig.add_subplot( 1, 1, 1, ) fig.set_figheight(14) fig.set_figwidth(14) axis.bar(key_list, prediction.reshape(-1, )) fig.suptitle('Model Prediction Probability', fontsize=30) plt.setp(axis.xaxis.get_majorticklabels(), rotation=45, fontsize=20) plt.setp(axis.yaxis.get_majorticklabels(), fontsize=20) plt.tight_layout() output = BytesIO() FigureCanvas(fig).print_png(output) pngImageB64String = "data:image/png;base64," pngImageB64String += base64.b64encode(output.getvalue()).decode('utf8') return render_template('results.html', prediction=predicted_name, filename_wav=filename_wav, actual=actual, pimage=f'./static/images/{predicted_name}.png', aimage=f'./static/images/{actual}.png', resp=pngImageB64String)
def contouring_response(lon, lat, data, request, dpi=None): dpi = dpi or 80. bbox, width, height, colormap, cmin, cmax, crs = _get_common_params(request) nlvls = request.GET['numcontours'] EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize if cmin is not None and cmax is not None: data[data > cmax] = cmax data[data < cmin] = cmin lvls = np.linspace(cmin, cmax, nlvls) norm = norm_func(vmin=cmin, vmax=cmax) else: lvls = nlvls norm = norm_func() if request.GET['image_type'] == 'filledcontours': ax.contourf(x, y, data, lvls, norm=norm, cmap=colormap) elif request.GET['image_type'] == 'contours': ax.contour(x, y, data, lvls, norm=norm, cmap=colormap) elif request.GET['image_type'] == 'filledhatches': hatches = DEFAULT_HATCHES[:lvls] ax.contourf(x, y, data, lvls, norm=norm, cmap=colormap, hatches=hatches) elif request.GET['image_type'] == 'hatches': hatches = DEFAULT_HATCHES[:lvls] ax.contourf(x, y, data, lvls, norm=norm, colors='none', hatches=hatches) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def tricontourf_response(tri_subset, data, request, dpi=80.0, nlvls=15): """ triang_subset is a matplotlib.Tri object in lat/lon units (will be converted to projected coordinates) xmin, ymin, xmax, ymax is the bounding pox of the plot in PROJETED COORDINATES!!! request is the original getMap request object """ bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] EPSG4326 = pyproj.Proj(init='EPSG:4326') tri_subset.x, tri_subset.y = pyproj.transform(EPSG4326, crs, tri_subset.x, tri_subset.y) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin lvls = np.linspace(float(cmin), float(cmax), int(nlvls)) ax.tricontourf(tri_subset, data, levels=lvls, cmap=colormap) else: ax.tricontourf(tri_subset, data, cmap=colormap) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def create_projected_fig(lonmin, latmin, lonmax, latmax, projection, height, width): from mpl_toolkits.basemap import Basemap from matplotlib.figure import Figure fig = Figure(dpi=80, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height) fig.set_figwidth(width) m = Basemap(llcrnrlon=lonmin, llcrnrlat=latmin, urcrnrlon=lonmax, urcrnrlat=latmax, projection=projection, resolution=None, lat_ts = 0.0, suppress_ticks=True) m.ax = fig.add_axes([0, 0, 1, 1], xticks=[], yticks=[]) return fig, m
def blank_figure(width, height, dpi=5): """ return a transparent (blank) response used for tiles with no intersection with the current view or for some other error. """ fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) ax = fig.add_axes([0, 0, 1, 1]) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0, 0, 1, 1]) return fig
def contourf_response(lon, lat, data, request, dpi=80, nlvls = 15): xmin, ymin, xmax, ymax = wms_handler.get_bbox(request) width, height = wms_handler.get_width_height(request) colormap = wms_handler.get_colormap(request) cmin, cmax = wms_handler.get_climits(request) #proj = get_pyproj(request) #xcrs, ycrs = proj(lon.flatten(),lat.flatten()) CRS = get_pyproj(request) xcrs, ycrs = pyproj.transform(EPSG4326, CRS, lon.flatten(),lat.flatten()) #TODO order for non-inverse? #logger.info("xcrs, ycrs: {0} {1}".format(xcrs, ycrs)) xcrs = xcrs.reshape(data.shape) ycrs = ycrs.reshape(data.shape) sxcrs = np.argsort(xcrs[1,:]) sycrs = np.argsort(ycrs[:,1]) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) lvls = np.linspace(cmin, cmax, nlvls) #ax.contourf(xcrs, ycrs, data, levels=lvls, cmap=colormap) ax.contourf(xcrs[sycrs,:][:,sxcrs], ycrs[sycrs,:][:,sxcrs], data[sycrs,:][:,sxcrs], levels=lvls, cmap=colormap) ax.set_xlim(xmin, xmax) ax.set_ylim(ymin, ymax) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0, 0, 1, 1]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def blank_canvas(width, height, dpi=5): """ return a transparent (blank) response used for tiles with no intersection with the current view or for some other error. """ fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) ax = fig.add_axes([0, 0, 1, 1]) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0, 0, 1, 1]) canvas = FigureCanvasAgg(fig) return canvas
def plot_pixel_drift(x_pos, y_pos, index=None, out_fn=None, title=None): """Plot pixel drift. Args: x_pos (`numpy.array`): an array of pixel values. y_pos (`numpy.array`): an array of pixel values. index (`numpy.array`): an array to use as index, can be datetime values. If no index is provided a simple range is generated. out_fn (str): Filename to save image to, default is None for no save. Returns: `matplotlib.Figure`: The `Figure` object """ # Plot the pixel drift of target if index is None: index = np.arange(len(x_pos)) pos_df = pd.DataFrame({'dx': x_pos, 'dy': y_pos}, index=index) fig = Figure() FigureCanvas(fig) fig.set_figwidth(12) fig.set_figheight(9) ax = fig.add_subplot(111) ax.plot(pos_df.index, pos_df.dx, lw=4, label='dx [Dec axis]') ax.plot(pos_df.index, pos_df.dy, lw=4, alpha=0.5, label='dy [RA axis]') ax.set_ylabel('Δ pixel', fontsize=18) ax.set_xlabel('Time [UTC]', fontsize=16) if title is None: title = 'Pixel drift' ax.set_title(title, fontsize=16) ax.set_ylim([-5, 5]) fig.legend(fontsize=16) fig.tight_layout() if out_fn: fig.savefig(out_fn, dpi=100) return fig
def getImage(self): figure = Figure() axes = figure.add_subplot(111) axes.plot(self.signal_read()) canvas = FigureCanvas(figure) figure.set_figwidth(6) figure.set_figheight(2) figure.savefig(self.fileImage) fig = QLabel() fig.setPixmap(QPixmap(self.fileImage)) fig.setFixedSize(600, 200) return fig
def radial_summary(values,name): # Set the colors for the plot colors=["#A7DB40","#D8E067","#FFB81F","#FF743D","#C4213D","#707070"] # Create a figure and a canvas to draw in fig = Figure() canvas = FigureCanvas(fig) fig.set_figwidth(1) fig.set_figheight(1) # Set the figure configuration and parameters ax = fig.add_subplot(1,1,1) # Plot the pie with the diferent values and colors ax.pie(values,colors=colors, shadow=True, startangle=90) #Save the graphic as an image canvas.print_figure('tweetclass/static/tweetclass/summary_pie_'+name+'.png',bbox_inches='tight')
def _draw_figure(self, title, filename, x_values, y_values, x_label, y_label): figure = Figure() canvas = FigureCanvas(figure) axes = figure.add_axes([0.15, 0.1, 0.7, 0.7]) axes.plot(x_values, y_values) axes.grid(True) axes.set_xlabel(x_label) axes.set_ylabel(y_label) axes.set_title(title) figure.set_figheight(8) figure.set_figwidth(15) try: figure.savefig(filename) #canvas.print_png(filename) except Exception, e: logger.error(title) logger.error(filename) logger.error(str(e))
def test_empty_annotation_get_window_extent(): figure = Figure(dpi=100) figure.set_figwidth(2.0) figure.set_figheight(2.0) renderer = RendererAgg(200, 200, 100) # Text annotation with arrow annotation = Annotation( '', xy=(0.0, 50.0), xytext=(0.0, 50.0), xycoords='figure pixels') annotation.set_figure(figure) annotation.draw(renderer) bbox = annotation.get_window_extent() points = bbox.get_points() eq_(points[0, 0], 0.0) eq_(points[1, 0], 0.0) eq_(points[1, 1], 50.0) eq_(points[0, 1], 50.0)
def test_arrow_annotation_get_window_extent(): figure = Figure(dpi=100) figure.set_figwidth(2.0) figure.set_figheight(2.0) renderer = RendererAgg(200, 200, 100) # Text annotation with arrow annotation = Annotation( '', xy=(0.0, 50.0), xytext=(50.0, 50.0), xycoords='figure pixels', arrowprops={ 'facecolor': 'black', 'width': 8, 'headwidth': 10, 'shrink': 0.0}) annotation.set_figure(figure) annotation.draw(renderer) bbox = annotation.get_window_extent() points = bbox.get_points() eq_(bbox.width, 50.0) assert_almost_equal(bbox.height, 10.0 / 0.72) eq_(points[0, 0], 0.0) eq_(points[0, 1], 50.0 - 5 / 0.72)
def pcolormesh_response(lon, lat, data, request, dpi=80): bbox, width, height, colormap, cmin, cmax, crs = _get_common_params(request) EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin norm = norm = norm_func(vmin=cmin, vmax=cmax) else: norm = norm_func() masked = np.ma.masked_invalid(data) ax.pcolormesh(x, y, masked, norm=norm, cmap=colormap) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def pcolormesh_response(lon, lat, data, request, dpi=None): dpi = dpi or 80. bbox, width, height, colormap, cmin, cmax, crs = _get_common_params( request) EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin norm = norm = norm_func(vmin=cmin, vmax=cmax) else: norm = norm_func() masked = np.ma.masked_invalid(data) ax.pcolormesh(x, y, masked, norm=norm, cmap=colormap) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def displayGraph(self, static_risk, static_returns, continuous_risk, continuous_returns, inflation, xticks): fig = Figure(figsize=(5, 4)) fig.set_figheight(10) fig.set_figwidth(20) a = fig.add_subplot(111) if self.use_static.get(): a.plot(xticks, static_risk, "y--") a.plot(xticks, static_returns, "y-") if self.use_cont.get(): a.plot(xticks, continuous_risk, "b--") a.plot(xticks, continuous_returns, "b-") if self.use_inf: a.plot(xticks, inflation, "r-") a.set_title("Risk vs Returns of Portfolio") a.set_ylabel("$") a.set_xlabel("Time") plt.setp(a.xaxis.get_majorticklabels(), rotation=90) canvas = FigureCanvasTkAgg(fig, master=self) canvas.get_tk_widget().grid(row=7) canvas.draw()
class FirseFrame(wx.Frame): def __init__(self, parent=None, id=-1, title='', pos=wx.DefaultSize, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE): wx.Frame.__init__(self, parent, id, title, pos, size, style) self.InitUI() pass def InitUI(self): self.SetBackgroundColour('white') self.scorePanel = wx.Panel(self) scores = [89, 98, 70, 80, 60, 78, 85, 90] sum = 0 for s in scores: sum += s average = sum / len(scores) t_score = numpy.arange(1, len(scores) + 1, 1) s_score = numpy.array(scores) self.figure_score = Figure() self.figure_score.set_figheight(3.6) self.figure_score.set_figwidth(7.8) self.axes_score = self.figure_score.add_subplot(111) self.axes_score.plot(t_score, s_score, 'ro', t_score, s_score, 'k') self.axes_score.axhline(y=average, color='r') self.axes_score.set_title(u'My Scores') self.axes_score.grid(True) self.axes_score.set_xlabel('T') self.axes_score.set_ylabel('score') FigureCanvas(self.scorePanel, -1, self.figure_score) pass
def pcolormesh_response(lon, lat, data, request, dpi=80): params = _get_common_params(request) bbox, width, height, colormap, cmin, cmax, crs = params EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() cmap = mpl.cm.get_cmap(colormap) if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin bounds = np.linspace(cmin, cmax, 15) norm = mpl.colors.BoundaryNorm(bounds, cmap.N) bounds = np.linspace(cmin, cmax, 15) else: norm = None masked = np.ma.masked_invalid(data) ax.pcolormesh(x, y, masked, vmin=5, vmax=30, norm=norm) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def draw_things(things,colors,labels,text,name=""): # If "name" is empty, it's setted to the text content without spaces if name=="": name = text.replace(" ","") # Create a figure and a canvas to draw in fig = Figure() fig.set_figwidth(15) fig.set_figheight(5) canvas = FigureCanvas(fig) # Set the figure configuration and parameters ax = fig.add_subplot(1,1,1, axisbg='white') ax.set_ylabel('Value') ax.set_xlabel('Tweets') ax.set_title(text) # Set the x axis indices for every plotting N = len(things[0]) ind = np.arange(N) # creates an numpy.array from 0 to N-1 # Formatter for the x axis def numeric_ment(x,pos): return "#0%d" % (x+1) formatter = ticker.FuncFormatter(numeric_ment) # Plot all the things for t in range(len(things)): ax.plot(ind,things[t],colors[t],label=labels[t],linewidth=1.5) # Plot the legend in the graphic ax.legend() # Format the x axis as defined avobe ax.xaxis.set_major_formatter(formatter) #Save the graphic as an image canvas.print_figure(name+'.png',facecolor='white',bbox_inches='tight')
def buildDetailsImage(self, layerInfoList, width): """ Creates the metadata details for figures using templates. """ # Find first non-outline layer. nonOutlineLayers = [l for l in layerInfoList if l.id != outline_layer.OUTLINE_LAYER_ID] layerInfo = nonOutlineLayers[0] if len(nonOutlineLayers) > 0 else None # Flatten the keyword dictionaries, giving priority to entries from descendants over # antecedents. keywordData = {} if layerInfo: for kw in reversed(layerInfo.keywordData): keywordData.update(kw) detailsText = caption_manager.getCaption(layerInfo, keywordData) height = 500 dpi = 100 transparent = False figsize = (width / float(dpi), height / float(dpi)) fig = Figure(figsize=figsize, dpi=dpi, facecolor='w', frameon=(not transparent)) renderer = Renderer(fig.dpi) text = fig.text(0.02, 0.98, detailsText, fontdict=metadataFont, horizontalalignment='left', verticalalignment='top') # Trim the height of the text image. extent = text.get_window_extent(renderer) textHeight = (extent.y1 - extent.y0 + 8) fig.set_figheight(textHeight / float(dpi)) return image_util.figureToImage(fig)
class TestFrame(ttk.Frame): def __init__(self, master, settings, machine): self.settings = settings self.machine = machine self.master = master ttk.Frame.__init__(self, master, width=780, height=400) self.columnconfigure(1, weight=1) self.columnconfigure(0, weight=0) self.rowconfigure(0, weight=0) self.grid(row=0, column=0, sticky="nsew") self.runLabel = ttk.Label(self, text="Run Program:", font=('Helvetica', 16), width="20", anchor=tk.E) self.runBtn = ttk.Button(self, text="Stab", command=self.runTest) self.runLabel.grid(row=0, column=0, sticky="e") self.runBtn.grid(row=0, column=1, sticky="w") self.runNumVar = tk.StringVar() self.runNumVar.set("Run Number: " + str(int(self.settings.getValue("runNumber")))) self.runNumberLabel = ttk.Label(self, textvariable=self.runNumVar, font=('Helvetica', 16), width="20", anchor=tk.E) self.runNumberLabel.grid(row=0, column=2, sticky="e") self.figure = Figure() self.figure.set_figheight(3.7) self.figure.set_figwidth(7.8) self.axis = self.figure.add_subplot(111) self.axis.plot([], [], lw=2) self.canvas = FigureCanvasTkAgg(self.figure, self) self.canvas.draw() self.canvas.get_tk_widget().grid(row=1, column=0, columnspan=4, sticky="nsew") self.clearGraphBtn = ttk.Button(self, text="Clear", command=self.clearResults) self.clearGraphBtn.grid(row=0, column=3, sticky="e") def clearResults(self): self.axis.clear() self.canvas.draw() self.canvas.flush_events() self.canvas.draw() def syncTab(self, active): if (not self.settings.getValue("homed")): self.runBtn.configure(state='disable') else: self.runBtn.configure(state='normal') def runTest(self): runNum = int(self.settings.getValue("runNumber")) runNum = runNum + 1 self.settings.setValue("runNumber", runNum) self.settings.save() self.runNumVar.set("Run Number: " + str(runNum)) self.runNumberLabel.update() penetration = self.settings.getValue("targetPen") thrustmove = self.settings.getValue("targetZero") + penetration if (thrustmove > self.settings.getValue("maxDistance")): return #if the thrust move is to far we quit distance = self.machine.Motor.AxisLocation() * -1 if (distance != 0): self.moveHome() thrustspeed = int(self.settings.getValue("Speed")) retractmove = (penetration * 2) * -1 #start reading self.machine.startSensor() #thrust at target self.machine.moveTo(thrustmove, int(thrustspeed)) finished = False while (not finished): time.sleep(.001) finished = self.machine.Motor.commandDone() time.sleep(.25) self.machine.stopSensor() forceresults = self.machine.getForceReadings() moveresults = self.machine.getMovementReadings() self.axis.plot(forceresults[0], forceresults[1], lw=2) self.canvas.draw() self.canvas.flush_events() self.canvas.draw() self.moveHome() filenametime = time.time() acceleration = int(self.settings.getValue("acceleration")) f = open("run-measurements-" + str(runNum) + ".csv", "a") f.write('run,speed,distance,penetration,acceleration\r\n') f.write( str(runNum) + ',' + str(thrustspeed) + ',' + str(thrustmove) + ',' + str(penetration) + ',' + str(acceleration) + '\r\n') f.write('\r\n') f.write('\r\n') f.write('\r\n') f.write('microsecond,rawmeasurement\r\n') count = len(forceresults[0]) for i in range(0, count): f.write( str(forceresults[0][i]) + "," + str(forceresults[1][i]) + '\r\n') f.close() f = open("run-movement-log-" + str(runNum) + ".csv", "a") f.write('run,speed,distance,penetration,acceleration\r\n') f.write( str(runNum) + ',' + str(thrustspeed) + ',' + str(thrustmove) + ',' + str(penetration) + ',' + str(acceleration) + '\r\n') f.write('\r\n') f.write('\r\n') f.write('\r\n') f.write('microsecond,location\r\n') count = len(moveresults[0]) for i in range(0, count): f.write( str(moveresults[0][i]) + "," + str(moveresults[1][i]) + '\r\n') f.close() def moveHome(self): homed = False self.machine.watchSwitch(self.machine.stopMove) self.machine.moveTo( self.settings.getValue("maxDistance") * -1, int(self.settings.getValue("homeSpeed"))) while (not homed): time.sleep(.1) homed = self.machine.Motor.commandDone() self.machine.stopSwitch() self.machine.moveTo(5, int(self.settings.getValue("homeSpeed"))) homed = False while (not homed): time.sleep(.1) homed = self.machine.Motor.commandDone() self.machine.Motor.PulseLocation = 0 self.settings.setValue("homed", True)
class Chart(object): """ Simple and clean facade to Matplotlib's plotting API. A chart instance abstracts a plotting device, on which one or multiple related plots can be drawn. Charts can be exported as images, or visualized interactively. Each chart instance will always open in its own GUI window, and this window will never block the execution of the rest of the program, or interfere with other L{Chart}s. The GUI can be safely opened in the background and closed infinite number of times, as long as the client program is still running. By default, a chart contains a single plot: >>> chart.plot matplotlib.axes.AxesSubplot >>> chart.plot.hist(...) If C{rows} and C{columns} are defined, the chart will contain C{rows} x C{columns} number of plots (equivalent to MPL's sub-plots). Each plot can be assessed by its index: >>> chart.plots[0] first plot or by its position in the grid: >>> chart.plots[0, 1] plot at row=0, column=1 @param number: chart number; by default this a L{Chart.AUTONUMBER} @type number: int or None @param title: chart master title @type title: str @param rows: number of rows in the chart window @type rows: int @param columns: number of columns in the chart window @type columns: int @note: additional arguments are passed directly to Matplotlib's Figure constructor. """ AUTONUMBER = None _serial = 0 def __init__(self, number=None, title='', rows=1, columns=1, backend=Backends.WX_WIDGETS, *fa, **fk): if number == Chart.AUTONUMBER: Chart._serial += 1 number = Chart._serial if rows < 1: rows = 1 if columns < 1: columns = 1 self._rows = int(rows) self._columns = int(columns) self._number = int(number) self._title = str(title) self._figure = Figure(*fa, **fk) self._figure._figure_number = self._number self._figure.suptitle(self._title) self._beclass = backend self._hasgui = False self._plots = PlotsCollection(self._figure, self._rows, self._columns) self._canvas = FigureCanvasAgg(self._figure) formats = [(f.upper(), f) for f in self._canvas.get_supported_filetypes()] self._formats = csb.core.Enum.create('OutputFormats', **dict(formats)) def __getitem__(self, i): if i in self._plots: return self._plots[i] else: raise KeyError('No such plot number: {0}'.format(i)) def __enter__(self): return self def __exit__(self, *a, **k): self.dispose() @property def _backend(self): return Backend.get(self._beclass, started=True) @property def _backend_started(self): return Backend.query(self._beclass) @property def title(self): """ Chart title @rtype: str """ return self._title @property def number(self): """ Chart number @rtype: int """ return self._number @property def plots(self): """ Index-based access to the plots in this chart @rtype: L{PlotsCollection} """ return self._plots @property def plot(self): """ First plot @rtype: matplotlib.AxesSubplot """ return self._plots[0] @property def rows(self): """ Number of rows in this chart @rtype: int """ return self._rows @property def columns(self): """ Number of columns in this chart @rtype: int """ return self._columns @property def width(self): """ Chart's width in inches @rtype: int """ return self._figure.get_figwidth() @width.setter def width(self, inches): self._figure.set_figwidth(inches) if self._backend_started: self._backend.resize(self._figure) @property def height(self): """ Chart's height in inches @rtype: int """ return self._figure.get_figheight() @height.setter def height(self, inches): self._figure.set_figheight(inches) if self._backend_started: self._backend.resize(self._figure) @property def dpi(self): """ Chart's DPI @rtype: int """ return self._figure.get_dpi() @dpi.setter def dpi(self, dpi): self._figure.set_dpi(dpi) self._backend.resize(self._figure) @property def formats(self): """ Supported output file formats @rtype: L{csb.core.enum} """ return self._formats def show(self): """ Show the GUI window (non-blocking). """ if not self._hasgui: self._backend.add(self._figure) self._hasgui = True self._backend.show(self._figure) def hide(self): """ Hide (but do not dispose) the GUI window. """ self._backend.hide(self._figure) def dispose(self): """ Dispose the GUI interface. Must be called at the end if any chart.show() calls have been made. Automatically called if using the chart in context manager ("with" statement). @note: Failing to call this method if show() has been called at least once may cause backend-related errors. """ if self._backend_started: service = self._backend if service and service.running: service.destroy(self._figure, wait=True) service.client_disposed(self) def save(self, file, format='png', crop=False, dpi=None, *a, **k): """ Save all plots to an image. @param file: destination file name @type file: str @param format: output image format; see C{chart.formats} for enumeration @type format: str or L{csb.core.EnumItem} @param crop: if True, crop the image (equivalent to MPL's bbox=tight) @type crop: bool @note: additional arguments are passed directly to MPL's savefig method """ if 'bbox_inches' in k: bbox = k['bbox_inches'] del k['bbox_inches'] else: if crop: bbox = 'tight' else: bbox = None self._canvas.print_figure(file, format=str(format), bbox_inches=bbox, dpi=dpi, *a, **k)
def quiver_response(lon, lat, dx, dy, request, unit_vectors=False, dpi=80): from django.http import HttpResponse xmin, ymin, xmax, ymax = wms_handler.get_bbox(request) width, height = wms_handler.get_width_height(request) colormap = wms_handler.get_colormap(request) climits = wms_handler.get_climits(request) cmax = 1. cmin = 0. if len(climits) == 2: cmin, cmax = climits else: logger.debug("No climits, default cmax to 1.0") # cmax = 10. #proj = get_pyproj(request) #x, y = proj(lon, lat) CRS = get_pyproj(request) x, y = pyproj.transform(EPSG4326, CRS, lon, lat) #TODO order for non-inverse? #logger.info("x, y: {0} {1}".format(x, y)) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() #scale to cmin - cmax # dx = cmin + dx*(cmax-cmin) # dy = cmin + dy*(cmax-cmin) mags = np.sqrt(dx**2 + dy**2) # mags[mags>cmax] = cmax mags[mags>cmax] = cmax mags[mags<cmin] = cmin import matplotlib as mpl cmap = mpl.cm.get_cmap(colormap) bounds = np.linspace(cmin, cmax, 15) norm = mpl.colors.BoundaryNorm(bounds, cmap.N) #plot unit vectors if unit_vectors: ax.quiver(x, y, dx/mags, dy/mags, mags, cmap=colormap) else: ax.quiver(x, y, dx, dy, mags, cmap=cmap, norm=norm) #ax.quiver(x, y, dx/mags, dy/mags, mags, cmap=colormap,norm=norm) ax.set_xlim(xmin, xmax) ax.set_ylim(ymin, ymax) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def chart_weight(request, fy, fm, fd, ty, tm, td, annotate_begin, annotate_end, width=1.9, height=0.4): from_date = datetime.date(int(fy),int(fm),int(fd)) to_date = datetime.date(int(ty),int(tm),int(td)) # Get all events that have weights between (and including) # from_date and to_date weights = Event.objects.filter(time__gte=from_date).filter(time__lte=to_date).filter(weight__isnull=False).order_by('time').select_related('weight') # Now let's pile in some data x=[] y=[] for event in weights: date = event.time.date() weight = event.weight_set.all()[0].weight x.append(date) y.append(weight) # Set up the chart; we use 100 DPI because it makes # pixel-math easy matplotlib.rc('lines', linewidth=1, color='black') matplotlib.rc('font', size=6) fig=Figure(dpi=100,frameon=False) fig.set_figwidth(width) fig.set_figheight(height) ax=fig.add_subplot(111, autoscale_on=True, frameon=False, yticklabels=[], xticklabels=[]) ax.plot_date(x, y, '-') ax.yaxis.set_ticks_position('none') ax.xaxis.set_ticks_position('none') # Add the date to the beginning if annotate_begin == '1': ax.annotate(x[0].strftime("%b %e") + '/' + str(int(y[0])) + '', xy=(18, -40), xycoords='figure pixels', arrowprops=None, color='black') # And the weight to the end (because we tend to know what day it # is from the rest of the site) if annotate_end == '1': ax.annotate(str(int(y[-1])), xy=(160, -25), xycoords='figure pixels', arrowprops=None, color='black') canvas = FigureCanvas(fig) response=django.http.HttpResponse(content_type='image/png') canvas.print_png(response) return response
def contouring_response(lon, lat, data, request, dpi=None): dpi = dpi or 80. bbox, width, height, colormap, cmin, cmax, crs = _get_common_params( request) nlvls = request.GET['numcontours'] EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize if cmin and cmax: data[data > cmax] = cmax data[data < cmin] = cmin lvls = np.linspace(cmin, cmax, nlvls) norm = norm_func(vmin=cmin, vmax=cmax) else: lvls = nlvls norm = norm_func() if request.GET['image_type'] == 'filledcontours': ax.contourf(x, y, data, lvls, norm=norm, cmap=colormap) elif request.GET['image_type'] == 'contours': ax.contour(x, y, data, lvls, norm=norm, cmap=colormap) elif request.GET['image_type'] == 'filledhatches': hatches = DEFAULT_HATCHES[:lvls] ax.contourf(x, y, data, lvls, norm=norm, cmap=colormap, hatches=hatches) elif request.GET['image_type'] == 'hatches': hatches = DEFAULT_HATCHES[:lvls] ax.contourf(x, y, data, lvls, norm=norm, colors='none', hatches=hatches) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
# import urllib # import json # # import pandas as pd # import numpy as np checkPrivilege() LARGE_FONT = ("Verdana", 12) SMALL_FONT = ("Verdana", 10) style.use("ggplot") f = Figure() a = f.add_subplot(111) f.set_figheight(240) dList = [] uList = [] index = [] for i in range(1, 100): index.append(i) dList.append(0.0) uList.append(0.0) r, s, t = getTotalNetUsage() last = [r, s, t] time.sleep(0.5) r, s, t = getTotalNetUsage() cur = [r, s, t]
class realTimeVisualisation(gtk.Window): def __init__(self,networkVariables): ''' ''' super(realTimeVisualisation,self).__init__() self.set_size_request(640,690) self.set_position(gtk.WIN_POS_CENTER) self.connect("destroy", gtk.main_quit) self.fig = Figure(figsize=(5,4), dpi=100) self.canvas = FigureCanvas(self.fig) # a gtk.DrawingArea self.canvas.set_size_request(640,690) vbox = gtk.VBox(False,1) alignIm = gtk.Alignment(0, 1 , 1, 0) alignIm.add(self.canvas) vbox.pack_start(alignIm) self.add(vbox) self.initNetworkVariables(networkVariables) self.createGraph() updateTime = 1 #len(self.quantitiesToPlot) ## if this time is to fast, it will show nothing gobject.timeout_add(updateTime,self.updateGraph) self.show_all() def initNetworkVariables(self,networkVariables): ''' ''' self.dt = 0.01 self.filename = '../.realtime.viz' self.quantitiesToPlot = ['Pressure','Flow'] self.initialValues = [0,0,0,0,0] #TODO: Try Except Pass should be fixed try: self.dt = networkVariables['dt'] self.filename = networkVariables['filename'] self.quantitiesToPlot = networkVariables['quantitiesToPlot'] self.initialValues = networkVariables['initialValues'] except: pass def updateGraph(self): ''' ''' #TODO: Try Except Pass should be fixed try: with open(''.join([cur,'/',self.filename]),'r') as dataFile: for dataLine in dataFile: dataString = dataLine break os.remove(''.join([cur,'/',self.filename])) except: pass dataDict = {} #TODO: Try Except Pass should be fixed try: dataDict = eval(dataString) except: try: if dataString == 'STOP': return False except: pass pass #TODO: Try Except Pass should be fixed try: for quantity in self.quantitiesToPlot: newValue = dataDict[quantity] ## update y values yvals = self.lines[quantity].get_ydata() yvalsn = np.append(yvals,newValue) self.lines[quantity].set_ydata(yvalsn) ## update x values timeOld = self.lines[quantity].get_xdata() time = np.append(timeOld,[timeOld[-1]+self.dt]) self.lines[quantity].set_xdata(time) ## adjust limits self.adjustAxis(self.axis[quantity],time,yvalsn) # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize() except: pass return True def adjustAxis(self,axis,xVals,yVals): ''' ''' mmF = 0.1 #get values for y yMaxVals = np.max(yVals) yMinVals = np.min(yVals) yMinAx,yMaxAx = axis.get_ylim() #check and correct if necessary if yMaxVals > yMaxAx-mmF*abs(yMaxAx): yMaxAx = yMaxVals+mmF*abs(yMaxVals) if yMinVals < yMinAx+mmF*abs(yMinAx): yMinAx = yMinVals-mmF*abs(yMinVals) #apply y values axis.set_ylim([yMinAx,yMaxAx]) #get values for x xMinVals = np.min(xVals) xMaxVals = np.max(xVals) xMinAx,xMaxAx = axis.get_xlim() #check and correct if necessary if xMaxVals > xMaxAx-mmF*abs(xMaxAx): xMaxAx = xMaxVals+mmF*abs(xMaxVals) if xMinVals < xMinAx+mmF*abs(xMinAx): xMinAx = xMinVals-mmF*abs(xMinVals) #apply y values axis.set_xlim([xMinAx,xMaxAx]) def createGraph(self): ''' ''' numberOfQuantities = len(self.quantitiesToPlot) self.fig.subplots_adjust(hspace = 0.4) self.fig.subplots_adjust(right = 0.85) self.fig.subplots_adjust(top = 0.98) self.fig.subplots_adjust(bottom = 0.2) self.fig.subplots_adjust(hspace = 0.5) self.fig.set_figwidth(8.27) self.fig.set_figheight((11.69/3)*numberOfQuantities) self.lines = {} self.axis = {} i = 0 colors = ['b','r','m','g','k'] for quantity in self.quantitiesToPlot: self.axis[quantity] = self.fig.add_subplot(numberOfQuantities,1,i+1, ylabel=quantity, xlabel='Time', ylim = [self.initialValues[i],self.initialValues[i]-0.001], xlim = [0,0.0001]) self.lines[quantity] = self.axis[quantity].plot(0,self.initialValues[i],color=colors[i] ,linestyle = '-',label=quantity, linewidth = 1.)[0] i = i+1 # update view() self.canvas.figure = self.fig self.fig.set_canvas(self.canvas) self.canvas.queue_resize()
class BaseVisualizer(object): visualizer_name = _('Base Visualizer') def __init__(self, canvas_panel, data, parent_frame): trigger(events.EVENT_VISUALIZER_DRAW, visualizer=self) self.conf = app_config # variables section self.canvas_panel = canvas_panel self.data = data self.processed_data = None self.frame = parent_frame self.events = app_events self.plots = [] self.vline = [] # calculate data self.process() # prepare canvas self.canvas_width, self.canvas_height = self.canvas_panel.Size figsize = (float(self.canvas_width) / self.conf.draw_dpi, self.conf.draw_figure_height * len(self.data)) self.fig = Figure( dpi=self.conf.draw_dpi, facecolor=self.conf.draw_facecolor, figsize=figsize ) self.canvas = FigCanvas(self.canvas_panel, -1, self.fig) # display controls self.draw() # bind events self.canvas_panel.Bind(wx.EVT_SIZE, self.evt_on_resize_panel) on(events.EVENT_VISUALIZER_DRAW, self.on_any_visualizer_draw) self.conf.on(events.EVENT_CHANGED_PARAMETER_key('draw_*'), self.on_config_changed) self.on('button_press_event', self.on_button_press_event) self.on('motion_notify_event', self.on_motion_notify_event) def create_cursor(self): if self.plots: self.cursor = MultiCursor(self.fig.canvas, self.plots, color=self.conf.draw_dynamic_cursor_color, lw=1) self.cursor.val_texts = [] for i, plot in enumerate(self.plots): val_text = plot.text(0.15, 1.04, '', transform=plot.transAxes, fontsize=9, color=self.conf.draw_dynamic_cursor_color) val_text.plot = plot val_text.data = self.processed_data[i] self.cursor.val_texts.append(val_text) def create_vline(self): for i, plot in enumerate(self.plots): line = plot.axvline(color=self.conf.draw_static_cursor_color) line.plot = plot line.data = self.processed_data[i] line.val_text = plot.text(0.05, 1.04, '', transform=plot.transAxes, fontsize=9, color=self.conf.draw_static_cursor_color) self.vline.append(line) def on(self, event, func): """ Canvas events """ self.fig.canvas.mpl_connect(event, func) def on_any_visualizer_draw(self, visualizer): if visualizer is not self: self.clear() self.conf.off(events.EVENT_CHANGED_PARAMETER_key('draw_*'), [self.on_config_changed]) def on_config_changed(self, key, value): if key in ('draw_position', 'draw_page_size'): self.update_plots() elif key in ('draw_dpi', 'draw_figure_height', 'draw_facecolor'): self.update_figure() elif key == 'draw_static_cursor_color': for line in self.vline: line.set_color(value) self.canvas.draw() elif key == 'draw_dynamic_cursor_color': for line in self.cursor.lines: line.set_color(value) self.canvas.draw() def on_button_press_event(self, event): self.update_vline(event) if event.inaxes is not None and self.canvas.widgetlock.available(self): self.events.trigger(events.EVENT_VISUALIZER_STATIC_CURSOR_CHANGED, plot_event=event, data=self.processed_data) def on_motion_notify_event(self, event): self.update_cursor_label(event) if event.inaxes is not None and self.canvas.widgetlock.available(self): self.events.trigger(events.EVENT_VISUALIZER_DYNAMIC_CURSOR_CHANGED, plot_event=event, data=self.processed_data) def evt_on_resize_panel(self, event): cur_width = self.canvas_panel.Size[0] if self.canvas_width != cur_width: self.canvas_width = cur_width self.fig.set_figwidth(float(self.canvas_width) / self.conf.draw_dpi) self.canvas_panel.Refresh() self.canvas.draw() def _prepare_static_cursor_value(self, data, event): return '(%.3f, %.3f)' % ( data.to_time(event.xdata), data.to_value(event.xdata)) def update_vline(self, event): if event.inaxes: for line in self.vline: line.set_xdata(event.xdata) line.val_text.set_text(self._prepare_static_cursor_value(line.data, event)) self.canvas.draw() def _prepare_dynamic_cursor_label(self, data, event): return '(%.3f, %.3f)' % ( data.to_time(event.xdata), data.to_value(event.xdata)) def update_cursor_label(self, event): if event.inaxes and False: #disabled for text in self.cursor.val_texts: text.set_text(self._prepare_dynamic_cursor_label(text.data, event)) self.canvas.draw() def update_plots(self): position = self.conf.draw_position page_size = self.conf.draw_page_size frame = (position - page_size if position > page_size else 0, position if position >= page_size else page_size) for plt in self.plots: plt.set_xlim(frame) self.canvas.draw() def update_figure(self): self.fig.set_dpi(self.conf.draw_dpi) self.fig.set_figheight(self.conf.draw_figure_height * len(self.data)) self.fig.set_facecolor(self.conf.draw_facecolor) self.canvas_panel.SetBackgroundColour(self.conf.draw_facecolor) self.canvas_panel.Update() self.canvas.draw() def create_aux(self): self.create_cursor() self.create_vline() self.canvas.figure.tight_layout() self.canvas_panel.update_scroll(self.canvas.Size) def draw(self): """Visualizes calculated data""" def clear(self): """Clear canvas""" self.canvas.figure.clear() self.canvas.draw() def process(self): """Calculates needed information""" self.processed_data = self.data def print_figure(self, path): """Export canvas into the file ``path``""" self.canvas.print_figure(path, dpi=self.conf.draw_dpi)
class Window(wx.Frame): global Monitor_Interval, y_Range def __init__(self, parent): super(Window, self).__init__(parent) self.InitUI() self.Centre() self.Show() self.SetIcon(wx.Icon('bitcoin_48px.ico', wx.BITMAP_TYPE_ICO)) self.taskBarIcon = TaskBarIcon(self) # create some sizers mainSizer = wx.BoxSizer(wx.VERTICAL) checkSizer = wx.BoxSizer(wx.HORIZONTAL) #事件绑定 self.Bind(wx.EVT_CLOSE, self.OnClose) self.Bind(wx.EVT_ICONIZE, self.OnIconfiy) # 最小化事件绑定 self.Bind(wx.EVT_PAINT, self.OnPaint) def InitUI(self): global initial_time, elapsed_time global Monitor_Interval, y_Range global Cur_Price, Max_Price, Min_Price, Price_Log, Counter #静态文本条 wx.StaticText(self, label='Top price:', pos=(30, 310 + 50)) wx.StaticText(self, label='Current price:', pos=(30, 330 + 50)) wx.StaticText(self, label='Floor price:', pos=(30, 350 + 50)) wx.StaticText(self, label='Current time:', pos=(210, 310 + 50)) wx.StaticText(self, label='Monitor interval:', pos=(210, 330 + 50)) wx.StaticText(self, label='Monitor time:', pos=(210, 350 + 50)) wx.StaticText(self, label='Network state:', pos=(30, 310)) wx.StaticText(self, label='Price trend:', pos=(210, 310)) #动态文本条 self.string_top_price = wx.StaticText(self, label='', pos=(130, 310 + 50)) self.string_price = wx.StaticText(self, label='', pos=(130, 330 + 50)) self.string_flr_price = wx.StaticText(self, label='', pos=(130, 350 + 50)) self.string_cur_time = wx.StaticText(self, label='', pos=(320, 310 + 50)) self.string_mon_gap = wx.StaticText(self, label='', pos=(320, 330 + 50)) self.string_elp_time = wx.StaticText(self, label='', pos=(320, 350 + 50)) self.string_network = wx.StaticText(self, label='', pos=(130, 310)) self.string_price_trend = wx.StaticText(self, label='', pos=(320, 310)) # 创建定时器 self.timer = wx.Timer(self) #创建定时器 self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer) #绑定一个定时器事件 self.SetSize((500, 480)) #窗口的颜色 self.SetBackgroundColour('#DCDCDC') #窗口的标题 self.SetTitle('Huobi Bitcoin price monitor Version 0.1') self.Centre() self.Show(True) #检查网络连接 if Check_Network() == 1: #查询价格,更新文本条 self.string_price.SetLabel(str(Get_Huobi_Price())) self.string_top_price.SetLabel(str(Max_Price)) self.string_flr_price.SetLabel(str(Min_Price)) #设置网络状态指示灯为绿色 self.string_network.SetLabel('ok') self.string_price_trend.SetLabel('unknow') else: self.string_price.SetLabel('0') self.string_top_price.SetLabel('0') self.string_flr_price.SetLabel('0') #设置网络状态指示灯为红色 self.string_network.SetLabel('error') self.string_price_trend.SetLabel('unknow') self.string_cur_time.SetLabel( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))) self.string_mon_gap.SetLabel( str(int(Monitor_Interval / 1000.0)) + ' s') initial_time = time.time() self.string_elp_time.SetLabel('0.00 mins') #绘制曲线相关,先生成画板 self.fig = Figure(facecolor='#DCDCDC') #设置背景色 self.fig.set_figheight(3) #设置Figure高度 self.fig.set_figwidth(5) #设置Figure宽度 # bind the Figure to the backend specific canvas self.canvas = FigureCanvas(self, wx.ID_ANY, self.fig) # add a subplot self.ax = self.fig.add_subplot(111) # limit the X and Y axes dimensions,以当前价格为中心,y_Range之内 self.ax.set_xlim([0, Curce_Points]) if y_Range == 1000: self.ax.set_ylim([Cur_Price - 500, Cur_Price + 500]) elif y_Range == 500: self.ax.set_ylim([Cur_Price - 250, Cur_Price + 250]) elif y_Range == 100: self.ax.set_ylim([Cur_Price - 50, Cur_Price + 50]) self.ax.set_autoscale_on(False) if Monitor_Interval == 1000 * 30: self.ax.set_xticks(np.linspace(0, 600, 7)) self.ax.set_xticklabels( ('300', '250', '200', '150', '100', '50', '0'), fontdict=font1) elif Monitor_Interval == 1000 * 10: self.ax.set_xticks(np.linspace(0, 600, 5)) self.ax.set_xticklabels(('100', '75', '50', '25', '0'), fontdict=font1) elif Monitor_Interval == 1000 * 60: self.ax.set_xticks(np.linspace(0, 600, 7)) self.ax.set_xticklabels( ('600', '500', '400', '300', '200', '100', '0'), fontdict=font1) elif Monitor_Interval == 1000 * 60 * 5: self.ax.set_xticks(np.linspace(0, 600, 7)) self.ax.set_xticklabels( ('3000', '2500', '2000', '1500', '1000', '500', '0'), fontdict=font1) if y_Range == 1000: self.ax.set_yticks( range(Cur_Price - 500 - 1, Cur_Price + 500 + 1, 100)) tem_array = tuple( range(Cur_Price - 500 - 1, Cur_Price + 500 + 1, 100)) elif y_Range == 500: self.ax.set_yticks( range(Cur_Price - 250 - 1, Cur_Price + 250 + 1, 50)) tem_array = tuple( range(Cur_Price - 250 - 1, Cur_Price + 250 + 1, 50)) elif y_Range == 100: self.ax.set_yticks( range(Cur_Price - 50 - 1, Cur_Price + 50 + 1, 10)) tem_array = tuple(range(Cur_Price - 50 - 1, Cur_Price + 50 + 1, 10)) self.ax.set_yticklabels(tem_array, fontdict=font1) #曲线图边框的颜色,本程序选择橘黄色 self.ax.spines['left'].set_color('#FF9000') self.ax.spines['right'].set_color('#FF9000') self.ax.spines['top'].set_color('#FF9000') self.ax.spines['bottom'].set_color('#FF9000') #坐标轴刻度朝向,颜色,长度,以及宽度 self.ax.tick_params(axis='x', direction='in', colors='black', length=4, width=1) self.ax.tick_params(axis='y', direction='in', colors='black', length=5, width=1) #网格线 self.ax.grid(True) # generates first "empty" plots self.user = [None] * Curce_Points self.l_user, = self.ax.plot(range(Curce_Points)) #图例(此处已关闭) ###self.l_user,=self.ax.plot(range(Curce_Points),self.user,label='Price curve of Bitcoin') ##self.ax.legend(loc='upper center',ncol=4,prop=font_manager.FontProperties(size=9)) # force a draw on the canvas() trick to show the grid and the legend self.canvas.draw() # save the clean background - everything but the line is drawn and saved in the pixel buffer background self.bg = self.canvas.copy_from_bbox(self.ax.bbox) # bind events coming from timer with id = TIMER_ID to the onTimer callback function wx.EVT_TIMER(self, TIMER_ID, self.OnTimer) def __del__(self): pass def OnTimer(self, evt): #显示时间事件处理函数 global Cur_Price, Max_Price, Min_Price, Price_Log, Counter global initial_time, elapsed_time global Network_State #检查网络状态,只有网络连通了,才调用价格查询子程序 if Check_Network() == 1: Cur_Price = Get_Huobi_Price() #网络状态指示灯绿色 self.string_network.SetLabel('ok') else: print('no network') #网络状态指示灯红色 self.string_network.SetLabel('error') self.string_price.SetLabel(str(Cur_Price)) self.string_top_price.SetLabel(str(Max_Price)) self.string_flr_price.SetLabel(str(Min_Price)) self.string_cur_time.SetLabel( time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))) self.string_mon_gap.SetLabel( str(int(Monitor_Interval / 1000.0)) + ' s') elapsed_time = time.time() - initial_time self.string_elp_time.SetLabel( str(round(elapsed_time / 60, 2)) + ' mins') # 转换成分钟,保留2位有效数字 #价格趋势rise或者fall或者unchanged if Cur_Price > Price_Log[Counter - 1]: self.string_price_trend.SetLabel('rise') elif Cur_Price == Price_Log[Counter - 1]: self.string_price_trend.SetLabel('unchanged') else: self.string_price_trend.SetLabel('fall') #绘制曲线 self.canvas.restore_region(self.bg) #更新曲线数据 temp = Cur_Price self.user = self.user[1:] + [temp] # update the plot self.l_user.set_ydata(self.user) # just draw the "animated" objects self.ax.draw_artist( self.l_user ) # It is used to efficiently update Axes data (axis ticks, labels, etc are not updated) self.canvas.blit(self.ax.bbox) def OnPaint(self, event=None): dc = wx.PaintDC(self) dc.Clear() pen = wx.Pen('#808A87', 1, wx.SOLID) #1表示线宽 dc.SetPen(pen) dc.DrawLine(0, 300, 500, 300) dc.SetPen(pen) dc.DrawLine(0, 340, 500, 340) def OnHide(self, event): self.Hide() def OnIconfiy(self, event): event.Skip() self.Hide() def OnClose(self, event): self.taskBarIcon.Destroy() self.Destroy()
def plot(): print "plotting" import StringIO import matplotlib.pyplot as plt import matplotlib.patches as mpatches from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from matplotlib.dates import DateFormatter sampleRate = 44100 hopSize = 128 # intro db = get_db() cur = get_db().cursor() # ip_addr = request.environ['REMOTE_ADDR'] ip_addr = str(request.headers.get('X-Real-IP')) # making sure that this IP Address already has a row cur.execute('SELECT count(*) FROM data WHERE ip_addr=?', (ip_addr, )) count = cur.fetchone()[0] if count == 0: error_msg = "IP Address not found" close_connection(error_msg) return error_msg ### get info needed to plot cur.execute('SELECT original_audio_str FROM data WHERE ip_addr=?', (ip_addr, )) original_audio_str = cur.fetchone()[0] # has brackets cur.execute('SELECT pitchesmelody_verb_str FROM data WHERE ip_addr=?', (ip_addr, )) pitchesmelody_verb_str = cur.fetchone()[0] cur.execute('SELECT melody_midi_str FROM data WHERE ip_addr=?', (ip_addr, )) melody_midi_str = cur.fetchone()[0] cur.execute('SELECT onset_times_str FROM data WHERE ip_addr=?', (ip_addr, )) onset_times_str = cur.fetchone()[0] # outro db.commit() close_connection("Normal") # strip brackets to convert to np.array original_audio_str = original_audio_str.strip('[') original_audio_str = original_audio_str.strip(']') original_np = np.fromstring(original_audio_str, sep=',') # converting into np.array pitchesmelody_verb = np.fromstring(pitchesmelody_verb_str, sep=',') melody_midi = np.fromstring(melody_midi_str, sep=',') onset_times = np.fromstring(onset_times_str, sep=',') #num timestamps = num results from detector dur = librosa.get_duration(original_np, sr=sampleRate) #in seconds timestamps = np.linspace(0.0, dur, len(pitchesmelody_verb)) fig = Figure() fig.set_figheight(9) fig.set_figwidth(15) ax0 = fig.add_subplot(211) ax1 = fig.add_subplot(212) fig.subplots_adjust(hspace=0.4) # f, axarr = plt.subplots(2, figsize=(15,9)) green_patch = mpatches.Patch(color='green', label='Detected onsets') black_patch = mpatches.Patch(color='black', label='Detected pitches') # ax0 is for pitch detection results ax0.legend(handles=[green_patch, black_patch]) ax0.scatter(timestamps, pitchesmelody_verb) ax0.set_title('Pitch Detected Results') ax0.set_ylabel('MIDI Note Number') ax0.set_xlabel('Time (s)') xmin = 0.0 xmax = dur ymin = 50.0 ymax = 80.0 ax0.axis([xmin, xmax, ymin, ymax]) ax0.vlines(onset_times, ymin, ymax, colors='green') #for the first silence s = 0.0 e = onset_times[0] ax0.text(s + (e - s) / 3.5, ymin + (ymax - ymin) / 2.0, "sil", color='black') for ii in range(0, len(melody_midi)): s = 0.0 e = dur #for the last segment if ii == len(melody_midi) - 1: s = onset_times[ii] #for the middle else: s = onset_times[ii] e = onset_times[ii + 1] #if melody note is nan if str(melody_midi[ii]) == "nan": ax0.text(s + (e - s) / 3.5, ymin + (ymax - ymin) / 2.0, "nan", color='black') continue ax0.hlines(melody_midi[ii], s, e, colors='black') ax0.text(s + (e - s) / 3.5, ymin + (ymax - ymin) / 2.0, str(round(melody_midi[ii], 1)), color='black') # ax1 is for original audio timestamps = np.linspace(0.0, dur, len(original_np)) ax1.legend(handles=[green_patch]) ax1.plot(timestamps, original_np) ax1.set_title('Original Waveform') ax1.set_ylabel('Amplitude') ax1.set_xlabel('Time (s)') xmin = 0.0 xmax = dur ymin = -1.0 ymax = 1.0 ax1.axis([xmin, xmax, ymin, ymax]) ax1.vlines(onset_times, ymin, ymax, colors='green') # displaying it canvas = FigureCanvas(fig) png_output = StringIO.StringIO() canvas.print_png(png_output) response = make_response(png_output.getvalue()) response.headers['Content-Type'] = 'image/png' return response
class FigurePanel(wx.Panel): def __init__(self, parent): wx.Panel.__init__(self, parent) self.SetBackgroundColour('#DCE5EE') pub().subscribe(self.update_language, T.LANGUAGE_CHANGED) self.control_panel = None self.dframes = [] self.order_names = [] self.key_figure = 1 self.mode_run = False self.current_dataframes = None self.current_datacolors = None self.run_explorer = False self.figure_config_dialog_ref = None # ---- inicialización de figura self.fig = Figure() self.canvas = FigureCanvas(self, -1, self.fig) # ---- configuración de figura self.fig_config = FigureConfig() self.set_figure_config() # ---- configuración de axe self.ax_conf = AxesConfig() # ---- radar chard config self.radar_chard_con = RadarChadConfig() # ---- toolbar self.sizer_tool = wx.BoxSizer(wx.HORIZONTAL) _bitmap = play_fig.GetBitmap() self.b_play = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER) self.sizer_tool.Add(self.b_play, flag=wx.ALIGN_CENTER_VERTICAL) self.b_play.Bind(wx.EVT_BUTTON, self.on_play) self.b_play.SetToolTipString(L('VISUALIZE_DATE_CLUSTER')) _bitmap = settings_fig.GetBitmap() self.b_setting = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER) self.sizer_tool.Add(self.b_setting, flag=wx.ALIGN_CENTER_VERTICAL) self.b_setting.Bind(wx.EVT_BUTTON, self.on_config) self.b_setting.SetToolTipString(L('FIGURE_CONF')) _bitmap = sort_and_filter.GetBitmap() self.b_sorted = wx.BitmapButton(self, -1, _bitmap, style=wx.NO_BORDER) self.b_sorted.Bind(wx.EVT_BUTTON, self.on_sort_and_filter) self.b_sorted.SetToolTipString(L('BUTTON_ORDER_AND_FILTER')) self.b_sorted.Disable() self.sizer_tool.Add(self.b_sorted, 0, wx.ALIGN_CENTER_VERTICAL) _bp = line_highligh.GetBitmap() self.b_highligh = wx.BitmapButton(self, -1, _bp, style=wx.NO_BORDER) self.b_highligh.Bind(wx.EVT_BUTTON, self.on_highligh) self.b_highligh.SetToolTipString(L('BUTTON_HIGHLIGHT')) self.b_highligh.Disable() self.sizer_tool.Add(self.b_highligh, 0, wx.ALIGN_CENTER_VERTICAL) self.toolbar = Toolbar(self.canvas) self.toolbar.Realize() self.toolbar.SetBackgroundColour('#DCE5EE') self.sizer_tool.Add(self.toolbar, 0, wx.ALIGN_CENTER_VERTICAL) choice_grafic = self.get_choice_grafic() self.sizer_tool.Add(choice_grafic, wx.ALIGN_LEFT) self.sizer = wx.BoxSizer(wx.VERTICAL) self.sizer.Add(self.sizer_tool, 0, wx.EXPAND) self.sizer.Add(self.canvas, 1, wx.EXPAND) self.SetSizer(self.sizer) self.Fit() self._welcome() def _welcome(self): Axes3D(self.fig) def set_figure_config(self): self.fig.set_figwidth(self.fig_config.width) self.fig.set_figheight(self.fig_config.height) self.fig.set_facecolor(self.fig_config.facecolor) left = self.fig_config.subplot_left bottom = self.fig_config.subplot_bottom right = self.fig_config.subplot_right top = self.fig_config.subplot_top wspace = self.fig_config.subplot_wspace hspace = self.fig_config.subplot_hspace self.fig.subplots_adjust(left, bottom, right, top, wspace, hspace) self.fig.suptitle('Tava Tool', fontsize=14, fontweight='light', style='italic', family='serif', color='c', horizontalalignment='center', verticalalignment='center') def draw_graphic(self, dframes, colors): key_figure = self.g_figure() if key_figure == K_PARALLEL_COORDENATE: return kparallelcoordinates(dframes, 'Name', self.fig, self.ax_conf, self.fig_config, colors) elif key_figure == K_RADAR_CHART_POLYGON: return radarchart(dframes, 'Name', self.fig, self.ax_conf, self.radar_chard_con, colors) elif key_figure == K_RADVIZ: return kradviz(dframes, 'Name', self.fig, self.ax_conf, colors) def kdraw(self, dframes, colors, ldic): self.current_dataframes = dframes self.current_datacolors = colors self.ldic = ldic self._kdraw(dframes, colors) def pre_kdraw_order(self, names_ordered): names_ordered.append('Name') _dframes = [] for df in self.current_dataframes: _dframes.append(df[names_ordered]) self._kdraw(_dframes, self.current_datacolors) def _kdraw(self, dframes, colors): self.fig.clear() self.start_busy() task = DrawThread(self, dframes, colors) task.start() def on_play(self, event): self.mode_run = True self.run_explorer = True self.new_order = [] # ---- dibujar clusters/datos seleccionados self.control_panel.run_fig() def on_sort_and_filter(self, event): self.run_explorer = True cdf = self.current_dataframes if cdf is None or cdf == []: return self.old_order = cdf[0].columns.tolist()[:-1] ItemsPickerFilterDialog(self, self.old_order) def on_highligh(self, event): _label_aux = '' if self.run_explorer: for axe in self.fig.get_axes(): lines = [] for line in axe.get_children(): if isinstance(line, Line2D): if self.ldic.get(line.get_color()) is not None: _label_aux = self.ldic.get(line.get_color()) line.set_label('shape = ' + self.ldic.get(line.get_color())) lines.append(line) else: line.set_label('') h = resaltar(lines, highlight_color=self.ax_conf.highlight_color, formatter='{label}'.format) if lines != []: h.show_highlight(lines[0]) self.run_explorer = False self.canvas_draw() def on_config(self, event): if self.figure_config_dialog_ref is None: self.figure_config_dialog_ref = FigureConfigDialog(self) else: self.figure_config_dialog_ref.nb.SetSelection(0) self.figure_config_dialog_ref.ShowModal() def g_figure(self): return self.ch_graph.GetSelection() def get_choice_grafic(self): grid = wx.FlexGridSizer(cols=2) sampleList = self.get_item_list() self.ch_graph = wx.Choice(self, -1, choices=sampleList) self.ch_graph.SetSelection(0) self.ch_graph.Bind(wx.EVT_CHOICE, self.on_graphic) self.ch_graph.SetToolTipString(L('SELECT_A_GRAPHIC')) grid.Add(self.ch_graph, 0, wx.ALIGN_LEFT | wx.ALL, 5) return grid def get_item_list(self): return [L('PARALLEL_COORDINATES'), 'Radar Chart'] def on_graphic(self, event): if event.GetString() != L('PARALLEL_COORDINATES') or not self.mode_run: self.b_highligh.Disable() return self.b_highligh.Enable() def update_language(self, msg): s = self.ch_graph.GetSelection() self.ch_graph.SetItems(self.get_item_list()) self.ch_graph.SetSelection(s) self.ch_graph.SetToolTipString(L('SELECT_A_GRAPHIC')) self.b_setting.SetToolTipString(L('FIGURE_CONF')) self.b_play.SetToolTipString(L('VISUALIZE_DATE_CLUSTER')) def start_busy(self): pub().sendMessage(T.START_BUSY) self.b_play.Disable() self.toolbar.Disable() self.b_setting.Disable() self.ch_graph.Disable() self.b_highligh.Disable() self.b_sorted.Disable() def stop_busy(self): pub().sendMessage(T.STOP_BUSY) self.b_play.Enable() self.toolbar.Enable() self.b_setting.Enable() self.ch_graph.Enable() self.b_highligh.Enable() self.b_sorted.Enable() def canvas_draw(self): self.canvas.draw() def set_fig(self, fig): self.fig = fig
class PlotWidget(custom_result.ResultWidget): __gsignals__ = { 'button-press-event': 'override', 'button-release-event': 'override', 'expose-event': 'override', 'size-allocate': 'override', 'unrealize': 'override' } def __init__(self, result): custom_result.ResultWidget.__init__(self) figsize=(DEFAULT_FIGURE_WIDTH, DEFAULT_FIGURE_HEIGHT) self.figure = Figure(facecolor='white', figsize=figsize) self.canvas = _PlotResultCanvas(self.figure) self.axes = self.figure.add_subplot(111) self.add_events(gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE) self.cached_contents = None self.sidebar_width = -1 def do_expose_event(self, event): cr = self.window.cairo_create() if not self.cached_contents: self.cached_contents = cr.get_target().create_similar(cairo.CONTENT_COLOR, self.allocation.width, self.allocation.height) renderer = RendererCairo(self.figure.dpi) renderer.set_width_height(self.allocation.width, self.allocation.height) renderer.set_ctx_from_surface(self.cached_contents) self.figure.draw(renderer) # event.region is not bound: http://bugzilla.gnome.org/show_bug.cgi?id=487158 # gdk_context = gtk.gdk.CairoContext(renderer.ctx) # gdk_context.region(event.region) # gdk_context.clip() cr.set_source_surface(self.cached_contents, 0, 0) cr.paint() def do_size_allocate(self, allocation): if allocation.width != self.allocation.width or allocation.height != self.allocation.height: self.cached_contents = None gtk.DrawingArea.do_size_allocate(self, allocation) def do_unrealize(self): gtk.DrawingArea.do_unrealize(self) self.cached_contents = None def do_button_press_event(self, event): if event.button == 3: custom_result.show_menu(self, event, save_callback=self.__save) return True else: return True def do_button_release_event(self, event): return True def do_realize(self): gtk.DrawingArea.do_realize(self) cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR) self.window.set_cursor(cursor) def do_size_request(self, requisition): try: # matplotlib < 0.98 requisition.width = self.figure.bbox.width() requisition.height = self.figure.bbox.height() except TypeError: # matplotlib >= 0.98 requisition.width = self.figure.bbox.width requisition.height = self.figure.bbox.height def recompute_figure_size(self): width = (self.sidebar_width / self.figure.dpi) height = width / DEFAULT_ASPECT_RATIO self.figure.set_figwidth(width) self.figure.set_figheight(height) self.queue_resize() def sync_dpi(self, dpi): self.figure.set_dpi(dpi) if self.sidebar_width >= 0: self.recompute_figure_size() def set_sidebar_width(self, width): if self.sidebar_width == width: return self.sidebar_width = width if self.sidebar_width >= 0: self.recompute_figure_size() def sync_style(self, style): self.cached_contents = None matplotlib.rcParams['font.size'] = self.parent.style.font_desc.get_size() / pango.SCALE def __save(self, filename): # The save/restore here was added to matplotlib's after 0.90. We duplicate # it for compatibility with older versions. (The code would need modification # for 0.98 and newer, which is the reason for the particular version in the # check) version = [int(x) for x in matplotlib.__version__.split('.')] need_save = version[:2] < [0, 98] if need_save: orig_dpi = self.figure.dpi.get() orig_facecolor = self.figure.get_facecolor() orig_edgecolor = self.figure.get_edgecolor() try: self.canvas.print_figure(filename) finally: if need_save: self.figure.dpi.set(orig_dpi) self.figure.set_facecolor(orig_facecolor) self.figure.set_edgecolor(orig_edgecolor) self.figure.set_canvas(self.canvas)
def show_stamps(pscs, frame_idx=None, stamp_size=11, show_residual=False, stretch=None, save_name=None, show_max=False, show_pixel_grid=False, **kwargs): ncols = len(pscs) if show_residual: ncols += 1 nrows = 1 fig = Figure() FigureCanvas(fig) fig.set_figheight(4) fig.set_figwidth(8) if frame_idx is not None: s0 = pscs[0][frame_idx] s1 = pscs[1][frame_idx] else: s0 = pscs[0] s1 = pscs[1] if stretch == 'log': stretch = LogStretch() else: stretch = LinearStretch() norm = ImageNormalize(s0, interval=MinMaxInterval(), stretch=stretch) ax1 = fig.add_subplot(nrows, ncols, 1) im = ax1.imshow(s0, cmap=get_palette(), norm=norm) # create an axes on the right side of ax. The width of cax will be 5% # of ax and the padding between cax and ax will be fixed at 0.05 inch. # https://stackoverflow.com/questions/18195758/set-matplotlib-colorbar-size-to-match-graph divider = make_axes_locatable(ax1) cax = divider.append_axes("right", size="5%", pad=0.05) fig.colorbar(im, cax=cax) ax1.set_title('Target') # Comparison ax2 = fig.add_subplot(nrows, ncols, 2) im = ax2.imshow(s1, cmap=get_palette(), norm=norm) divider = make_axes_locatable(ax2) cax = divider.append_axes("right", size="5%", pad=0.05) fig.colorbar(im, cax=cax) ax2.set_title('Comparison') if show_pixel_grid: add_pixel_grid(ax1, stamp_size, stamp_size, show_superpixel=False) add_pixel_grid(ax2, stamp_size, stamp_size, show_superpixel=False) if show_residual: ax3 = fig.add_subplot(nrows, ncols, 3) # Residual residual = s0 - s1 im = ax3.imshow(residual, cmap=get_palette(), norm=ImageNormalize(residual, interval=MinMaxInterval(), stretch=LinearStretch())) divider = make_axes_locatable(ax3) cax = divider.append_axes("right", size="5%", pad=0.05) fig.colorbar(im, cax=cax) ax3.set_title('Noise Residual') ax3.set_title('Residual RMS: {:.01%}'.format(residual.std())) ax3.set_yticklabels([]) ax3.set_xticklabels([]) if show_pixel_grid: add_pixel_grid(ax1, stamp_size, stamp_size, show_superpixel=False) # Turn off tick labels ax1.set_yticklabels([]) ax1.set_xticklabels([]) ax2.set_yticklabels([]) ax2.set_xticklabels([]) if save_name: try: fig.savefig(save_name) except Exception as e: warn("Can't save figure: {}".format(e)) return fig
class pyOM_gui(Tkinter.Frame, pyOM_ave): """ pyOM with graphical user interface """ def __init__(self): """ initialize windows, etc """ pyOM_ave.__init__(self) M = self.fortran.main_module self.halt = 1 self.semaphore = [ 'timestep', 'quit', 'snapshot', 'average', 'read_restart', 'write_restart', 'user_defined' ] if M.my_pe == 0: self.pyOM_vstr = 'pyOM v%2.1f' % self.pyOM_version Tkinter.Frame.__init__(self, master=None) self.pack(expand=Tkinter.YES) self.master.title(self.pyOM_vstr) self.master.protocol('WM_DELETE_WINDOW', self.quit) # the menu menubar = Tkinter.Menu(self) menu = Tkinter.Menu(menubar, tearoff=0) menu.add_command(label="Read restart file", command=self.read) menu.add_command(label="Write restart file", command=self.write) menu.add_command(label="Save plot to file", command=self.printplot) menu.add_separator() menu.add_command(label="Exit", command=self.quit) menubar.add_cascade(label="File", menu=menu) menu = Tkinter.Menu(menubar, tearoff=0) menu.add_command(label="Start integration", command=self.start) menu.add_command(label="Stop integration", command=self.stop) menu.add_command(label="Reset integration", command=self.reset) menu.add_command(label="Plot", command=self.plot) menubar.add_cascade(label="Control", menu=menu) menu = Tkinter.Menu(menubar, tearoff=0) menu.add_command(label="Shell", command=self.shell) menu.add_command(label="Config", command=self.config) menubar.add_cascade(label="Options", menu=menu) self.master.config(menu=menubar) # plotting area on window self.image_height = 500 self.image_width = 800 self.main_area = Tkinter.Canvas(self, height=self.image_height, width=self.image_width) self.main_area.pack(side=Tkinter.TOP) # text area on window self.time_step_list = ScrolledText.ScrolledText( self, height=5, state=Tkinter.NORMAL, bd=2) self.time_step_list.pack(side=Tkinter.TOP, fill=Tkinter.X, expand=Tkinter.YES) # write some text self.time_step_list.insert(Tkinter.END, 'Welcome to %s\n\n' % self.pyOM_vstr) self.time_step_list.insert( Tkinter.END, 'grid size : nx=%i ny=%i nz=%i \n' % (M.nx, M.ny, M.nz)) self.time_step_list.insert(Tkinter.END, 'time step : %f s\n' % M.dt_tracer) self.time_step_list.insert(Tkinter.END, 'Number of PEs : %i \n' % M.n_pes) self.time_step_list.yview(Tkinter.MOVETO, 1) self.time_step_list.config(state=Tkinter.DISABLED) # Toolbar area on window Toolbar = Tkinter.Frame(self, relief=Tkinter.SUNKEN, bd=2) Toolbar.pack(side=Tkinter.TOP, expand=Tkinter.YES, fill=Tkinter.X) self.snapint = Tkinter.IntVar() #; self.snapint.set(0) self.plotint = Tkinter.IntVar() #; self.plotint.set(0) self.image_button1 = Tkinter.PhotoImage( master=Toolbar, file=os.path.join(matplotlib.rcParams['datapath'], 'images', 'forward.png')) self.image_button2 = Tkinter.PhotoImage( master=Toolbar, file=os.path.join(matplotlib.rcParams['datapath'], 'images', 'hand.png')) # start/stop button self.itt_str = Tkinter.StringVar() F = Tkinter.Frame(Toolbar) F.pack(side=Tkinter.LEFT) Tkinter.Label(F, text=self.pyOM_vstr, width=18).pack(side=Tkinter.TOP, anchor='w') Tkinter.Label(F, textvariable=self.itt_str, width=18).pack(side=Tkinter.TOP, anchor='w') Tkinter.Button(Toolbar, text="Run", image=self.image_button1, command=self.start).pack(side=Tkinter.LEFT) Tkinter.Button(Toolbar, text="Stop", image=self.image_button2, command=self.stop).pack(side=Tkinter.LEFT) # scale bars for diag/plotting intervals self.aveint = Tkinter.IntVar() #; self.plotint.set(0) Tkinter.Scale(Toolbar,variable = self.aveint,label="averaging interval", length=120, \ from_ = 1, to = 500, orient=Tkinter.HORIZONTAL).pack(side=Tkinter.LEFT) Tkinter.Scale(Toolbar,variable = self.snapint,label="snapshot interval", length=120, \ from_ = 1, to = 500, orient=Tkinter.HORIZONTAL).pack(side=Tkinter.LEFT) B = Tkinter.Checkbutton(Toolbar, command=self.scale_both) B.select() B.pack(side=Tkinter.LEFT) self.scale_bar = Tkinter.Scale(Toolbar,variable = self.plotint,label="plotting interval", length=120, \ from_ = 1, to = 500, orient=Tkinter.HORIZONTAL) self.scale_bar.pack(side=Tkinter.LEFT, padx=15) # buttons to disable plotting/snapshot F = Tkinter.Frame(Toolbar) F.pack(side=Tkinter.LEFT) self.enable_plotting = Tkinter.IntVar() self.enable_plotting.set(1) if not hasattr(self, 'make_plot'): self.enable_plotting.set(0) Tkinter.Checkbutton(F, text='enable plotting', variable=self.enable_plotting).pack( side=Tkinter.TOP, anchor='w') self.enable_snapshot = Tkinter.IntVar() self.enable_snapshot.set(0) Tkinter.Checkbutton(F, text='enable snaphots', variable=self.enable_snapshot).pack( side=Tkinter.TOP, anchor='w') self.enable_average = Tkinter.IntVar() self.enable_average.set(0) Tkinter.Checkbutton(F, text='enable averaging', variable=self.enable_average).pack( side=Tkinter.TOP, anchor='w') # Figure size self.figure = Figure() self.figure.set_figwidth( float(self.image_width) / self.figure.get_dpi()) self.figure.set_figheight( float(self.image_height) / self.figure.get_dpi()) self.figure.text(0.5, 0.5, self.pyOM_vstr, ha='center', va='center', fontsize='xx-large', color='darkblue') # first plot and animate self.itt_str.set('time step %i' % M.itt) self.time = M.itt * M.dt_tracer self.shell_on = False self.run = self.mainloop return def set_signal(self, cmd): """ send a signal to other PEs, only called by PE0 """ i = numpy.zeros((1, ), numpy.intc, order='F') i[0] = self.semaphore.index(cmd) self.fortran.pe0_bcast_int(i) return def get_signal(self): """ get a signal from PE 0 """ i = numpy.zeros((1, ), numpy.intc, order='F') self.fortran.pe0_bcast_int(i) i = int(i[0]) if i > len(self.semaphore) or i < 0: raise pyOMError('wrong signal in get_signal') return self.semaphore[i] def mainloop(self, snapint=None, runlen=None): """ enter main loop """ M = self.fortran.main_module if M.my_pe == 0: if snapint: self.snapint.set( int(snapint / self.fortran.main_module.dt_tracer)) self.aveint.set( int(snapint / self.fortran.main_module.dt_tracer)) self.scale_both() #if M.itt >0: # self.ani = animation.FuncAnimation(self.figure,self.plot(), interval=0) #else: self.plot() Tkinter.mainloop( ) # PE0 will only return when quit button is hit, it is now event driven else: stop = False while not stop: # other PEs have to listen to signals from event driven PE0 cmd = self.get_signal() if cmd == 'timestep': self.fortran.pe0_bcast_int(M.itt) self.time_step() self.time_goes_by() elif cmd == 'quit': stop = True elif cmd == 'snapshot': self.write_snap_cdf() elif cmd == 'average': self.write_average_cdf() elif cmd == 'read_restart': self.read_restart() elif cmd == 'write_restart': self.write_restart() elif cmd == 'user_defined': self.user_defined_signal() else: raise pyOMError(' wrong signal in mainloop') return def user_defined_signal(self): """ dummy routine, which can be overloaded """ return def one_time_step(self): """ enter a simple model time stepping loop, only for PE0 """ if not self.halt: M = self.fortran.main_module M.itt = M.itt + 1 self.itt_str.set('time step %i' % M.itt) self.time = M.itt * M.dt_tracer self.set_signal('timestep') self.fortran.pe0_bcast_int(M.itt) self.time_step() if numpy.mod( M.itt, self.aveint.get()) == 0 and self.enable_average.get() == 1: self.do_average() if numpy.mod(M.itt, self.snapint.get() ) == 0 and self.enable_snapshot.get() == 1: self.do_snapshot() if numpy.mod(M.itt, self.plotint.get() ) == 0 and self.enable_plotting.get() == 1: self.plot() self.time_goes_by() self.after(1, self.one_time_step) return def start(self): """ start integration """ if self.halt == 1: self.halt = 0 self.print_text('\ncontinue model integration') self.one_time_step() return def stop(self): """ stop integration """ if self.halt == 0: self.halt = 1 self.print_text('\nstopping model integration') return def do_average(self): text = '\nwriting average at %12.4es solver itts=%i' % ( self.time, self.fortran.main_module.congr_itts) self.print_text(text) self.set_signal('average') self.write_average_cdf() return def do_snapshot(self): """ writing a snapshot """ text = '\nwriting a snapshot at %12.4es solver itts=%i' % ( self.time, self.fortran.main_module.congr_itts) self.print_text(text) self.set_signal('snapshot') self.write_snap_cdf() return def plot(self): """ make a plot """ M = self.fortran.main_module # fortran module with model variables text = '\nplotting at %12.4es solver itts=%i' % (self.time, M.congr_itts) if not M.enable_hydrostatic: text = text + ' (non hydro itts=%i)' % M.congr_itts_non_hydro self.print_text(text) if hasattr(self, 'make_plot'): self.make_plot() else: self.print_text('\ncannot plot: missing method make_plot') self.figcanvas = FigureCanvasTkAgg(self.figure, self.main_area) self.figcanvas.get_tk_widget().grid(row=0, column=0) return def scale_both(self): """ scale button for snapshort and snapshot intervall identical """ if self.snapint == self.plotint: self.plotint = Tkinter.IntVar() self.plotint.set(self.snapint.get()) self.scale_bar.config(variable=self.plotint, state=Tkinter.NORMAL) else: self.scale_bar.config(variable=self.snapint, state=Tkinter.DISABLED) self.plotint = self.snapint return def print_text(self, s): """ print text string s in window """ self.time_step_list.config(state=Tkinter.NORMAL) self.time_step_list.insert(Tkinter.END, s) self.time_step_list.yview(Tkinter.MOVETO, 1) self.time_step_list.config(state=Tkinter.DISABLED) return def printplot(self): """ message box """ tkMessageBox.showinfo("Info", "not yet implemented") return def quit(self): """ Quit message box """ if tkMessageBox.askokcancel(title='Quit', message='Exit pyOM?'): self.set_signal('quit') Tkinter.Frame.quit(self) return def reset(self): """ reset integration, show box """ self.stop() self.set_initial_conditions() self.fortran.calc_initial_conditions() self.plot() return def read(self): """ to read restart open file dialog """ #file=tkFileDialog.askopenfilename() #if file: # self.halt=1 # self.print_text('\nreading restart file %s' %file) # self.read_restart(file) self.halt = 1 self.set_signal('read_restart') self.read_restart() return def write(self): """ to write restart open file dialog """ self.halt = 1 self.print_text('\nstopping model integration') #file=tkFileDialog.asksaveasfilename(initialfile='restart.dta') #if file: # self.print_text('\nwriting restart to file %s' %file) # self.write_restart(file) self.set_signal('write_restart') self.write_restart() return def config(self): if hasattr(self, 'config_setup'): self.config_window = Tkinter.Toplevel() self.config_window.protocol('WM_DELETE_WINDOW', self.quit) self.config_frame = Tkinter.Frame(self.config_window) self.config_frame.pack() #Tkinter.Label(self.config_frame,text='Config').pack(side=Tkinter.TOP) self.config_setup() # add widgets to frame else: tkMessageBox.showinfo("Info", "method config_setup not found") return # rest is this shell def shell(self): if self.shell_on: self.shell_window.destroy() self.shell_on = False else: self.shell_window = Tkinter.Toplevel() self.shell_window.protocol('WM_DELETE_WINDOW', self.quit) fo = ("Times", 12) self.display = ScrolledText.ScrolledText(self.shell_window, width=80, font=fo) self.display.pack() self.command = Tkinter.StringVar() self.command.set('') if not hasattr(self, 'commandlist'): self.commandlist = [''] self.command_pointer = 0 self.entry = Tkinter.Entry(self.display, textvariable=self.command, width=77, font=fo, bd=0) self.entry.config(highlightthickness=0) self.display.config(state=Tkinter.NORMAL) self.display.insert(Tkinter.END, '\n Welcome to %s \n\n' % self.pyOM_vstr) self.display.insert(Tkinter.END, '>>') self.display.see(Tkinter.END) self.display.window_create(Tkinter.END, window=self.entry) self.display.config(state=Tkinter.DISABLED) self.entry.bind(sequence="<Return>", func=self.command_process) self.entry.bind(sequence="<Up>", func=self.command_up) self.entry.bind(sequence="<Down>", func=self.command_down) self.entry.focus_set() self.entry.icursor(Tkinter.END) self.shell_on = True if not hasattr(self, 'command_locals'): self.set_command_locals() return def set_command_locals(self): M = self.fortran.main_module # fortran module with model variables import matplotlib.pyplot as plt self.command_locals = locals() return def command_up(self, args): self.command_pointer = max(0, self.command_pointer - 1) self.command.set(self.commandlist[self.command_pointer]) self.entry.icursor(Tkinter.END) def command_down(self, args): self.command_pointer = min(len(self.commandlist), self.command_pointer + 1) if self.command_pointer == len(self.commandlist): self.command.set('') else: self.command.set(self.commandlist[self.command_pointer]) self.entry.icursor(Tkinter.END) def command_process(self, args): import sys try: from StringIO import StringIO ## for Python 2 except ImportError: from io import StringIO ## for Python 3 self.sendToDisplay('>>' + self.command.get() + "\n") if self.command.get() != '': self.commandlist.append(self.command.get()) self.command_pointer = len(self.commandlist) b1 = sys.stderr b2 = sys.stdout sys.stderr = StringIO() sys.stdout = StringIO() c = code.InteractiveInterpreter(self.command_locals) c.runsource(self.command.get()) self.sendToDisplay(sys.stderr.getvalue()) self.sendToDisplay(sys.stdout.getvalue()) sys.stderr = b1 sys.stdout = b2 self.command.set('') return def sendToDisplay(self, string): self.display.config(state=Tkinter.NORMAL) self.display.insert(Tkinter.END + '-4 chars', string) self.display.see(Tkinter.END) self.display.config(state=Tkinter.DISABLED) return
def quiver_response(lon, lat, dx, dy, request, dpi=None): dpi = dpi or 80. bbox = request.GET['bbox'] width = request.GET['width'] height = request.GET['height'] colormap = request.GET['colormap'] colorscalerange = request.GET['colorscalerange'] vectorscale = request.GET['vectorscale'] cmin = colorscalerange.min cmax = colorscalerange.max crs = request.GET['crs'] unit_vectors = None # We don't support requesting these yet, but wouldn't be hard EPSG4326 = pyproj.Proj(init='EPSG:4326') x, y = pyproj.transform(EPSG4326, crs, lon, lat) # TODO order for non-inverse? fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height / dpi) fig.set_figwidth(width / dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() mags = np.sqrt(dx**2 + dy**2) cmap = mpl.cm.get_cmap(colormap) if request.GET['logscale'] is True: norm_func = mpl.colors.LogNorm else: norm_func = mpl.colors.Normalize # Set out of bound data to NaN so it shows transparent? # Set to black like ncWMS? # Configurable by user? if cmin is not None and cmax is not None: mags[mags > cmax] = cmax mags[mags < cmin] = cmin norm = norm_func(vmin=cmin, vmax=cmax) else: norm = norm_func() # plot unit vectors if unit_vectors: ax.quiver(x, y, dx / mags, dy / mags, mags, cmap=cmap, norm=norm, scale=vectorscale) else: ax.quiver(x, y, dx, dy, mags, cmap=cmap, norm=norm, scale=vectorscale) ax.set_xlim(bbox.minx, bbox.maxx) ax.set_ylim(bbox.miny, bbox.maxy) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
class MySimWindow(wx.Frame): def __init__(self, parent=None, id=-1, title='', pos=wx.DefaultSize, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE): wx.Frame.__init__(self, parent, id, title, pos, size, style) self.InitUI() pass def InitUI(self): # 声明Panel,改变背景色 self.SetBackgroundColour('#FFF5EE') self.panel = wx.Panel(self) # 布局块 vbox = wx.BoxSizer(wx.HORIZONTAL) nm = wx.StaticBox(self.panel, -1, '控制台输出:') sizer_left = wx.StaticBoxSizer(nm, wx.HORIZONTAL) nm_center = wx.StaticBox(self.panel, -1, '仿真绘图窗口:') sizer_center = wx.StaticBoxSizer(nm_center, wx.HORIZONTAL) nm_right = wx.StaticBox(self.panel, -1, '仿真控制按钮:') sizer_right = wx.StaticBoxSizer(nm_right, wx.HORIZONTAL) # 左侧控制台输出 inBox1 = wx.BoxSizer(wx.VERTICAL) self.outInfo = wx.TextCtrl(self.panel, value="当前未开始仿真", style=wx.TE_READONLY | wx.TE_LEFT, size=(210, 660)) self.out_save = wxBtn.GenButton( self.panel, -1, u"清空控制台输出", size=(95, 30), ) self.out_save.SetBackgroundColour('#E0EEEE') inBox1.Add(self.outInfo, 0, wx.ALL | wx.CENTER, 1) inBox1.Add(self.out_save, 0, wx.ALL | wx.CENTER, 1) sizer_left.Add(inBox1, 0, wx.ALL | wx.EXPAND, 0) # 中部绘图窗口 inBox2 = wx.BoxSizer(wx.VERTICAL) scores = [89, 98, 70, 80, 60, 78, 85, 90] sum = 0 for s in scores: sum += s average = sum / len(scores) t_score = numpy.arange(1, len(scores) + 1, 1) s_score = numpy.array(scores) self.figure_map = Figure() self.figure_map.set_figheight(6.7) self.figure_map.set_figwidth(8) # self.sub_co = self.subplots() self.axes_co = self.figure_map.add_subplot(221) self.axes_sm = self.figure_map.add_subplot(222) self.axes_tp = self.figure_map.add_subplot(223) self.axes_cal = self.figure_map.add_subplot(224) self.axes_co.plot(t_score, s_score, 'ro', t_score, s_score, 'k') self.axes_co.axhline(y=average, color='r') self.axes_co.grid(True) self.axes_co.set_title(u'Please Input Parameter -- CO') self.axes_co.set_ylabel(u'Empty Now ') # self.axes_co.set_major_locator() self.axes_sm.plot(t_score, s_score, 'ro', t_score, s_score, 'k') self.axes_sm.axhline(y=average, color='r') self.axes_sm.grid(True) self.axes_sm.set_title(u'Please Input Parameter -- sm') self.axes_sm.set_ylabel(u'Empty Now ') self.axes_tp.plot(t_score, s_score, 'ro', t_score, s_score, 'k') self.axes_tp.axhline(y=average, color='r') self.axes_tp.grid(True) self.axes_tp.set_title(u'Please Input Parameter -- tp') self.axes_tp.set_xlabel(u'Empty Now ') self.axes_tp.set_ylabel(u'Empty Now ') self.axes_cal.plot(t_score, s_score, 'ro', t_score, s_score, 'k') self.axes_cal.axhline(y=average, color='r') self.axes_cal.grid(True) self.axes_cal.set_title(u'Please Input Parameter --cal') self.axes_cal.set_xlabel(u'Empty Now ') self.axes_cal.set_ylabel(u'Empty Now ') self.MyFig = FigureCanvas(self.panel, -1, self.figure_map) inBox2.Add(self.MyFig, 0, wx.ALL | wx.EXPAND, 1) self.out_save = wxBtn.GenButton( self.panel, -1, u"暂停仿真", size=(95, 30), ) self.out_save.SetBackgroundColour('#E0EEEE') inBox2.Add(self.out_save, 0, wx.ALL | wx.CENTER, 1) sizer_center.Add(inBox2, 0, wx.ALL | wx.CENTER, 0) # 右侧控制按钮 sampleList = MysqlCon.getListOfTable('testDb') inBox3 = wx.BoxSizer(wx.VERTICAL) load_co_txt = wx.StaticText(self.panel, -1, "CO数据表选择") self.dwlist_co = wx.Choice(self.panel, -1, (85, 18), choices=sampleList) self.dwlist_co.SetSelection(0) load_sm_txt = wx.StaticText(self.panel, -1, "烟雾浓度数据表选择") self.dwlist_sm = wx.Choice(self.panel, -1, (85, 18), choices=sampleList) self.dwlist_sm.SetSelection(1) load_tp_txt = wx.StaticText(self.panel, -1, "温度数据表选择") self.dwlist_tp = wx.Choice(self.panel, -1, (85, 18), choices=sampleList) self.dwlist_tp.SetSelection(2) self.btn_setData = wxBtn.GenButton( self.panel, -1, u"读取数据", size=(95, 30), ) self.btn_setData.SetBackgroundColour('#E0EEEE') self.Bind(wx.EVT_BUTTON, self.btn_setData_cb, self.btn_setData) inBox3.Add(load_co_txt, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.dwlist_co, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(load_sm_txt, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.dwlist_sm, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(load_tp_txt, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.dwlist_tp, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.btn_setData, 0, wx.ALL | wx.EXPAND, 15) funcList = ['功能测试用', 'D-S数据融合', 'RBF神经网络'] load_tp_fuc = wx.StaticText(self.panel, -1, "数据融合方法选择") self.dwlist_fuc = wx.Choice(self.panel, -1, (85, 18), choices=funcList) self.cont_fuc = wxBtn.GenButton( self.panel, -1, u"开始仿真", size=(95, 30), ) self.cont_fuc.SetBackgroundColour('#E0EEEE') inBox3.Add(load_tp_fuc, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.dwlist_fuc, 0, wx.ALL | wx.CENTER, 1) inBox3.Add(self.cont_fuc, 0, wx.ALL | wx.EXPAND, 1) sizer_right.Add(inBox3, 0, wx.ALL | wx.CENTER, 1) # self.btn_go = wxBtn.GenButton(self.panel, label=u"点击预览", size=(80, 30)) # self.btn_go.Centre() # self.Bind(wx.EVT_BUTTON, self.DrawPic, self.btn_go) # inBox3.Add(self.btn_go, 0, wx.ALL | wx.EXPAND, 1) # 画图部分 # inBox4 = wx.BoxSizer(wx.HORIZONTAL) # scores = [89, 98, 70, 80, 60, 78, 85, 90] # sum = 0 # for s in scores: # sum += s # average = sum / len(scores) # # t_score = numpy.arange(1, len(scores) + 1, 1) # s_score = numpy.array(scores) # # self.figure_map = Figure() # self.figure_map.set_figheight(4.1) # self.figure_map.set_figwidth(8.0) # self.axes_cal = self.figure_map.add_subplot(111) # # self.axes_cal.plot(t_score, s_score, 'ro', t_score, s_score, 'k') # self.axes_cal.axhline(y=average, color='r') # self.axes_cal.grid(True) # self.axes_cal.set_title(u'Please Input Parameter ') # self.axes_cal.set_xlabel(u'Empty Now ') # self.axes_cal.set_ylabel(u'Empty Now ') # # self.MyFig = FigureCanvas(self.panel, -1, self.figure_map) # inBox4.Add(self.MyFig, 0, wx.ALL | wx.EXPAND, 1) # sizer_left.Add(inBox4, 0, wx.ALL | wx.CENTER, 5) # # self.btn_go = wxBtn.GenButton(self.panel, -1, size=(80, 30), label=u"确认生成") # self.Bind(wx.EVT_BUTTON, self.genData, self.btn_go) # inBox5 = wx.BoxSizer(wx.HORIZONTAL) # inBox5.Add(self.btn_go, 0, wx.ALL | wx.CENTER, 5) # sizer_left.Add(inBox5, 0, wx.ALL | wx.CENTER, 1) # self.Bind(wx.EVT_BUTTON, self.btn_cb_co, self.btn_co_confirm) vbox.Add(sizer_left, 0, wx.ALL | wx.LEFT, 1) vbox.Add(sizer_center, 0, wx.ALL | wx.CENTER, 1) vbox.Add(sizer_right, 0, wx.ALL | wx.RIGHT, 1) self.panel.SetSizer(vbox) # self.Fit() 有此函数会缩成一团!!! self.Centre() pass # 读取数据按钮的回调函数 def btn_setData_cb(self, handler): tb_data_co = self.dwlist_co.GetStringSelection() tb_data_sm = self.dwlist_sm.GetStringSelection() tb_data_tp = self.dwlist_tp.GetStringSelection() tb_data_fuc = self.dwlist_fuc.GetStringSelection() self.data_co = MysqlCon.getDataOfTable("testDb", tb_data_co) self.data_sm = MysqlCon.getDataOfTable("testDb", tb_data_sm) self.data_tp = MysqlCon.getDataOfTable("testDb", tb_data_tp) # 需要补充异常情况判断 ??? # 获取数据表时间和频率\长度 time_co = self.data_co[0].time time_sm = self.data_sm[0].time time_tp = self.data_tp[0].time fren_co = self.data_co[0].fren fren_sm = self.data_sm[0].fren fren_tp = self.data_tp[0].fren len_co = len(self.data_co) len_sm = len(self.data_sm) len_tp = len(self.data_tp) axes_x_co = [] axes_x_sm = [] axes_x_tp = [] axes_y_co = [] axes_y_sm = [] axes_y_tp = [] temp = 1 for row in self.data_co: axes_x_co.append(temp * (1 / fren_co)) axes_y_co.append(row.value) temp = temp + 1 pass self.axes_co.clear() self.axes_co.plot(axes_x_co, axes_y_co, 'ro', axes_x_co, axes_y_co, 'k') self.axes_co.grid(True) self.axes_co.set_title(u'CO Data Is Ready!') self.axes_co.set_ylabel(u'??!!## ') for row in self.data_sm: axes_x_sm.append(temp * (1 / fren_sm)) axes_y_sm.append(row.value) temp = temp + 1 pass self.axes_sm.clear() self.axes_sm.plot(axes_x_sm, axes_y_sm, 'ro', axes_x_sm, axes_y_sm, 'k') self.axes_sm.grid(True) self.axes_sm.set_title(u'Smoke Data Is Ready!') self.axes_sm.set_ylabel(u'??!!## ') for row in self.data_tp: axes_x_tp.append(temp * (1 / fren_tp)) axes_y_tp.append(row.value) temp = temp + 1 pass self.axes_tp.clear() self.axes_tp.plot(axes_x_tp, axes_y_tp, 'ro', axes_x_tp, axes_y_tp, 'k') self.axes_tp.grid(True) self.axes_tp.set_title(u'Temperature Data Is Ready!') self.axes_tp.set_ylabel(u'??!!## ') self.MyFig.draw() pass # 开始仿真按钮 def btn_beginSim_cb(self, handler): # 暂时只实现以1秒为单位的动态演示 # 之后实现 以加权平均为方法的数据融合图形展示 # 之后实现,对仿真过程的控制 pass # dropdownList 按钮变化后的效果 def dwlist_cb_co(self): pass def dwlist_cb_sm(self): pass def dwlist_cb_tp(self): pass def dwlist_cb_fuc(self): pass
frame_center_min = tk.Frame(frame_center, background="#71BDFF") frame_center_min.pack(side="top") frame_center_max = tk.Frame(frame_center, background="#71BDFF") frame_center_max.pack(side="top") frame_right = tk.Frame(app, background="#71BDFF") frame_right.pack(side="left", expand=True) ### WIDGETS ################################################################### ### GRAPH WITH MATPLOTLIB #### fig = Figure() fig.autolayout: True fig.set_figheight(7) fig.set_figwidth(9) ax = fig.add_subplot(1, 1, 1) ax.plot([], []) ax.set_title("Bitcoin Value BTC/EUR") ax.set_xlabel("Date") ax.set_ylabel("BTC/EUR") canvas = FigureCanvasTkAgg(fig, master=frame_left) canvas.get_tk_widget().pack(fill="both", expand=True) ### LABELS FOR STATISTIC INFORMATION ### label_text_last_value_var = tk.StringVar() label_text_last_value = tk.Label(frame_center_last_value, textvariable=label_text_last_value_var,
def tricontourf_response(triang_subset, data, request, dpi=80.0, nlvls = 15): """ triang_subset is a matplotlib.Tri object in lat/lon units (will be converted to projected coordinates) xmin, ymin, xmax, ymax is the bounding pox of the plot in PROJETED COORDINATES!!! request is the original getMap request object """ from django.http import HttpResponse xmin, ymin, xmax, ymax = wms_handler.get_bbox(request) width, height = wms_handler.get_width_height(request) colormap = wms_handler.get_colormap(request) cmin, cmax = wms_handler.get_climits(request) #logger.info('cmin/cmax: {0} {1}'.format(cmin, cmax)) # TODO: check this? try: data[data>cmax] = cmax data[data<cmin] = cmin except: exc_type, exc_value, exc_traceback = sys.exc_info() logger.warning("tricontourf_response error: " + repr(traceback.format_exception(exc_type, exc_value, exc_traceback))) clvls = wms_handler.get_clvls(request) #proj = get_pyproj(request) #triang_subset.x, triang_subset.y = proj(triang_subset.x, triang_subset.y) CRS = get_pyproj(request) triang_subset.x, triang_subset.y = pyproj.transform(EPSG4326, CRS, triang_subset.x, triang_subset.y) #TODO order for non-inverse? #logger.info('TRANSFORMED triang_subset.x: {0}'.format(triang_subset.x)) #logger.info('TRANSFORMED triang_subset.y: {0}'.format(triang_subset.y)) fig = Figure(dpi=dpi, facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figheight(height/dpi) fig.set_figwidth(width/dpi) ax = fig.add_axes([0., 0., 1., 1.], xticks=[], yticks=[]) ax.set_axis_off() lvls = np.linspace(float(cmin), float(cmax), int(clvls)) #logger.info('trang.shape: {0}'.format(triang_subset.x.shape)) #logger.info('data.shape: {0}'.format(data.shape)) ax.tricontourf(triang_subset, data, levels = lvls, cmap=colormap) ax.set_xlim(xmin, xmax) ax.set_ylim(ymin, ymax) ax.set_frame_on(False) ax.set_clip_on(False) ax.set_position([0., 0., 1., 1.]) #plt.axis('off') canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) return response
def create_graph(): """Create graph of code quality evolution """ t0 = time() cwd = getcwd() project_name = cwd.split('/')[-1] # We copy project to tmp (for security) tmp_directory = '%s/ipkg_quality.git' % mkdtemp() call(['git', 'clone', cwd, tmp_directory]) chdir(tmp_directory) # First step: we create a list of statistics statistics = {} commit_ids = git.get_revisions() commit_ids.reverse() print 'Script will analyse %s commits.' % len(commit_ids) for commit_id in commit_ids: # We move to a given commit call(['git', 'reset', '--hard', commit_id]) # Print script evolution stdout.write('.') stdout.flush() # We list files filenames = git.get_filenames() filenames = [ x for x in filenames if x.endswith('.py') ] # We get code quality for this files stats, files_db = analyse(filenames, ignore_errors=True) metadata = git.get_metadata() date_time = metadata['committer'][1] commit_date = date(date_time.year, date_time.month, date_time.day) if commit_date not in statistics: statistics[commit_date] = stats else: # Same day => Avg for key in statistics[commit_date]: avg = (statistics[commit_date][key] + stats[key])/2 statistics[commit_date][key] = avg print # Get dates values = [] dates = statistics.keys() dates.sort() for a_date in dates: values.append(statistics[a_date]) # Base graph informations base_title = '[%s %s]' % (project_name, git.get_branch_name()) # We generate graphs chdir(cwd) for problem_dict in ['code_length', 'aesthetics_problems', 'exception_problems', 'import_problems']: current_problems = eval(problem_dict) graph_title = '%s %s' % (base_title, current_problems['title']) lines = [] labels = [] fig = Figure() graph = fig.add_subplot(111) for key in current_problems['keys']: if current_problems['pourcent']: problem_values = [((x[key]*100.0)/x['lines']) for x in values] else: problem_values = [x[key] for x in values] lines.append(graph.plot_date(dates, problem_values, '-')) labels.append(current_problems['keys'][key]) graph.set_title(graph_title) graph.xaxis.set_major_formatter(DateFormatter("%b '%y'")) if current_problems['pourcent']: graph.set_ylabel('Pourcent') graph.yaxis.set_major_formatter(FormatStrFormatter("%5.02f %%")) else: graph.set_ylabel('Quantity') graph.set_xlabel('') graph.autoscale_view() graph.grid(True) fig.autofmt_xdate() fig.set_figheight(fig.get_figheight()+5) legend = fig.legend(lines, labels, loc=8, axespad=0.0) legend.get_frame().set_linewidth(0) canvas = FigureCanvasAgg(fig) destination = 'graph_%s.png' % problem_dict canvas.print_figure(destination, dpi=80) print '%s -> %s ' % (graph_title, destination) t1 = time() print 'Generation time: %d minutes.' % ((t1 - t0)/60)
def _do_gbl3(self, shared_ids, arg, gbar, barspace): data = self.data iface = self.iface errors = list() msa_lens = list() blocks = list() array = np.empty(shape=(len(shared_ids), 0), dtype=int) for gene in data.genes: iface.text = '%s: read MSA' % gene LOG.debug(iface.text) raw_msa = (self.wd / gene / ('%s_raw_msa.fasta' % gene)).resolve() msa = self.wd / gene / ('%s_msa.fasta' % gene) records = {r.id: r for r in SeqIO.parse(raw_msa, 'fasta')} take_out = { _id for _id in records.keys() if _id in data.gbl.ignore_ids } take_out = {_id: records.pop(_id) for _id in take_out} if take_out: # write newly dropped sequences to backup file new_take_out = { _id: r for _id, r in take_out.items() if _id not in iface.tempspace.bak_ignore } with open(self.wd / gene / ('%s_raw_msa_dropped.fasta' % gene), 'a') as fasta: SeqIO.write(new_take_out.values(), fasta, 'fasta') # overwrite MSA without all dropped samples with open(raw_msa, 'w') as fasta: SeqIO.write(records.values(), fasta, 'fasta') if sorted(records.keys()) != shared_ids: errors.append( 'MSA for %s does not match the dataset, please re-build.' % gene) sleep(.1) GObject.idle_add(self.stop_gbl, errors) return True ar = np.array([ repo.seqtoint(records[_id].seq.upper()) for _id in shared_ids ]) msa_lens.append(ar.shape[1]) # get the array columns that are not only gaps usable_sites = [ i for i in range(ar.shape[1]) if set(ar[:, i]) != {repo.toint('-')} ] array = np.hstack(( array, ar, )) # shared.SEP would need to be stacked here del ar data.msa_shape[:2] = array.shape[::-1] if iface.gbl_preset.get_active_text() == 'skip': LOG.debug('skipping %s' % gene) shutil.copy(raw_msa, msa) iface.i += 1 continue iface.text = '%s: run Gblocks' % gene LOG.debug(iface.text) with open(self.wd / gene / 'gblocks.log', 'w') as log_handle: try: LOG.debug(arg % raw_msa) subprocess.run(arg % raw_msa, shell=True, check=True, stdout=log_handle, stderr=log_handle) except (OSError, subprocess.CalledProcessError) as e: errors.append(str(e)) log_handle.write(str(e)) continue # parse result iface.text = '%s: parse result' % gene LOG.debug(iface.text) shutil.move(raw_msa.with_suffix('.fasta.txt'), msa) # get the good blocks from the last pseudo-sequence in the text mask file for pseudo_seq in SeqIO.parse( raw_msa.with_suffix('.fasta.txtMask'), 'fasta'): mask = pseudo_seq # map the Gblocks mask to the original MSA sites line_blocks = [ usable_sites[i] for i, char in enumerate(mask.seq) if char == '#' ] LOG.debug(line_blocks) if not line_blocks: err = '%s: no good blocks' % gene LOG.error(err) errors.append(err) continue shift = sum(msa_lens[:-1]) blocks.extend([i + shift for i in line_blocks]) iface.i += 1 data.msa_lens = msa_lens iface.text = 'concatenating MSAs' iface.tempspace.bak_ignore = {i for i in data.gbl.ignore_ids} if 'aligner' not in iface: iface.aligner, cmd = self.get_msa_build_cmd( repo.toalgo(iface.msa_algo.get_active_text()), self.wd, data.genes) iface.aligner.reset_paths(self.wd, self.wd / repo.PATHS.msa) data.msa_shape[2], data.msa_shape[3] = iface.aligner.concat_msa( gui=shared_ids) iface.text = 'computing SHA256 hash' LOG.debug(iface.text) self.get_hashes(repo.PATHS.msa, PAGE) iface.i += 1 iface.text = 'plot MSAs' LOG.debug(iface.text) data.gbl_shape[0] = array.shape[1] * self.get_hadj() # make gaps transparent array = np.ma.masked_where(array > repo.toint('else'), array) # create a transparency mask gbl_mask = np.full(array.shape, repo.ALPHA) gbl_mask[:, blocks] = 1 data.msa_shape[2] = len(blocks) # for completeness LOG.debug('msa shape: %s' % str(data.msa_shape)) x_ratio = data.msa_shape[2] / data.msa_shape[0] LOG.debug('x ratio: %.3f' % x_ratio) # adjust maximum size scale = 6 while max(data.msa_shape[:2]) * scale > 2**14: scale -= 1 LOG.debug('scaling gbl with %d' % scale) if iface.gbl_preset.get_active_text() != 'skip': for alpha, blocks, gtk_bin, png_path, x_ratio, width \ in zip([gbl_mask, 1], [range(array.shape[1]), blocks], [iface.gbl_left_vp, iface.gbl_right_vp], [repo.PATHS.left, repo.PATHS.right], [1, x_ratio], [data.msa_shape[0], data.msa_shape[2]]): f = Figure( ) # figsize=(width / shared.DPI, data.msa_shape[1] / shared.DPI), dpi=shared.DPI) # figaspect(data.msa_shape[1] / width)) f.set_facecolor('none') f.set_figheight(data.msa_shape[1] / repo.DPI * 5) f.set_figwidth(max(1, width) / repo.DPI) # f.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0) # leave room at the bottom for the gene legend bar b = barspace / data.gbl_shape[1] ax = f.add_axes([0, b, 1, 1 - b]) mat = ax.matshow(array[:, blocks], alpha=alpha, cmap=ListedColormap(repo.colors), vmin=-.5, vmax=len(repo.colors) - .5, aspect='auto') if not gbar: LOG.debug('adding ticks') [ ax.spines[t].set_visible(False) for t in ['left', 'right', 'top', 'bottom'] ] ax.yaxis.set_visible(False) ax.xaxis.set_ticks_position('bottom') ax.tick_params(colors=iface.FG, pad=.2, length=0, labelsize=1) ax.xaxis.set_ticks([ i for i in range(1, array[:, blocks].shape[1] - 1) if not i % 100 ]) else: ax.axis('off') LOG.debug('adding gene marker bar') # build matrix of gene indicators gm = [[i] * l for i, l in enumerate(msa_lens)] if x_ratio == 1: # add the spacer for i in range(len(data.genes) - 1): gm[i] += [-1] * len(repo.SEP) gm = [gi for gl in gm for gi in gl] # turn into np array gm = np.vstack([np.array(gm)] * 2) # make spacer transparent gm = np.ma.masked_where(gm < 0, gm) # trim the array early gm = gm[:, blocks] gene_colors = get_cmap('GnBu', len(data.genes)) # plot the marker bar onto the MSA graphic bax = f.add_axes([0, b * .4, 1, b / 3]) bar = bax.pcolormesh(gm, cmap=gene_colors) # bax.axis('off') [ bax.spines[t].set_visible(False) for t in ['left', 'right', 'top', 'bottom'] ] bax.yaxis.set_visible(False) bax.xaxis.set_ticks_position('bottom') bax.tick_params(colors=iface.FG, pad=.2, length=0, labelsize=1) bax.xaxis.set_ticks( [i for i in range(1, gm.shape[1] - 1) if not i % 100]) # plot a legend for the gene marker bar with plt.rc_context({ 'axes.edgecolor': iface.FG, 'xtick.color': iface.FG }): iface.text = 'gene marker bar' LOG.debug(iface.text) Path.mkdir(self.wd / repo.PATHS.phylo_msa.parent, exist_ok=True) fig = plt.figure(figsize=(4, .2)) cax = fig.add_subplot(111) cbar = ColorbarBase(ax=cax, cmap=gene_colors, orientation='horizontal', ticks=[ (.5 / len(data.genes) + j * 1 / len(data.genes)) for j in range(len(data.genes)) ]) cbar.ax.set_xticklabels(data.genes) fig.savefig(self.wd / repo.PATHS.gbar, transparent=True, bbox_inches='tight', pad_inches=0, dpi=600) plt.close(fig) del fig, cbar iface.i += 1 iface.text = 'save PNG' LOG.debug(iface.text) Path.mkdir(self.wd / png_path.parent, exist_ok=True) f.savefig(self.wd / png_path, transparent=True, dpi=scale * repo.DPI, bbox_inches='tight', pad_inches=0.00001) if iface.rasterize.props.active: iface.text = 'place PNG' LOG.debug(iface.text) self.load_image( iface.zoomer, PAGE, gtk_bin, self.wd / png_path, data.gbl_shape[0] * x_ratio * self.get_hadj(), data.gbl_shape[1]) else: iface.text = 'place vector' LOG.debug(iface.text) canvas = FigureCanvas(f) canvas.set_size_request( max(len(blocks) * self.get_hadj(), -1), data.gbl_shape[1]) # width, height try: ch = gtk_bin.get_child() if ch: gtk_bin.remove(ch) gtk_bin.add(canvas) except Exception as ex: LOG.error(ex) iface.i += 1 gtk_bin.realize() gtk_bin.show_all() # re-size LOG.debug('re-sizing again') for wi in [iface.gbl_left, iface.gbl_right]: wi.set_max_content_height(data.gbl_shape[1]) self.load_colorbar(iface.palplot2) if gbar: self.load_colorbar(iface.gbar1, gbar=True) iface.gbar1.set_visible(True) else: iface.gbar1.set_visible(False) iface.text = 'idle' iface.frac = 1 sleep(.1) GObject.idle_add(self.stop_gbl, errors) return True
def getLegendGraphic(request, dataset): """ Parse parameters from request that looks like this: http://webserver.smast.umassd.edu:8000/wms/NecofsWave? ELEVATION=1 &LAYERS=hs &TRANSPARENT=TRUE &STYLES=facets_average_jet_0_0.5_node_False &SERVICE=WMS &VERSION=1.1.1 &REQUEST=GetLegendGraphic &FORMAT=image%2Fpng &TIME=2012-06-20T18%3A00%3A00 &SRS=EPSG%3A3857 &LAYER=hs """ styles = request.GET["styles"].split("_") try: climits = (float(styles[3]), float(styles[4])) except: climits = (None, None) variables = request.GET["layer"].split(",") plot_type = styles[0] colormap = styles[2].replace('-', '_') # direct the service to the dataset # make changes to server_local_config.py if settings.LOCALDATASET: url = settings.LOCALDATASETPATH[dataset] else: url = Dataset.objects.get(name=dataset).path() nc = netCDF4.Dataset(url) """ Create figure and axes for small legend image """ #from matplotlib.figure import Figure from matplotlib.pylab import get_cmap fig = Figure(dpi=100., facecolor='none', edgecolor='none') fig.set_alpha(0) fig.set_figwidth(1*1.3) fig.set_figheight(1.5*1.3) """ Create the colorbar or legend and add to axis """ v = cf.get_by_standard_name(nc, variables[0]) try: units = v.units except: units = '' # vertical level label if v.ndim > 3: units = units + '\nvertical level: %s' % _get_vertical_level(nc, v) if climits[0] is None or climits[1] is None: # TODO: NOT SUPPORTED RESPONSE #going to have to get the data here to figure out bounds #need elevation, bbox, time, magnitudebool CNorm = None ax = fig.add_axes([0, 0, 1, 1]) ax.grid(False) ax.text(.5, .5, 'Error: No Legend\navailable for\nautoscaled\ncolor styles!', ha='center', va='center', transform=ax.transAxes, fontsize=8) elif plot_type not in ["contours", "filledcontours"]: #use limits described by the style ax = fig.add_axes([.01, .05, .2, .8]) # xticks=[], yticks=[]) CNorm = matplotlib.colors.Normalize(vmin=climits[0], vmax=climits[1], clip=False, ) cb = matplotlib.colorbar.ColorbarBase(ax, cmap=get_cmap(colormap), norm=CNorm, orientation='vertical', ) cb.set_label(units, size=8) else: # plot type somekind of contour if plot_type == "contours": #this should perhaps be a legend... #ax = fig.add_axes([0,0,1,1]) fig_proxy = Figure(frameon=False, facecolor='none', edgecolor='none') ax_proxy = fig_proxy.add_axes([0, 0, 1, 1]) CNorm = matplotlib.colors.Normalize(vmin=climits[0], vmax=climits[1], clip=True) #levs = numpy.arange(0, 12)*(climits[1]-climits[0])/10 levs = numpy.linspace(climits[0], climits[1], 11) x, y = numpy.meshgrid(numpy.arange(10), numpy.arange(10)) cs = ax_proxy.contourf(x, y, x, levels=levs, norm=CNorm, cmap=get_cmap(colormap)) proxy = [plt.Rectangle((0, 0), 0, 0, fc=pc.get_facecolor()[0]) for pc in cs.collections] fig.legend(proxy, levs, #bbox_to_anchor = (0, 0, 1, 1), #bbox_transform = fig.transFigure, loc = 6, title = units, prop = { 'size' : 8 }, frameon = False, ) elif plot_type == "filledcontours": #this should perhaps be a legend... #ax = fig.add_axes([0,0,1,1]) fig_proxy = Figure(frameon=False, facecolor='none', edgecolor='none') ax_proxy = fig_proxy.add_axes([0, 0, 1, 1]) CNorm = matplotlib.colors.Normalize(vmin=climits[0], vmax=climits[1], clip=False,) #levs = numpy.arange(1, 12)*(climits[1]-(climits[0]))/10 levs = numpy.linspace(climits[0], climits[1], 10) levs = numpy.hstack(([-99999], levs, [99999])) x, y = numpy.meshgrid(numpy.arange(10), numpy.arange(10)) cs = ax_proxy.contourf(x, y, x, levels=levs, norm=CNorm, cmap=get_cmap(colormap)) proxy = [plt.Rectangle((0, 0), 0, 0, fc=pc.get_facecolor()[0]) for pc in cs.collections] levels = [] for i, value in enumerate(levs): #if i == 0: # levels[i] = "<" + str(value) if i == len(levs)-2 or i == len(levs)-1: levels.append("> " + str(value)) elif i == 0: levels.append("< " + str(levs[i+1])) else: #levels.append(str(value) + "-" + str(levs[i+1])) text = '%.2f-%.2f' % (value, levs[i+1]) levels.append(text) fig.legend(proxy, levels, #bbox_to_anchor = (0, 0, 1, 1), #bbox_transform = fig.transFigure, loc = 6, title = units, prop = { 'size' : 6 }, frameon = False, ) canvas = FigureCanvasAgg(fig) response = HttpResponse(content_type='image/png') canvas.print_png(response) nc.close() return response
class GSARecipe(QtGui.QWidget): def __init__(self, parent=None): super(GSARecipe, self).__init__(parent=parent) self.df = pd.DataFrame() self.experiments = [] self.layout = QtWidgets.QGridLayout(self) self.layout.setAlignment(QtCore.Qt.AlignTop) self.file_button = QtWidgets.QPushButton("Upload File") self.file_button.clicked.connect(self.getFile) self.experiment_selection = QtGui.QComboBox(self) self.experiment_selection.activated[str].connect(self.plotRecipe) self.experiment_selection.setEnabled(False) self.figure = Figure() self.recipe_profile = FigureCanvas(self.figure) self.layout.addWidget(self.file_button, 0, 0, 1, 1) self.layout.addWidget(self.experiment_selection, 0, 1, 1, 1) self.layout.addWidget(self.recipe_profile, 1, 0, 1, 2) self.setLayout(self.layout) self.errmsg = QtWidgets.QMessageBox() def getFile(self): filepath = QtWidgets.QFileDialog.getOpenFileName() if filepath[0] != u"": if filepath[0][-3:] != "csv": self.errmsg.setIcon(QtWidgets.QMessageBox.Warning) self.errmsg.setText("Please upload a .csv") self.errmsg.exec_() del filepath else: self.readCSV(filepath) else: del filepath def readCSV(self, filepath): self.df = pd.read_csv(filepath[0]) self.experiment_selection.addItems(["Please Select Exeriment No"]) ind, col = self.df.shape self.experiments = [] for i in range(ind): self.experiments.append(str(i + 1)) self.experiment_selection.addItems(self.experiments) self.experiment_selection.setEnabled(True) def collapse(self, series): stamp = [] self.df = series.to_frame() i = 0 for n in range(6): stamp_component = self.df[i:i + 13].transpose() stamp_component.columns = [ "Timestamp (min)", "Temp (degC)", "Pressure(Torr)", "Sample Location (normalized from 0-1)", "Helium Flow Rate (sccm)", "Helium Flow Rate (Torr l/s)", "Hydrogen Flow Rate (sccm)", "Hydrogen Flow Rate (Torr l/s)", "Carbon Source", "Carbon Source Flow Rate (sccm)", "Carbon Source Flow Rate (Torr l/s)", "Argon Flow Rate (sccm)", "Argon Flow Rate (Torr l/s)", ] stamp.append(stamp_component) i += 13 reorder = stamp[0].append( [stamp[1], stamp[2], stamp[3], stamp[4], stamp[5]]) reorder.index = [0, 1, 2, 3, 4, 5] return reorder def finalize(self, frame1, frame2, frame3): frames = [frame1, frame2, frame3] for frame in frames: frame.rename(columns={"Timestamp (min)": "Time (min)"}, inplace=True) total = 0 for i in range(len(frame.index)): total += frame.iloc[i, 0] frame.iat[i, 0] = total zeroA = pd.DataFrame({ "Time (min)": [0], "Temp (degC)": [0], "Pressure(Torr)": [frame1.iat[0, 2]], "Sample Location (normalized from 0-1)": [frame1.iat[0, 3]], "Helium Flow Rate (sccm)": [frame1.iat[0, 4]], "Helium Flow Rate (Torr l/s)": [frame1.iat[0, 5]], "Hydrogen Flow Rate (sccm)": [frame1.iat[0, 6]], "Hydrogen Flow Rate (Torr l/s)": [frame1.iat[0, 7]], "Carbon Source": [frame1.iat[0, 8]], "Carbon Source Flow Rate (sccm)": [frame1.iat[0, 9]], "Carbon Source Flow Rate (Torr l/s)": [frame1.iat[0, 10]], "Argon Flow Rate (sccm)": [frame1.iat[0, 11]], "Argon Flow Rate (Torr l/s)": [frame1.iat[0, 12]], }) zeroedFrame1 = zeroA.append(frame1) zeroedFrame1.index = [0, 1, 2, 3, 4, 5, 6] columns = zeroedFrame1.columns.tolist() columns = columns[::-1] zeroedFrame1 = zeroedFrame1[columns] tmp = zeroedFrame1.dropna(axis=0, how="all") shrink1 = tmp.dropna(axis=1, how="all") Annealing = shrink1.fillna(0) zeroG = pd.DataFrame({ "Time (min)": [0], "Temp (degC)": [Annealing.iat[-1, 1]], "Pressure(Torr)": [frame2.iat[0, 2]], "Sample Location (normalized from 0-1)": [frame2.iat[0, 3]], "Helium Flow Rate (sccm)": [frame2.iat[0, 4]], "Helium Flow Rate (Torr l/s)": [frame2.iat[0, 5]], "Hydrogen Flow Rate (sccm)": [frame2.iat[0, 6]], "Hydrogen Flow Rate (Torr l/s)": [frame2.iat[0, 7]], "Carbon Source": [frame2.iat[0, 8]], "Carbon Source Flow Rate (sccm)": [frame2.iat[0, 9]], "Carbon Source Flow Rate (Torr l/s)": [frame2.iat[0, 10]], "Argon Flow Rate (sccm)": [frame2.iat[0, 11]], "Argon Flow Rate (Torr l/s)": [frame2.iat[0, 12]], }) zeroedFrame2 = zeroG.append(frame2) zeroedFrame2.index = [0, 1, 2, 3, 4, 5, 6] columns = zeroedFrame2.columns.tolist() columns = columns[::-1] zeroedFrame2 = zeroedFrame2[columns] tmp = zeroedFrame2.dropna(axis=0, how="all") shrink2 = tmp.dropna(axis=1, how="all") Growth = shrink2.fillna(0) zero3 = pd.DataFrame({ "Time (min)": [Growth.iat[-1, 0]], "Temp (degC)": [Growth.iat[-1, 1]], "Pressure(Torr)": [frame3.iat[0, 2]], "Sample Location (normalized from 0-1)": [frame3.iat[0, 3]], "Helium Flow Rate (sccm)": [frame3.iat[0, 4]], "Helium Flow Rate (Torr l/s)": [frame3.iat[0, 5]], "Hydrogen Flow Rate (sccm)": [frame3.iat[0, 6]], "Hydrogen Flow Rate (Torr l/s)": [frame3.iat[0, 7]], "Carbon Source": [frame3.iat[0, 8]], "Carbon Source Flow Rate (sccm)": [frame3.iat[0, 9]], "Carbon Source Flow Rate (Torr l/s)": [frame3.iat[0, 10]], "Argon Flow Rate (sccm)": [frame3.iat[0, 11]], "Argon Flow Rate (Torr l/s)": [frame3.iat[0, 12]], }) zeroedFrame3 = zero3.append(frame3) zeroedFrame3.index = [0, 1, 2, 3, 4, 5, 6] total = 0 for i in range(len(zeroedFrame3.index)): total += zeroedFrame3.iloc[i, -1] zeroedFrame3.iat[i, -1] = total columns = zeroedFrame3.columns.tolist() columns = columns[::-1] zeroedFrame3 = zeroedFrame3[columns] tmp = zeroedFrame3.dropna(axis=0, how="all") shrink3 = tmp.dropna(axis=1, how="all") Cooling = shrink3.fillna(0) return Annealing, Growth, Cooling def plotRecipe(self): exp = int(self.experiment_selection.currentText()) - 1 grapheneRec = self.df.iloc[exp, 31:269] Anneal_series = grapheneRec.iloc[1:79] Growth_series = grapheneRec.iloc[80:159] Cooling_series = grapheneRec.iloc[160:269] mp.close("all") Anneal = self.collapse(Anneal_series) Growth = self.collapse(Growth_series) Cooling = self.collapse(Cooling_series) A, G, C = self.finalize(Anneal, Growth, Cooling) self.figure, (A_temp, G_temp, C_temp) = mp.subplots(1, 3, sharey=True) A_temp.plot(A["Time (min)"], A["Temp (degC)"], "b") A_temp.tick_params(axis="both", direction="in") A_gas = A_temp.twinx() A_gas.tick_params(axis="y", direction="in", labelright=False) G_temp.plot(G["Time (min)"], G["Temp (degC)"], "b") G_temp.tick_params(axis="both", direction="in") G_gas = G_temp.twinx() G_gas.tick_params(axis="y", direction="in", labelright=False) C_temp.plot(C["Time (min)"], C["Temp (degC)"], "b") C_temp.tick_params(axis="both", direction="in") C_gas = C_temp.twinx() C_gas.tick_params(axis="y", direction="in") A_gas.get_shared_y_axes().join(A_gas, G_gas, C_gas) hel_count = False hyd_count = False car_count = False arg_count = False for flow_rate in A[4:]: if flow_rate == "Helium Flow Rate (sccm)": A_hel = A_gas.step(A["Time (min)"], A["Helium Flow Rate (sccm)"], "r") hel_count = True if flow_rate == "Hydrogen Flow Rate (sccm)": A_hyd = A_gas.step( A["Time (min)"], A["Hydrogen Flow Rate (sccm)"], "m", label="Hydrogen Flow Rate", ) hyd_count = True if flow_rate == "Carbon Source Flow Rate (sccm)": A_car = A_gas.step( A["Time (min)"], A["Carbon Source Flow Rate (sccm)"], "g", label="Carbon Source Flow Rate", ) car_count = True if flow_rate == "Argon Flow Rate (sccm)": A_arg = A_gas.step( A["Time (min)"], A["Argon Flow Rate (sccm)"], "y", label="Argon Flow Rate", ) arg_count = True for flow_rate in G[4:]: if flow_rate == "Helium Flow Rate (sccm)": G_hel = G_gas.step( G["Time (min)"], G["Helium Flow Rate (sccm)"], "r", label="Helium Flow Rate", ) if hel_count == False: hel_count = True if flow_rate == "Hydrogen Flow Rate (sccm)": G_hyd = G_gas.step( G["Time (min)"], G["Hydrogen Flow Rate (sccm)"], "m", label="Hydrogen Flow Rate", ) if hyd_count == False: hyd_count = True if flow_rate == "Carbon Source Flow Rate (sccm)": G_car = G_gas.step( G["Time (min)"], G["Carbon Source Flow Rate (sccm)"], "g", label="Carbon Source Flow Rate", ) if car_count == False: car_count = True if flow_rate == "Argon Flow Rate (sccm)": G_arg = G_gas.step( G["Time (min)"], G["Argon Flow Rate (sccm)"], "y", label="Argon Flow Rate", ) if arg_count == False: arg_count = True for flow_rate in C[4:]: if flow_rate == "Helium Flow Rate (sccm)": C_hel = C_gas.step( C["Time (min)"], C["Helium Flow Rate (sccm)"], "r", label="Helium Flow Rate", ) if hel_count == False: hel_count = True if flow_rate == "Hydrogen Flow Rate (sccm)": C_hyd = C_gas.step( C["Time (min)"], C["Hydrogen Flow Rate (sccm)"], "m", label="Hydrogen Flow Rate", ) if hyd_count == False: hyd_count = True if flow_rate == "Carbon Source Flow Rate (sccm)": C_car = C_gas.step( C["Time (min)"], C["Carbon Source Flow Rate (sccm)"], "g", label="Carbon Source Flow Rate", ) if car_count == False: car_count = True if flow_rate == "Argon Flow Rate (sccm)": C_arg = C_gas.step( C["Time (min)"], C["Argon Flow Rate (sccm)"], "y", label="Argon Flow Rate", ) if arg_count == False: arg_count = True self.figure.suptitle("Graphene Growth Recipe Profile", fontsize=20) A_temp.set_title("Annealing") G_temp.set_title("Growth") C_temp.set_title("Cooling") A_temp.set_ylabel("Temperature ($^\circ$C)", fontsize=20) G_temp.set_xlabel("Time (min)", fontsize=20) C_gas.set_ylabel("Gas Flow Rate (sccm)", fontsize=20) temperature = mlines.Line2D([], [], color="blue") recipe_handles = [temperature] recipe_labels = ["Temperature"] if hel_count == True: helium = mlines.Line2D([], [], color="red") recipe_handles.append(helium) recipe_labels.append("Helium Flow Rate") if hyd_count == True: hydrogen = mlines.Line2D([], [], color="magenta") recipe_handles.append(hydrogen) recipe_labels.append("Hydrogen Flow Rate") if car_count == True: carbon = mlines.Line2D([], [], color="green") recipe_handles.append(carbon) recipe_labels.append("Carbon Source Flow Rate") if arg_count == True: argon = mlines.Line2D([], [], color="yellow") recipe_handles.append(argon) recipe_labels.append("Argon Flow Rate") self.figure.legend(recipe_handles, recipe_labels, loc="upper right", fontsize=12) self.figure.set_figheight(10) self.figure.set_figwidth(20) self.recipe_profile.draw() mp.show()
class MatplotlibWidgetCustom(QtGui.QWidget): def __init__(self, parent=None): super(MatplotlibWidgetCustom, self).__init__(parent) self._setup = False # self.setupScatterCanvas(dpi) # self.scatterPlot(x='random',y='random',frame=True,framesize=6,xlabel="lol",ylabel="rofl") def setupScatterCanvas(self,width=5,height=5,dpi=72,toolbar=False): if self._setup is False: self.figure = Figure(figsize=(width,height),dpi=dpi) self.canvas = FigureCanvas(self.figure) layout = QtGui.QVBoxLayout() layout.addWidget(self.canvas) if toolbar is True: self.figure.set_figheight(height + 0.5) self.toolbar = NavigationToolbar(self.canvas, self) layout.addWidget(self.toolbar) self.setLayout(layout) self._setup = True else: self.clearAll() self._setup = False self.setupScatterCanvas(width,height,dpi,toolbar) def clearAll(self): QtGui.QWidget().setLayout(self.layout()) self._setup = False def scatterPlot(self,x='random',y='random',frame=False,framesize=None,xlabel="",ylabel=""): if x == 'random' or y == 'random': # the random data x = np.random.randn(1000) y = np.random.randn(1000) # the scatter plot: # if not hasattr(self,'subplotScatter'): self.subplotScatter = self.figure.add_subplot(111) self.subplotScatter.clear() self.subplotScatter.scatter(x, y) self.subplotScatter.set_aspect(1.) print x.min(), x.max(), y.min(), y.max() limit = max([abs(x.min()), abs(x.max()), abs(y.min()), abs(y.max())]) + 0.2 print limit self.subplotScatter.set_xlim(-limit, limit) self.subplotScatter.set_ylim(-limit, limit) self.subplotScatter.set_xlabel(xlabel) self.subplotScatter.set_ylabel(ylabel) self.subplotScatter.xaxis.set_label_coords(0.1,0.08) self.subplotScatter.yaxis.set_label_coords(0.08,0.12) self.subplotScatter.plot([0], '+', mew=1, ms=10, c="red") if frame is True and framesize is not None: self.subplotScatter.add_patch(patches.Rectangle( (-framesize * 0.5, -framesize * 0.5), framesize, framesize, fill=False, edgecolor="red")) elif frame is True and framesize is None: print "Please specify frame size in px as e.g. framesize=1.86" # create new axes on the right and on the top of the current axes # The first argument of the new_vertical(new_horizontal) method is # the height (width) of the axes to be created in inches. self.divider = make_axes_locatable(self.subplotScatter) self.axHistx = self.divider.append_axes("top", size="25%", pad=0.1) self.axHisty = self.divider.append_axes("right", size="25%", pad=0.1) # # make some labels invisible # # plt.setp(self.axHistx.get_xticklabels() + self.axHisty.get_yticklabels(), visible=False) self.axHistx.set_xticklabels(self.axHistx.get_xticklabels(),visible=False) self.axHisty.set_yticklabels(self.axHisty.get_yticklabels(),visible=False) # self.axHistx.set_yticks([0,0.5,1]) # self.axHisty.set_xticks([0,0.5,1]) # now determine nice limits by hand: binwidth = 0.25 xymax = np.max([np.max(np.fabs(x)), np.max(np.fabs(y))]) lim = (int(xymax / binwidth) + 1) * binwidth bins = np.arange(-lim, lim + binwidth, binwidth) self.axHistx.hist(x, bins=bins) self.axHisty.hist(y, bins=bins, orientation='horizontal') # the xaxis of self.axHistx and yaxis of self.axHisty are shared with self.subplotScatter, # thus there is no need to manually adjust the xlim and ylim of these # axis. # self.axHistx.axis["bottom"].major_ticklabels.set_visible(False) for tl in self.axHistx.get_xticklabels(): tl.set_visible(False) self.axHistx.set_yticks([]) # self.axHisty.axis["left"].major_ticklabels.set_visible(False) for tl in self.axHisty.get_yticklabels(): tl.set_visible(False) self.axHisty.set_xticks([]) # self.figure.set_dpi(200) self.canvas.draw() def xyPlot(self,*args,**kwargs): self.subplotXY = self.figure.add_subplot(111) try: clear = kwargs.pop('clear') except: clear = False if clear is True: self.subplotXY.clear() self.subplotXY.plot(*args,**kwargs) leg = self.subplotXY.legend(fontsize='small') leg.get_frame().set_alpha(0.5) self.canvas.draw() def matshowPlot(self,mat=None,contour=None,labelContour=''): # import tifffile as tf n = len(self.figure.axes) if n < 2: for i in range(n): self.figure.axes[i].change_geometry(n + 1, 1, i + 1) # self.figure.subplots_adjust(hspace=0.5) self.figure.tight_layout() self.subplotMat = self.figure.add_subplot(n + 1, 1, n + 1) # self.subplotMat.plot(np.arange(100),np.random.random(100)*10) # mat = tf.imread('/Users/jan/Desktop/dot2.tif') self.subplotMat.clear() self.subplotMat.matshow(mat) self.subplotMat.contour(contour, cmap='Greys', linewidths=(1,)) self.subplotMat.grid(False) self.subplotMat.text( 0.95, 0.03, labelContour, fontsize=12, horizontalalignment='right', verticalalignment='bottom', transform=self.figure.transFigure) self.subplotMat.set_anchor('W') self.canvas.draw()
class Ui_cpsApp(Ui_cpsMainWindow): def __init__(self): super(Ui_cpsApp, self).__init__() def setupUiApp(self, MainWindow): super(Ui_cpsApp, self).setupUi(MainWindow) self.filePath = "" self.colorMap = 'magma' self.color = 'orange' self.populateComboBoxes() self.nfftComboBox.activated.connect(self.clicker) self.scaleComboBox.activated.connect(self.activateComboBoxes) self.minFreqComboBox.activated.connect(self.activateComboBoxes) self.maxFreqComboBox.activated.connect(self.activateComboBoxes) self.noverlapComboBox.activated.connect(self.activateComboBoxes) self.windowComboBox.activated.connect(self.activateComboBoxes) self.actionRecord.triggered.connect(self.runRecord) self.actionChoose.triggered.connect(self.getDirectory) self.actionViridis.triggered.connect(self.triggeredViridis) self.actionInferno.triggered.connect(self.triggeredInferno) self.actionMagma.triggered.connect(self.triggeredMagma) self.actionRdBu.triggered.connect(self.triggeredRdBu) self.actionOrange.triggered.connect(self.triggeredOrange) self.actionBlack.triggered.connect(self.triggeredBlack) self.actionBlue.triggered.connect(self.triggeredBlue) self.actionRed.triggered.connect(self.triggeredRed) self.actionBroad.triggered.connect(self.triggeredBroad) self.actionAccurate.triggered.connect(self.triggeredAccurate) self.actionRemove_span.triggered.connect(self.triggeredRemoveSpan) self.actionQuitApp.triggered.connect(MainWindow.close) self.figureSpec = Figure() self.figureSpecCanvas = FigureCanvas(self.figureSpec) self.specLayout.addWidget(self.figureSpecCanvas) self.figureFig = Figure() self.figureFig.set_figheight(2.5) self.figureFigCanvas = FigureCanvas(self.figureFig) self.figLayout.addWidget(self.figureFigCanvas) def populateComboBoxes(self): self.windowComboBox.addItem('boxcar') self.windowComboBox.addItem('triang') self.windowComboBox.addItem('blackman') self.windowComboBox.addItem('hamming') self.windowComboBox.addItem('hann') self.windowComboBox.addItem('bartlett') self.windowComboBox.addItem('flattop') self.windowComboBox.addItem('parzen') self.windowComboBox.addItem('nuttall') self.windowComboBox.addItem('taylor') self.windowComboBox.setCurrentIndex(0) self.nfftComboBox.addItem('256', ['128', '250']) self.nfftComboBox.addItem('512', ['128', '256', '500']) self.nfftComboBox.addItem('1024', ['128', '256', '512', '1000']) self.nfftComboBox.addItem('2048', ['128', '256', '512', '1024', '2000']) self.nfftComboBox.addItem( '4096', ['128', '256', '512', '1024', '2048', '4000']) self.nfftComboBox.setCurrentIndex(2) self.noverlapComboBox.addItem('256') self.noverlapComboBox.addItem('512') self.noverlapComboBox.addItem('1000') self.noverlapComboBox.setCurrentIndex(0) self.scaleComboBox.addItem('linear') self.scaleComboBox.addItem('symlog') self.scaleComboBox.setCurrentIndex(0) self.minFreqComboBox.addItem('0 [Hz]') self.minFreqComboBox.addItem('10 [Hz]') self.minFreqComboBox.addItem('20 [Hz]') self.minFreqComboBox.addItem('100 [Hz]') self.minFreqComboBox.setCurrentIndex(0) self.maxFreqComboBox.addItem('Auto') self.maxFreqComboBox.addItem('20 [Hz]') self.maxFreqComboBox.addItem('240 [Hz]') self.maxFreqComboBox.addItem('10000 [Hz]') self.maxFreqComboBox.addItem('20000 [Hz]') self.maxFreqComboBox.addItem('40000 [Hz]') self.maxFreqComboBox.setCurrentIndex(0) def clicker(self, index): self.noverlapComboBox.clear() self.noverlapComboBox.addItems(self.nfftComboBox.itemData(index)) self.noverlapComboBox.setCurrentIndex(self.nfftComboBox.currentIndex()) self.activateComboBoxes() def activateComboBoxes(self): if os.path.exists(self.filePath): self.plotSpectrogram(self.f) def triggeredViridis(self): self.actionInferno.setChecked(False) self.actionMagma.setChecked(False) self.actionRdBu.setChecked(False) self.colorMap = 'viridis' if self.filePath != '': self.plotSpectrogram(self.f) def triggeredInferno(self): self.actionViridis.setChecked(False) self.actionMagma.setChecked(False) self.actionRdBu.setChecked(False) self.colorMap = 'inferno' if self.filePath != '': self.plotSpectrogram(self.f) def triggeredMagma(self): self.actionViridis.setChecked(False) self.actionInferno.setChecked(False) self.actionRdBu.setChecked(False) self.colorMap = 'magma' if self.filePath != '': self.plotSpectrogram(self.f) def triggeredRdBu(self): self.actionViridis.setChecked(False) self.actionInferno.setChecked(False) self.actionMagma.setChecked(False) self.colorMap = 'RdBu' if self.filePath != '': self.plotSpectrogram(self.f) def triggeredOrange(self): self.actionBlack.setChecked(False) self.actionBlue.setChecked(False) self.actionRed.setChecked(False) self.color = 'orange' self.plotFigure() def triggeredBlack(self): self.actionOrange.setChecked(False) self.actionBlue.setChecked(False) self.actionRed.setChecked(False) self.color = 'black' self.plotFigure() def triggeredBlue(self): self.actionOrange.setChecked(False) self.actionBlack.setChecked(False) self.actionRed.setChecked(False) self.color = 'blue' self.plotFigure() def triggeredRed(self): self.actionOrange.setChecked(False) self.actionBlack.setChecked(False) self.actionBlue.setChecked(False) self.color = 'red' self.plotFigure() def triggeredBroad(self): self.actionAccurate.setChecked(False) def triggeredAccurate(self): self.actionBroad.setChecked(False) def triggeredRemoveSpan(self): if self.filePath != '': self.f = list(wavfile.read(self.filePath)) self.plotFigure() self.plotSpectrogram(self.f) def getDirectory(self): chosenPath = str( QFileDialog.getOpenFileName(cpsMainWindow, caption="Select .wav file", filter='Audio (*.wav)')[0]) if chosenPath != "": self.textPath.setText(chosenPath) self.filePath = chosenPath self.f = list(wavfile.read(self.filePath)) self.plotFigure() self.plotSpectrogram(self.f) def runRecord(self): cpsMainWindow.hide() record = QDialog() uiRecord = recordWindow(record) uiRecord.setupUiRecord(record) record.show() record.exec_() if uiRecord.stringPath != '': temp = uiRecord.stringPath + '/' + str( uiRecord.filenameInput.text()) + '.wav' if os.path.exists(temp): self.filePath = uiRecord.stringPath + '/' + str( uiRecord.filenameInput.text()) + '.wav' self.textPath.setText(self.filePath) self.f = list(wavfile.read(self.filePath)) self.plotSpectrogram(self.f) self.plotFigure() cpsMainWindow.show() def plotSpectrogram(self, f, startTime=0): if self.filePath != '': samplingFrequency, signalData = f self.figureSpec.clear() # Plot the signal read from wav file ax = self.figureSpec.add_subplot(111) nfft = int(self.nfftComboBox.currentText()) nover = int(self.noverlapComboBox.currentText()) if self.windowComboBox.currentText() == 'boxcar': win = signal.get_window('boxcar', len(signalData)) elif self.windowComboBox.currentText() == 'triang': win = signal.get_window('triang', len(signalData)) elif self.windowComboBox.currentText() == 'blackman': win = signal.get_window('blackman', len(signalData)) elif self.windowComboBox.currentText() == 'hamming': win = signal.get_window('hamming', len(signalData)) elif self.windowComboBox.currentText() == 'hann': win = signal.get_window('hann', len(signalData)) elif self.windowComboBox.currentText() == 'bartlett': win = signal.get_window('bartlett', len(signalData)) elif self.windowComboBox.currentText() == 'flattop': win = signal.get_window('flattop', len(signalData)) elif self.windowComboBox.currentText() == 'parzen': win = signal.get_window('parzen', len(signalData)) elif self.windowComboBox.currentText() == 'nuttall': win = signal.get_window('nuttall', len(signalData)) elif self.windowComboBox.currentText() == 'taylor': win = signal.get_window('taylor', len(signalData)) signalData = multiply(signalData, win) ax.specgram(signalData, NFFT=nfft, noverlap=nover, Fs=samplingFrequency, cmap=self.colorMap) ax.set_yscale(self.scaleComboBox.currentText()) #linear or symlog if self.maxFreqComboBox.currentText() != 'Auto': ax.set_ylim( 0, int(self.maxFreqComboBox.currentText().split(' ', 1)[0])) ax.set_ylim( int(self.minFreqComboBox.currentText().split(' ', 1)[0]), ) ax.set_title('Spectrogram', fontsize=12) ax.set_xlabel('Time [s]', fontsize=8) ax.set_ylabel('Frequency [Hz]', fontsize=8) ax.tick_params(labelsize=7) self.figureSpec.tight_layout(pad=0.3) self.figureSpecCanvas.draw() def spanSelected(self, startFrame, endFrame): signalData = self.f[1] chosenData = signalData[int(startFrame):int(endFrame)] if self.actionAccurate.isChecked(): self.f[1] = chosenData self.plotFigure() tempF = self.f else: tempF = self.f.copy() tempF[1] = chosenData self.plotSpectrogram(tempF) def plotFigure(self): if self.filePath != '': rate, data = self.f if len(data.shape) == 1: channel1 = data[:] channel2 = None else: channel1 = data[:, 0] channel2 = data[:, 1] self.figureFig.clear() axes = self.figureFig.add_subplot(111) n_ticks = 8 max_time = len(channel1) / rate x_ticks = [ len(channel1) * i / (n_ticks - 1) for i in range(n_ticks) ] x_ticklabels = [ f'{max_time * i / (n_ticks - 1):.2f}s' for i in range(n_ticks) ] axes.plot(channel1, color=self.color) axes.set_title('Select span below', fontsize=10) axes.set_xticks(x_ticks) axes.set_xticklabels(x_ticklabels, fontsize=7) axes.set_yticks([0]) axes.set_yticklabels(['y=0'], fontsize=7) axes.set_xlim([0, max(x_ticks)]) axes.axhline(y=0, color=self.color, linewidth=1, linestyle='-') self.figureFig.tight_layout(pad=0.1) self.figureFigCanvas.draw() self.span = SpanSelector( axes, self.spanSelected, "horizontal", minspan=1000, useblit=True, span_stays=True, rectprops=dict(alpha=0.3, facecolor="red"), )