Exemple #1
0
    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
Exemple #2
0
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
Exemple #3
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)
Exemple #4
0
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
Exemple #5
0
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)
Exemple #7
0
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)
Exemple #8
0
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)
Exemple #10
0
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
Exemple #11
0
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
Exemple #12
0
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)
Exemple #14
0
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
Exemple #15
0
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
Exemple #16
0
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
Exemple #17
0
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
Exemple #18
0
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
Exemple #20
0
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
Exemple #21
0
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
Exemple #22
0
    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')
Exemple #24
0
 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)
Exemple #26
0
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)
Exemple #27
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)
Exemple #28
0
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
Exemple #29
0
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()
Exemple #31
0
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
Exemple #32
0
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
Exemple #33
0
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)
Exemple #36
0
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)
Exemple #37
0
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
Exemple #39
0
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
Exemple #40
0
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
Exemple #41
0
# 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]
Exemple #42
0
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()
Exemple #43
0
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()
Exemple #45
0
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
Exemple #46
0
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
Exemple #47
0
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)
Exemple #48
0
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
Exemple #49
0
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
Exemple #50
0
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
Exemple #51
0
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
Exemple #54
0
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)
Exemple #55
0
    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
Exemple #57
0
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()
Exemple #58
0
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()
Exemple #59
0
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"),
            )