def hinton(W, maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix.
    Temporarily disables matplotlib interactive mode if it is on,
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W))) / np.log(2))

    P.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]),
           'gray')
    P.axis('off')
    P.axis('equal')
    for x in range(width):
        for y in range(height):
            w = W[y, x]
            weight = w / maxWeight if w > 0 else min(1, -w / maxWeight)
            color = 'white' if w > 0 else 'black'
            _blob((x + 1) - 0.5, height - (y + 1) + 0.5, weight, color)
    if reenable:
        P.ion()
    P.show()
Exemple #2
0
def ploterrorbars(x, y, dy, ymax=None, color='k', xfac=1,
                  ax=None, xlog=False, **other):
    if ax is None:
        ax = pylab.gca()

    if ymax is None:
        ymin = y - dy
        ymax = y + dy
    else:
        ymin = dy
        ymax = ymax

    if xlog:
        dxlog = 0.005 * xfac * (np.log10(xlim()[1]) - np.log10(xlim()[0]))
        print('dxlog', dxlog)
        dx = dxlog * x / np.log10(np.e)
    else:
        dx = 0.005 * xfac * (xlim()[1] - xlim()[0])
    xtemp = xlim()
    ytemp = ylim()
    pylab.ioff()
    for i in range(len(x)):
        ax.plot([x[i], x[i]], [ymin[i], ymax[i]], color=color, **other)
        ax.plot([x[i] - dx, x[i] + dx],
                [ymax[i], ymax[i]], color=color, **other)
        ax.plot([x[i] - dx, x[i] + dx],
                [ymin[i], ymin[i]], color=color, **other)

    if pylab.isinteractive():
        pylab.ion()
        pylab.show()

    ax.set_xlim(xtemp[0], xtemp[1])
    ax.set_ylim(ytemp[0], ytemp[1])
Exemple #3
0
def hinton(W, maxWeight=None):
    """
    Source: http://wiki.scipy.org/Cookbook/Matplotlib/HintonDiagrams
    Draws a Hinton diagram for visualizing a weight matrix.
    Temporarily disables matplotlib interactive mode if it is on,
    otherwise this takes forever.
    """
    reenable = False
    if pl.isinteractive():
        pl.ioff()
    pl.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W)))/np.log(2))

    pl.fill(np.array([0,width,width,0]),np.array([0,0,height,height]),'gray')
    pl.axis('off')
    pl.axis('equal')
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        pl.ion()
    pl.show()
Exemple #4
0
def hinton(W, maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix.
    Temporarily disables matplotlib interactive mode if it is on,
    otherwise this takes forever.
    """
    import pylab
    reenable = False
    if pylab.isinteractive():
        pylab.ioff()
    pylab.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W))) / np.log(2))

    pylab.fill(np.array([0, width, width, 0]), np.array([0, 0, height,
                                                         height]), 'gray')
    pylab.axis('off')
    pylab.axis('equal')
    for x in range(width):
        for y in range(height):
            _x = x + 1
            _y = y + 1
            w = W[y, x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, w / maxWeight),
                      'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, -w / maxWeight),
                      'black')
    if reenable:
        pylab.ion()
    pylab.show()
def hinton(W,filename="hinton.pdf", maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    ax=P.subplot(111)
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W)))/np.log(2))

    P.fill(np.array([0,width,width,0]),np.array([0,0,height,height]),'gray')
    P.axis('off')
    #P.axis('equal')
    ax.set_yticklabels(['25','20','15','10','5','0'])
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        P.ion()
    P.title(filename)
    P.savefig(filename)
Exemple #6
0
    def __init__(self, parent=None, pid=None, figure_or_canvas=None):
        super().__init__(parent, pid, 'plot')

        self.fileMenu = self.menuBar().addMenu("&File")
        self.addMenuItem(self.fileMenu, 'Open...', self.openFigure)
        self.addMenuItem(self.fileMenu, 'Save As...', self.saveFigure)
        self.addMenuItem(self.fileMenu,
                         'Close',
                         self.close_me_from_menu,
                         icon='cross.png')
        self.addMenuItem(self.fileMenu, 'Close Others', self.close_others)

        self.editMenu = CheckMenu("&Edit", self.menuBar())
        self.menuBar().addMenu(self.editMenu)

        self.addMenuItem(self.editMenu,
                         'Copy',
                         self.copyToCb,
                         statusTip="Copy to Clipboard",
                         icon='page_copy.png')

        self.viewMenu = CheckMenu("&View", self.menuBar())
        self.menuBar().addMenu(self.viewMenu)

        self.addMenuItem(self.viewMenu,
                         'Refresh',
                         self.refresh,
                         statusTip="Refresh the plot",
                         icon='update.png')
        self.addMenuItem(self.viewMenu,
                         'Grid',
                         self.grid,
                         statusTip="Show/hide grid",
                         icon='layer_grid.png')
        self.addMenuItem(
            self.viewMenu,
            'Tight',
            self.tight,
            statusTip="Adjust the padding between and around subplots",
            icon='canvas_size.png')
        self.addMenuItem(self.viewMenu,
                         'Interactive',
                         self.toggle_interactive,
                         checkcall=lambda: pylab.isinteractive())

        self.addBaseMenu()

        if hasattr(figure_or_canvas, 'canvas'):
            self.figure = figure_or_canvas
            self.canvas = figure_or_canvas.canvas
        else:
            self.figure = figure_or_canvas.figure
            self.canvas = figure_or_canvas

        self.setCentralWidget(self.canvas)

        self.nav = NavigationToolbar(self.canvas, self)
        self.nav.setIconSize(QtCore.QSize(20, 20))
        self.addToolBar(self.nav)
        self.statusBar().hide()
Exemple #7
0
def hinton(W, out_file=None, maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**N.ceil(N.log(N.max(N.abs(W)))/N.log(2))

    P.gca().set_position([0, 0, 1, 1])
    P.fill(N.array([0,width,width,0]),N.array([0,0,height,height]),'gray')
    P.axis('off')
    P.axis('equal')
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        P.ion()
    #P.show()
    if out_file:
        #P.savefig(out_file, format='png', bbox_inches='tight', pad_inches=0)
        fig = P.gcf()
        fig.subplots_adjust()
        fig.savefig(out_file)
Exemple #8
0
def hinton(W, filename="hinton.pdf", maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    ax = P.subplot(111)
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**np.ceil(np.log(np.max(np.abs(W))) / np.log(2))

    P.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]),
           'gray')
    P.axis('off')
    #P.axis('equal')
    ax.set_yticklabels(['25', '20', '15', '10', '5', '0'])
    for x in xrange(width):
        for y in xrange(height):
            _x = x + 1
            _y = y + 1
            w = W[y, x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, w / maxWeight),
                      'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, -w / maxWeight),
                      'black')
    if reenable:
        P.ion()
    P.title(filename)
    P.savefig(filename)
Exemple #9
0
 def __init__(self, features, **kwargs):
     self.features = features
     self.fc_function = None
     self.lw_function = None
     wasinteractive = pylab.isinteractive()
     if wasinteractive:
         pylab.ioff()
     self.shapes = []
     for i, feature in enumerate(self.features):
         if isinstance(feature.shape, g.MultiPolygon):
             self.shapes.append([])
             for shape in feature.shape.geoms:
                 x, y = numpy.asarray(shape.exterior)[:, :2].swapaxes(0, 1)
                 self.shapes[-1].append(pylab.fill(x, y, **kwargs)[0])
         if isinstance(feature.shape, g.Polygon):
             x, y = numpy.asarray(feature.shape.exterior)[:, :2].swapaxes(
                 0, 1)
             self.shapes.append(pylab.fill(x, y, **kwargs))
         elif isinstance(feature.shape, g.MultiLineString):
             self.shapes.append([])
             for shape in feature.shape.geoms:
                 x, y = numpy.asarray(shape)[:, :2].swapaxes(0, 1)
                 self.shapes[-1].append(pylab.plot(x, y, **kwargs)[0])
         elif isinstance(feature.shape, g.LineString):
             x, y = numpy.asarray(feature.shape).swapaxes(0, 1)
             self.shapes.append(pylab.plot(x, y, **kwargs))
         elif isinstance(feature.shape, g.Point):
             x, y = feature.shape.x, feature.shape.y
             self.shapes.append(pylab.plot([x], [y], **kwargs)[0])
     pylab.axis('equal')
     if wasinteractive:
         pylab.ion()
         pylab.draw()
Exemple #10
0
def hinton(W, name, maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**N.ceil(N.log(N.max(N.abs(W))) / N.log(2))

    P.fill(N.array([0, width, width, 0]), N.array([0, 0, height, height]),
           'gray')
    P.axis('off')
    P.axis('equal')
    for x in range(width):
        for y in range(height):
            _x = x + 1
            _y = y + 1
            w = W[y, x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, w / maxWeight),
                      'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, -w / maxWeight),
                      'black')
    if reenable:
        P.ion()
    P.savefig('hinton' + name + '.png')
    P.show()
    def __call__(self,output_fn,init_time=0,final_time=None,**params):
        p=ParamOverrides(self,params)

        if final_time is None:
            final_time=topo.sim.time()

        attrs = p.attrib_names if len(p.attrib_names)>0 else output_fn.attrib_names
        for a in attrs:
            pylab.figure(figsize=(6,4))
            isint=pylab.isinteractive()
            pylab.ioff()
            pylab.grid(True)
            ylabel=p.ylabel
            pylab.ylabel(a+" "+ylabel)
            pylab.xlabel('Iteration Number')

            coords = p.units if len(p.units)>0 else output_fn.units
            for coord in coords:
                y_data=[y for (x,y) in output_fn.values[a][coord]]
                x_data=[x for (x,y) in output_fn.values[a][coord]]
                if p.raw==True:
                    plot_data=zip(x_data,y_data)
                    pylab.save(normalize_path(p.filename+a+'(%.2f, %.2f)' %(coord[0], coord[1])),plot_data,fmt='%.6f', delimiter=',')


                pylab.plot(x_data,y_data, label='Unit (%.2f, %.2f)' %(coord[0], coord[1]))
                (ymin,ymax)=p.ybounds
                pylab.axis(xmin=init_time,xmax=final_time,ymin=ymin,ymax=ymax)

            if isint: pylab.ion()
            pylab.legend(loc=0)
            p.title=topo.sim.name+': '+a
            p.filename_suffix=a
            self._generate_figure(p)
Exemple #12
0
    def hinton(W, max_weight=None, names=(names, worst_names)):
        """
        Draws a Hinton diagram for visualizing a weight matrix.
        Temporarily disables matplotlib interactive mode if it is on,
        otherwise this takes forever.
        """
        reenable = False
        if P.isinteractive():
            P.ioff()
        P.clf()
        height, width = W.shape
        if not max_weight:
            max_weight = 2**np.ceil(np.log(np.max(np.abs(W)))/np.log(2))

        P.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]), 'gray')
        P.axis('off')
        P.axis('equal')
        cmap = plt.get_cmap('RdYlGn')
        for x in range(width):
            if names:
                plt.text(-0.5, x, names[0][x], fontsize=7, ha='right', va='bottom')
                plt.text(x, height+0.5, names[1][height-x-1], fontsize=7, va='bottom', rotation='vertical', ha='left')
            for y in range(height):
                _x = x+1
                _y = y+1
                w = W[y, x]
                if w > 0:
                    _blob(_x - 0.5, height - _y + 0.5, min(1, w/max_weight), color=cmap(w/max_weight))
                elif w < 0:
                    _blob(_x - 0.5, height - _y + 0.5, min(1, -w/max_weight), 'black')
        if reenable:
            P.ion()
        P.show()
Exemple #13
0
def graticule(dpar=None,dmer=None,coord=None,local=None,**kwds):
    """Create a graticule, either on an existing mollweide map or not.

    Parameters:
      - dpar, dmer: interval in degrees between meridians and between parallels
      - coord: the coordinate system of the graticule (make rotation if needed,
               using coordinate system of the map if it is defined)
      - local: True if local graticule (no rotation is performed)
    Return:
      None
    """
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if len(f.get_axes()) == 0:
            ax=PA.HpxMollweideAxes(f,(0.02,0.05,0.96,0.9),coord=coord)
            f.add_axes(ax)
            ax.text(0.86,0.05,ax.proj.coordsysstr,fontsize=14,
                    fontweight='bold',transform=ax.transAxes)
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ax.graticule(dpar=dpar,dmer=dmer,coord=coord,
                             local=local,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #14
0
def graticule(dpar=None, dmer=None, coord=None, local=None, **kwds):
    """Create a graticule, either on an existing mollweide map or not.

    Parameters:
      - dpar, dmer: interval in degrees between meridians and between parallels
      - coord: the coordinate system of the graticule (make rotation if needed,
               using coordinate system of the map if it is defined)
      - local: True if local graticule (no rotation is performed)
    Return:
      None
    """
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if len(f.get_axes()) == 0:
            ax = PA.HpxMollweideAxes(f, (0.02, 0.05, 0.96, 0.9), coord=coord)
            f.add_axes(ax)
            ax.text(0.86,
                    0.05,
                    ax.proj.coordsysstr,
                    fontsize=14,
                    fontweight='bold',
                    transform=ax.transAxes)
        for ax in f.get_axes():
            if isinstance(ax, PA.SphericalProjAxes):
                ax.graticule(dpar=dpar,
                             dmer=dmer,
                             coord=coord,
                             local=local,
                             **kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #15
0
    def hinton(self, maxWeight=None):
        """
        Draws a Hinton diagram for visualizing a weight matrix. 
        Temporarily disables matplotlib interactive mode if it is on, 
        otherwise this takes forever.
        Source: http://wiki.scipy.org/Cookbook/Matplotlib/HintonDiagrams
        """
        reenable = False
        if P.isinteractive():
            P.ioff()
        P.clf()
        height, width = self.sigma_w.shape
        if not maxWeight:
            maxWeight = 2**np.ceil(
                np.log(np.max(np.abs(self.sigma_w))) / np.log(2))

        P.fill(np.array([0, width, width, 0]), np.array([0, 0, height,
                                                         height]), 'gray')
        P.axis('off')
        P.axis('equal')
        for x in xrange(width):
            for y in xrange(height):
                _x = x + 1
                _y = y + 1
                w = self.sigma_w[y, x]
                if w > 0:
                    self._blob(_x - 0.5, height - _y + 0.5,
                               min(1, w / maxWeight), 'white')
                elif w < 0:
                    self._blob(_x - 0.5, height - _y + 0.5,
                               min(1, -w / maxWeight), 'black')
        if reenable:
            P.ion()
        P.show()
def hinton(W, maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**N.ceil(N.log(N.max(N.abs(W)))/N.log(2))

    P.fill(N.array([0,width,width,0]),N.array([0,0,height,height]),'gray')
    P.axis('off')
    P.axis('equal')
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        P.ion()
    P.show()
Exemple #17
0
    def draw(self, axes=None, loc=2):
        if axes == None:
            axes = p.gca()

        if self.box != None and self.box in axes.artists:
            del axes.artists[ axes.artists.index(self.box) ]
        
        #key_areas = [ mpl.offsetbox.TextArea(k, textprops=self.textprops) for k in self.datadict.keys() ]
        #val_areas = [ mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops) for k in self.datadict.keys() ]
        key_areas = [ mpl.offsetbox.TextArea(k, textprops=self.textprops) for k in list(self.datadict.keys()) ]
        val_areas = [ mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops) for k in list(self.datadict.keys()) ]
        
        key_vpack = mpl.offsetbox.VPacker(children=key_areas, align="left", pad=0, sep=0)
        val_vpack = mpl.offsetbox.VPacker(children=val_areas, align="right", pad=0, sep=0)
        hpack = mpl.offsetbox.HPacker(children=[key_vpack, val_vpack], align="top", pad=0,sep=4)
        
        globchildren = []
        if self.title != None:
            #titlearea = mpl.offsetbox.TextArea(self.title, textprops=self.titleprops)
            titlearea = mpl.offsetbox.TextArea(self.title)
            globchildren.append(titlearea)
        
        globchildren.append(hpack)
        globvpack = mpl.offsetbox.VPacker(children=globchildren, align="center", pad=0, sep=1)
        
        self.box = mpl.offsetbox.AnchoredOffsetbox(loc=loc, child=globvpack)
        self.box.patch.set_facecolor(self.facecolor)
        self.box.patch.set_edgecolor(self.edgecolor)
        self.box.patch.set_alpha(self.alpha)
        axes.add_artist( self.box )

        if p.isinteractive():
            p.gcf().canvas.draw()
Exemple #18
0
def showslice2(thedata,thelabel,minval,maxval,colormap):
    theshape=thedata.shape
    numslices=theshape[0]
    ysize=theshape[1]
    xsize=theshape[2]
    slicesqrt=int(np.ceil(np.sqrt(numslices)))
    theslice=np.zeros((ysize*slicesqrt,xsize*slicesqrt))
    for i in range(0,numslices):
        ypos=int(i/slicesqrt)*ysize
        xpos=int(i%slicesqrt)*xsize
        theslice[ypos:ypos+ysize,xpos:xpos+xsize]=thedata[i,:,:]
    if P.isinteractive():
	P.ioff()
    P.axis('off')
    P.axis('equal')
    P.subplots_adjust(hspace=0.0)
    P.axes([0,0,1,1], frameon = False)
    if (colormap==0):
        thecmap=P.cm.gray
    else:
	mycmdata1 = {
	    'red'  :  ((0., 0., 0.), (0.5, 1.0, 0.0), (1., 1., 1.)),
	    'green':  ((0., 0., 0.), (0.5, 1.0, 1.0), (1., 0., 0.)),
	    'blue' :  ((0., 0., 0.), (0.5, 1.0, 0.0), (1., 0., 0.))
	    }
	thecmap = P.matplotlib.colors.LinearSegmentedColormap('mycm', mycmdata1)
	#thecmap=P.cm.spectral
    theimptr = P.imshow(theslice, vmin=minval, vmax=maxval, interpolation='nearest', label=thelabel, aspect='equal', cmap=thecmap)
    #P.colorbar()
    return()
def saveHintonDiagram(W, directory):
    maxWeight = None
    #print "Weight: ", W
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if pylab.isinteractive():
        pylab.ioff()
    pylab.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**numpy.ceil(numpy.log(numpy.max(numpy.abs(W)))/numpy.log(2))

    pylab.fill(numpy.array([0,width,width,0]),numpy.array([0,0,height,height]),'gray')
    pylab.axis('off')
    pylab.axis('equal')
    for x in xrange(width):
        for y in xrange(height):
            _x = x+1
            _y = y+1
            w = W[y,x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,w/maxWeight),'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1,-w/maxWeight),'black')
    if reenable:
        pylab.ion()
    #pylab.show()
    pylab.savefig(directory)
    def __call__(self,**params):
        p=ParamOverrides(self,params)
        sheet = p.sheet
        for coordinate in p.coords:
            i_value,j_value=sheet.sheet2matrixidx(coordinate[0],coordinate[1])

            pylab.figure(figsize=(7,7))
            isint=pylab.isinteractive()
            pylab.ioff()

            pylab.ylabel('Response',fontsize='large')
            pylab.xlabel('%s (%s)' % (p.x_axis.capitalize(),p.unit),fontsize='large')
            pylab.title('Sheet %s, coordinate(x,y)=(%0.3f,%0.3f) at time %s' %
                        (sheet.name,coordinate[0],coordinate[1],topo.sim.timestr()))
            p.title='%s: %s Tuning Curve' % (topo.sim.name,p.x_axis.capitalize())

            self.first_curve=True
            for curve_label in sorted(sheet.curve_dict[p.x_axis].keys()):
                x_values,y_values,ticks=self._curve_values(i_value,j_value,sheet.curve_dict[p.x_axis][curve_label])

                x_tick_values,ticks = self._reduce_ticks(ticks)
                labels = [self._format_x_tick_label(x) for x in ticks]
                pylab.xticks(x_tick_values, labels,fontsize='large')
                pylab.yticks(fontsize='large')
                p.plot_type(x_values, y_values, label=curve_label,lw=3.0)
                self.first_curve=False

            if isint: pylab.ion()
            if p.legend: pylab.legend(loc=2)
            self._generate_figure(p)
Exemple #21
0
 def plot(self):
     fig = self._doPlot()
     if not pylab.isinteractive():
         pylab.show()
     else:
         pylab.draw()
     pylab.close(fig)
Exemple #22
0
def showlines(vs, size=(4.1,2), **kwargs):
# {{{
  ''' 
  Plot line plots of a list of 1D variables on the same plot.

  Parameters
  ----------
  v :  list of :class:`Var`
     The variables to plot. Should all have 1 non-degenerate axis.
  '''

  Z = [v.squeeze() for v in vs]

  for z in Z:
    assert z.naxes == 1, 'Variable %s has %d non-generate axes; must have 1.' % (z.name, z.naxes)

  fig = kwargs.pop('fig', None)

  ax = wr.AxesWrapper(size=size)
  ydat = []
  for v in vs:
    vplot(v, axes=ax, label=v.name, )
    ydat.append(ax.find_plot(wr.Plot).plot_args[1])

  ylim = (np.min([np.min(y) for y in ydat]), np.max([np.max(y) for y in ydat]))
  kwargs.update(dict(ylim=ylim))
  ax.legend(loc='best', frameon=False)
  ax.setp(**kwargs)

  import pylab as pyl
  if pyl.isinteractive(): ax.render(fig)
  return ax
def read_text_pyfusion(files, target='^Shot .*', ph_dtype=None, plot=pl.isinteractive(), ms=100, hold=0, debug=0, quiet=1,  exception = Exception):
    """ Accepts a file or a list of files, returns a list of structured arrays
    See merge ds_list to merge and convert types (float -> pyfusion.prec_med
    """
    st = seconds(); last_update=seconds()
    file_list = files
    if len(np.shape(files)) == 0: file_list = [file_list]
    f='f8'
    if ph_dtype == None: ph_dtype = [('p12',f),('p23',f),('p34',f),('p45',f),('p56',f)]
    #ph_dtype = [('p12',f)]
    ds_list =[]
    comment_list =[]
    count = 0
    for (i,filename) in enumerate(file_list):
        if seconds() - last_update > 30:
            last_update = seconds()
            print('reading {n}/{t}: {f}'
                  .format(f=filename, n=i, t=len(file_list)))
        try:
            if pl.is_string_like(target): 
                skip = 1+find_data(filename, target,debug=debug)
            else: 
                skip = target
            if quiet == 0:
                print('{t:.1f} sec, loading data from line {s} of {f}'
                      .format(t = seconds()-st, s=skip, f=filename))
            #  this little bit to determine layout of data
            # very inefficient to read twice, but in a hurry!
            txt = np.loadtxt(fname=filename, skiprows=skip-1, dtype=str, 
                             delimiter='FOOBARWOOBAR')
            header_toks = txt[0].split()
            # is the first character of the 2nd last a digit?
            if header_toks[-2][0] in '0123456789': 
                if pyfusion.VERBOSE > 0: 
                    print('found new header including number of phases')
                n_phases = int(header_toks[-2])
                ph_dtype = [('p{n}{np1}'.format(n=n,np1=n+1), f) for n in range(n_phases)]
                
            if 'frlow' in header_toks:  # add the two extra fields
                fs_dtype= [ ('shot','i8'), ('t_mid','f8'), 
                            ('_binary_svs','i8'), 
                            ('freq','f8'), ('amp', 'f8'), ('a12','f8'),
                            ('p', 'f8'), ('H','f8'), 
                            ('frlow','f8'), ('frhigh', 'f8'),('phases',ph_dtype)]
            else:
                fs_dtype= [ ('shot','i8'), ('t_mid','f8'), 
                            ('_binary_svs','i8'), 
                            ('freq','f8'), ('amp', 'f8'), ('a12','f8'),
                            ('p', 'f8'), ('H','f8'), ('phases',ph_dtype)]

            ds_list.append(
                np.loadtxt(fname=filename, skiprows = skip, 
                           dtype= fs_dtype)
            )
            count += 1
            comment_list.append(filename)
        except ValueError, info:
            print('Conversion error while reading {f} with loadtxt - {info}'.format(f=filename, info=info))
Exemple #24
0
def showcol(vs, size=(4.1,2), **kwargs):
# {{{
  ''' 
  Plot variable, showing a contour plot for 2d variables or a line plot for 1d variables.

  Parameters
  ----------
  v :  list of lists of :class:`Var`
     The variables to plot. Should have either 1 or 2 non-degenerate axes.

  Notes
  -----
  This function is intended as the simplest way to display the contents of a variable,
  choosing appropriate parameter values as automatically as possible.
  '''

  Z = [v.squeeze() for v in vs]

  assert Z[0].naxes in [1, 2], 'Variables %s has %d non-generate axes; must have 1 or 2.' % (Z.name, Z.naxes)

  for z in Z[1:]:
    assert Z[0].naxes == z.naxes, 'All variables must have the same number of non-generate dimensions'
    #assert all([a == b for a, b in zip(Z[0].axes, z.axes)])

  fig = kwargs.pop('fig', None)

  if Z[0].naxes == 1:
    axs = []
    ydat = []
    for v in vs:
      lblx = (v is vs[-1])
      ax = vplot(v, lblx = lblx, **kwargs)
      ax.size = size
      axs.append([ax])
      ydat.append(ax.find_plot(wr.Plot).plot_args[1])

    Ax = wr.grid(axs)
    ylim = (np.min([np.min(y) for y in ydat]), np.max([np.max(y) for y in ydat]))
    Ax.setp(ylim = ylim, children=True)

  elif Z[0].naxes == 2:
    axs = []
    for v in vs:
      lblx = (v is vs[-1])
      ax = vcontour(v, lblx = lblx, **kwargs)
      ax.size = size
      axs.append([ax])

    Ax = wr.grid(axs)

    cbar = kwargs.pop('colorbar', dict(orientation='vertical'))
    cf = Ax.axes[0].find_plot(wr.Contourf)
    if cbar and cf is not None:
      Ax = wr.colorbar(Ax, cf, **cbar)

  import pylab as pyl
  if pyl.isinteractive(): Ax.render(fig)
  return Ax
Exemple #25
0
 def refresh(self):
     for i, f in enumerate(self.features):
         for s in self.shapes[i]:
             if self.fc_function and hasattr(s, 'set_fc'):
                 s.set_fc(self.fc_function(f))
             if self.lw_function and hasattr(s, 'set_lw'):
                 s.set_lw(self.lw_function(f))
     if pylab.isinteractive():
         pylab.draw()
Exemple #26
0
def plot_rectangular(x,
                     y,
                     x_label=None,
                     y_label=None,
                     title=None,
                     show_legend=True,
                     axis='tight',
                     ax=None,
                     *args,
                     **kwargs):
    '''
    plots rectangular data and optionally label axes.

    Parameters
    ------------
    z : array-like, of complex data
        data to plot
    x_label : string
        x-axis label
    y_label : string
        y-axis label
    title : string
        plot title
    show_legend : Boolean
        controls the drawing of the legend
    ax : :class:`matplotlib.axes.AxesSubplot` object
        axes to draw on
    *args,**kwargs : passed to pylab.plot
    
    '''
    if ax is None:
        ax = plb.gca()

    my_plot = ax.plot(x, y, *args, **kwargs)

    if x_label is not None:
        ax.set_xlabel(x_label)

    if y_label is not None:
        ax.set_ylabel(y_label)

    if title is not None:
        ax.set_title(title)

    if show_legend:
        # only show legend if they provide a label
        if 'label' in kwargs:
            ax.legend()

    if axis is not None:
        ax.autoscale(True, 'x', True)
        ax.autoscale(True, 'y', False)

    if plb.isinteractive():
        plb.draw()

    return my_plot
Exemple #27
0
def showslice(theslice):
    if P.isinteractive():
	P.ioff()
    P.axis('off')
    P.axis('equal')
    P.axis('tight')
    P.imshow(theslice, interpolation='nearest', aspect='equal', cmap=P.cm.gray)
    P.colorbar()
    return()
Exemple #28
0
    def plot_uncertainty_bounds_s(self, multiplier=200, *args, **kwargs):
        '''
        Plots complex uncertainty bounds plot on smith chart.

        This function plots the complex uncertainty of a NetworkSet
        as circles on the smith chart. At each frequency a circle
        with radii proportional to the complex standard deviation
        of the set at that frequency is drawn. Due to the fact that
        the `markersize` argument is in pixels, the radii can scaled by
        the input argument  `multiplier`.

        default kwargs are
            {
            'marker':'o',
            'color':'b',
            'mew':0,
            'ls':'',
            'alpha':.1,
            'label':None,
            }

        Parameters
        -------------
        multipliter : float
            controls the circle sizes, by multiples of the standard
            deviation.



        '''
        default_kwargs = {
            'marker': 'o',
            'color': 'b',
            'mew': 0,
            'ls': '',
            'alpha': .1,
            'label': None,
        }
        default_kwargs.update(**kwargs)

        if plb.isinteractive():
            was_interactive = True
            plb.interactive(0)
        else:
            was_interactive = False

        [
            self.mean_s[k].plot_s_smith(*args,
                                        ms=self.std_s[k].s_mag * multiplier,
                                        **default_kwargs)
            for k in range(len(self[0]))
        ]

        if was_interactive:
            plb.interactive(1)
        plb.draw()
        plb.show()
Exemple #29
0
def plot_polar(
    theta, r, x_label=None, y_label=None, title=None, show_legend=True, axis_equal=False, ax=None, *args, **kwargs
):
    """
    plots polar data on a polar plot and optionally label axes.

    Parameters
    ------------
    theta : array-like
        data to plot
    r : array-like
        
    x_label : string
        x-axis label
    y_label : string
        y-axis label
    title : string
        plot title
    show_legend : Boolean
        controls the drawing of the legend
    ax : :class:`matplotlib.axes.AxesSubplot` object
        axes to draw on
    *args,**kwargs : passed to pylab.plot
    
    See Also
    ----------
    plot_rectangular : plots rectangular data
    plot_complex_rectangular : plot complex data on complex plane
    plot_polar : plot polar data
    plot_complex_polar : plot complex data on polar plane
    plot_smith : plot complex data on smith chart

    """
    if ax is None:
        ax = plb.gca(polar=True)

    ax.plot(theta, r, *args, **kwargs)

    if x_label is not None:
        ax.set_xlabel(x_label)

    if y_label is not None:
        ax.set_ylabel(y_label)

    if title is not None:
        ax.set_title(title)

    if show_legend:
        # only show legend if they provide a label
        if "label" in kwargs:
            ax.legend()

    if axis_equal:
        ax.axis("equal")

    if plb.isinteractive():
        plb.draw()
Exemple #30
0
def plot_smith(z, smith_r=1, chart_type='z', x_label='Real',
    y_label='Imaginary', title='Complex Plane', show_legend=True,
    axis='equal', ax=None, force_chart = False, *args, **kwargs):
    '''
    plot complex data on smith chart

    Parameters
    ------------
    z : array-like, of complex data
        data to plot
    smith_r : number
        radius of smith chart
    chart_type : ['z','y']
        Contour type for chart.
         * *'z'* : lines of constant impedance
         * *'y'* : lines of constant admittance
    x_label : string
        x-axis label
    y_label : string
        y-axis label
    title : string
        plot title
    show_legend : Boolean
        controls the drawing of the legend
    axis_equal: Boolean
        sets axis to be equal increments (calls axis('equal'))
    force_chart : Boolean
        forces the re-drawing of smith chart 
    ax : :class:`matplotlib.axes.AxesSubplot` object
        axes to draw on
    *args,**kwargs : passed to pylab.plot

    See Also
    ----------
    plot_rectangular : plots rectangular data
    plot_complex_rectangular : plot complex data on complex plane
    plot_polar : plot polar data
    plot_complex_polar : plot complex data on polar plane
    plot_smith : plot complex data on smith chart
    '''
    
    if ax is None:
        ax = plb.gca()

    # test if smith chart is already drawn
    if not force_chart:
        if len(ax.patches) == 0:
            smith(ax=ax, smithR = smith_r, chart_type=chart_type)

    plot_complex_rectangular(z, x_label=x_label, y_label=y_label,
        title=title, show_legend=show_legend, axis=axis,
        ax=ax, *args, **kwargs)

    ax.axis(smith_r*npy.array([-1.1, 1.1, -1.1, 1.1]))
    if plb.isinteractive():
        plb.draw()
Exemple #31
0
def plot_polar(theta, r, x_label=None, y_label=None, title=None,
    show_legend=True, axis_equal=False, ax=None, *args, **kwargs):
    '''
    plots polar data on a polar plot and optionally label axes.

    Parameters
    ------------
    theta : array-like
        data to plot
    r : array-like
        
    x_label : string
        x-axis label
    y_label : string
        y-axis label
    title : string
        plot title
    show_legend : Boolean
        controls the drawing of the legend
    ax : :class:`matplotlib.axes.AxesSubplot` object
        axes to draw on
    *args,**kwargs : passed to pylab.plot
    
    See Also
    ----------
    plot_rectangular : plots rectangular data
    plot_complex_rectangular : plot complex data on complex plane
    plot_polar : plot polar data
    plot_complex_polar : plot complex data on polar plane
    plot_smith : plot complex data on smith chart

    '''
    if ax is None:
        ax = plb.gca(polar=True)

    ax.plot(theta, r, *args, **kwargs)

    if x_label is not None:
        ax.set_xlabel(x_label)

    if y_label is not None:
        ax.set_ylabel(y_label)

    if title is not None:
        ax.set_title(title)

    if show_legend:
        # only show legend if they provide a label
        if 'label' in kwargs:
            ax.legend()

    if axis_equal:
        ax.axis('equal')
        
    if plb.isinteractive():
        plb.draw()
Exemple #32
0
 def plot(self):
     """
     Draw this layout to a matplotlib canvas.
     """
     fig = self._doPlot()
     if not pylab.isinteractive():
         pylab.show()
     else:
         pylab.draw()
     pylab.close(fig)
Exemple #33
0
 def plot(self):
     """
     Draw this layout to a matplotlib canvas.
     """
     fig = self._doPlot()
     if not pylab.isinteractive():
         pylab.show()
     else:
         pylab.draw()
     pylab.close(fig)
Exemple #34
0
def showlines(vs,
              fmts=None,
              labels=None,
              size=(4.1, 2),
              lblx=True,
              lbly=True,
              **kwargs):
    # {{{
    '''
  Produce line plots of a list of 1D variables on a single figure.

  Parameters
  ----------
  vs :  list of :class:`Var`
     The variables to plot. Should all have 1 non-degenerate axis.
  '''

    Z = [v.squeeze() for v in vs]

    for z in Z:
        assert z.naxes == 1, 'Variable %s has %d non-generate axes; must have 1.' % (
            z.name, z.naxes)

    fig = kwargs.pop('fig', None)

    ax = wr.AxesWrapper(size=size)
    ydat = []
    for i, v in enumerate(vs):
        if fmts is None:
            fmt = ''
        elif hasattr(fmts, '__len__'):
            fmt = fmts[i]
        else:
            fmt = fmts

        if labels is None:
            lbl = v.name
        elif hasattr(labels, '__len__'):
            lbl = labels[i]
        else:
            lbl = labels

        vplot(v, axes=ax, fmt=fmt, label=lbl)
        ydat.append(ax.find_plot(wr.Plot).plot_args[1])

    #ylim = (np.min([np.min(y) for y in ydat]), np.max([np.max(y) for y in ydat]))
    #kwargs.update(dict(ylim=ylim))

    kwleg = kwargs.pop('legend', dict(loc='best', frameon=False))
    ax.legend(**kwleg)
    ax.setp(**kwargs)

    import pylab as pyl
    if pyl.isinteractive(): ax.render(fig)
    return ax
Exemple #35
0
    def draw_selection(self, lbl, replace=True):
        """ draw a given subset """
        if (lbl not in self._draws) | (replace is True):
            sample = self.selections[lbl]

            self._draws[lbl] = sample.draw(self.x, self.y, ax=self.axes)

            if plt.isinteractive():
                self.draw()

            return sample, self._draws[lbl]
Exemple #36
0
    def draw_selection(self, lbl, replace=True):
        """ draw a given subset """
        if (lbl not in self._draws) | (replace is True):
            sample = self.selections[lbl]

            self._draws[lbl] = sample.draw(self.x, self.y, ax=self.axes)

            if plt.isinteractive():
                self.draw()

            return sample, self._draws[lbl]
Exemple #37
0
    def plot_uncertainty_bounds_s(self, multiplier =200, *args, **kwargs):
        '''
        Plots complex uncertainty bounds plot on smith chart.

        This function plots the complex uncertainty of a NetworkSet
        as circles on the smith chart. At each frequency a circle
        with radii proportional to the complex standard deviation
        of the set at that frequency is drawn. Due to the fact that
        the `markersize` argument is in pixels, the radii can scaled by
        the input argument  `multiplier`.

        default kwargs are
            {
            'marker':'o',
            'color':'b',
            'mew':0,
            'ls':'',
            'alpha':.1,
            'label':None,
            }

        Parameters
        -------------
        multipliter : float
            controls the circle sizes, by multiples of the standard
            deviation.



        '''
        default_kwargs = {
            'marker':'o',
            'color':'b',
            'mew':0,
            'ls':'',
            'alpha':.1,
            'label':None,
            }
        default_kwargs.update(**kwargs)



        if plb.isinteractive():
            was_interactive = True
            plb.interactive(0)
        else:
            was_interactive = False

        [self.mean_s[k].plot_s_smith(*args, ms = self.std_s[k].s_mag*multiplier, **default_kwargs) for k in range(len(self[0]))]

        if was_interactive:
            plb.interactive(1)
        plb.draw()
        plb.show()
Exemple #38
0
 def wrapper(*args, **kwds):
     interactive_mode = P.isinteractive()
     if interactive_mode:
         #logging.debug('Turning pylab interactive off.')
         P.ioff()
     try:
         return fn(*args, **kwds)
     finally:
         if interactive_mode:
             #logging.debug('Turning pylab interactive on.')
             P.ion()
Exemple #39
0
 def __call__(self, recalc_range=False):
     if recalc_range:
         self.maxvalue = max((self.f(c) for c in self.polygons.iterkeys()))
         self.minvalue = min((self.f(c) for c in self.polygons.iterkeys()))
     for cell, poly in self.polygons.iteritems():
         v = self.f(cell)
         c = self.cmap(
             (v - self.minvalue) / (self.maxvalue - self.minvalue))
         poly.set_fc(c)
     if pylab.isinteractive():
         pylab.draw()
Exemple #40
0
def delgraticules():
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ax.delgraticules()
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #41
0
def Trace_diag(LH,Lna,LT,LHR,Lair,fignum) :
	figure(fignum)
	if isinteractive() :
		ioff()	
	lna_H,lH_H=Return_Hs(LH,Lna)
	Plotlines(lna_H,lH_H,lineprops)
	lna_T,lH_T=Return_Ts(LT,Lna)
	Plotlines(lna_T,lH_T,lineprops)
	lna_HR,lH_HR=Return_HRs(Lna,LHR)
	PlotHR(lna_HR,lH_HR,LHR,lineprops_HR)
	Ttick=Transf_xy(Lna[0],array(lH_T[0:-1:2]))[1]
	Tlabel=map(str,LT)
	yticks(Ttick,Tlabel)
	xlabel(r'$\rm{Teneur\ en\ eau\ (na)}\ [\ g_{H_2O}\ /\ g_{AS}\ ]$')
	ylabel(r'$\rm{Temp\'erature\ (T)}\ [\ ^{\circ}C\ ]$')
	title("Diagramme de l'air humide")
	if not(isinteractive()) :
		ion()
	axis([x1,x3,y1,y3])
	setp(gca(),autoscale_on=False)
	draw()
Exemple #42
0
def delgraticules():
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        for ax in f.get_axes():
            if isinstance(ax, PA.SphericalProjAxes):
                ax.delgraticules()
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #43
0
 def __init__(self,
              cells,
              value_function,
              cmap=pylab.cm.jet,
              hold=True,
              vmin=None,
              vmax=None,
              **kwargs):
     self.cells = cells
     self.__f = value_function
     was_interactive = pylab.isinteractive()
     if was_interactive: pylab.ioff()
     geos = []
     self.maxvalue = -1e300 if vmax is None else vmax
     self.minvalue = 1e300 if vmin is None else vmin
     self.polygons = {}
     # Generate image array, which is filled with generated values from self.f
     self._A = []
     for cell in cells:
         shape = geoms[cell]
         if hasattr(shape, "geoms"):
             shapes = shape.geoms
         else:
             shapes = [shape]
         value = self.f(cell)
         self._A.append(value)
         if vmax is None:
             self.maxvalue = max(value, self.maxvalue)
         if vmin is None:
             self.minvalue = min(value, self.minvalue)
         for s in shapes:
             geos.append((cell, s, value))
     if self.minvalue >= self.maxvalue: self.minvalue = self.maxvalue - 1
     for cell, s, v in geos:
         if hasattr(s, "exterior"):
             s = s.exterior
         c = cmap(
             float(v - self.minvalue) /
             float(self.maxvalue - self.minvalue))
         a = pylab.asarray(s)
         self.polygons[cell] = pylab.fill(a[:, 0],
                                          a[:, 1],
                                          fc=c,
                                          hold=hold,
                                          **kwargs)[0]
         hold = 1
     pylab.axis('equal')
     norm = pylab.matplotlib.colors.Normalize(self.minvalue, self.maxvalue)
     pylab.matplotlib.cm.ScalarMappable.__init__(self, norm, cmap)
     if was_interactive:
         pylab.draw()
         pylab.ion()
Exemple #44
0
    def draw(self, axes=None, loc=2):
        if axes == None:
            axes = p.gca()

        if self.box != None and self.box in axes.artists:
            del axes.artists[axes.artists.index(self.box)]

        #key_areas = [ mpl.offsetbox.TextArea(k, textprops=self.textprops) for k in self.datadict.keys() ]
        #val_areas = [ mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops) for k in self.datadict.keys() ]
        key_areas = [
            mpl.offsetbox.TextArea(k, textprops=self.textprops)
            for k in list(self.datadict.keys())
        ]
        val_areas = [
            mpl.offsetbox.TextArea(self.datadict[k], textprops=self.textprops)
            for k in list(self.datadict.keys())
        ]

        key_vpack = mpl.offsetbox.VPacker(children=key_areas,
                                          align="left",
                                          pad=0,
                                          sep=0)
        val_vpack = mpl.offsetbox.VPacker(children=val_areas,
                                          align="right",
                                          pad=0,
                                          sep=0)
        hpack = mpl.offsetbox.HPacker(children=[key_vpack, val_vpack],
                                      align="top",
                                      pad=0,
                                      sep=4)

        globchildren = []
        if self.title != None:
            #titlearea = mpl.offsetbox.TextArea(self.title, textprops=self.titleprops)
            titlearea = mpl.offsetbox.TextArea(self.title)
            globchildren.append(titlearea)

        globchildren.append(hpack)
        globvpack = mpl.offsetbox.VPacker(children=globchildren,
                                          align="center",
                                          pad=0,
                                          sep=1)

        self.box = mpl.offsetbox.AnchoredOffsetbox(loc=loc, child=globvpack)
        self.box.patch.set_facecolor(self.facecolor)
        self.box.patch.set_edgecolor(self.edgecolor)
        self.box.patch.set_alpha(self.alpha)
        axes.add_artist(self.box)

        if p.isinteractive():
            p.gcf().canvas.draw()
Exemple #45
0
def histogram_p_values(p_values, tag):
    import pylab as P
    interactive_mode = P.isinteractive()
    P.ioff()
    try:
        P.figure()
        P.hist(p_values)
        P.title('%s p-values for transcriptional programs' % tag)
        P.xlabel('p-values')
        P.savefig(os.path.join(output_dir, 'p-values-for-%ss.png' % tag), format='PNG')
        P.close()
    finally:
        if interactive_mode:
            P.ion()
Exemple #46
0
def graticule(dpar=None, dmer=None, coord=None, local=None, **kwds):
    """Draw a graticule on the current Axes.

    Parameters
    ----------
    dpar, dmer : float, scalars
      Interval in degrees between meridians and between parallels
    coord : {'E', 'G', 'C'}
      The coordinate system of the graticule (make rotation if needed,
      using coordinate system of the map if it is defined).
    local : bool
      If True, draw a local graticule (no rotation is performed, useful for
      a gnomonic view, for example)

    Notes
    -----
    Other keyword parameters will be transmitted to the projplot function.

    See Also
    --------
    delgraticules
    """
    import pylab

    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if len(f.get_axes()) == 0:
            ax = PA.HpxMollweideAxes(f, (0.02, 0.05, 0.96, 0.9), coord=coord)
            f.add_axes(ax)
            ax.text(
                0.86,
                0.05,
                ax.proj.coordsysstr,
                fontsize=14,
                fontweight="bold",
                transform=ax.transAxes,
            )
        for ax in f.get_axes():
            if isinstance(ax, PA.SphericalProjAxes):
                ax.graticule(dpar=dpar,
                             dmer=dmer,
                             coord=coord,
                             local=local,
                             **kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #47
0
def plot_rectangular(x, y, x_label=None, y_label=None, title=None,
    show_legend=True, axis='tight', ax=None, *args, **kwargs):
    '''
    plots rectangular data and optionally label axes.

    Parameters
    ------------
    z : array-like, of complex data
        data to plot
    x_label : string
        x-axis label
    y_label : string
        y-axis label
    title : string
        plot title
    show_legend : Boolean
        controls the drawing of the legend
    ax : :class:`matplotlib.axes.AxesSubplot` object
        axes to draw on
    *args,**kwargs : passed to pylab.plot
    
    '''
    if ax is None:
        ax = plb.gca()

    my_plot = ax.plot(x, y, *args, **kwargs)

    if x_label is not None:
        ax.set_xlabel(x_label)

    if y_label is not None:
        ax.set_ylabel(y_label)

    if title is not None:
        ax.set_title(title)

    if show_legend:
        # only show legend if they provide a label
        if 'label' in kwargs:
            ax.legend()

    if axis is not None:
        ax.autoscale(True, 'x', True)
        ax.autoscale(True, 'y', False)
        
    if plb.isinteractive():
        plb.draw()
    
    return my_plot
Exemple #48
0
def histogram_p_values(p_values, tag):
    import pylab as P
    interactive_mode = P.isinteractive()
    P.ioff()
    try:
        P.figure()
        P.hist(p_values)
        P.title('%s p-values for transcriptional programs' % tag)
        P.xlabel('p-values')
        P.savefig(os.path.join(output_dir, 'p-values-for-%ss.png' % tag),
                  format='PNG')
        P.close()
    finally:
        if interactive_mode:
            P.ion()
Exemple #49
0
def projtext(*args,**kwds):
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    ret = None
    try:
        for ax in f.get_axes():
            if isinstance(ax,PA.SphericalProjAxes):
                ret = ax.projtext(*args,**kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    return ret
Exemple #50
0
def projtext(*args, **kwds):
    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    ret = None
    try:
        for ax in f.get_axes():
            if isinstance(ax, PA.SphericalProjAxes):
                ret = ax.projtext(*args, **kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
            #pylab.show()
    return ret
Exemple #51
0
def showvar(var, *args, **kwargs):
# {{{
  ''' 
  Plot variable, showing a contour plot for 2d variables or a line plot for 1d variables.

  Parameters
  ----------
  var :  :class:`Var`
     The variable to plot. Should have either 1 or 2 non-degenerate axes.

  *args, **kwargs : arguments to pass on to underlying plotting routines, see
      Notes.

  Notes
  -----
  This function is intended as the simplest way to display the contents of a
  variable, choosing appropriate parameter values as automatically as possible.
  For 1d variables it calls :func:`Var.vplot()`, and for 2d variables
  :func:`Var.vcontour`. In the latter case, if filled contours were produced, it
  calls `AxesWrapper.colorbar()'. A dictionary ``colorbar`` can be provided to
  pass arguments through. Setting ``colorbar`` to ``False`` suppresses the
  colorbar.

  See Also
  --------
  vplot, vcontour, colorbar
  '''

  Z = var.squeeze()
  assert Z.naxes in [1, 2], 'Variable %s has %d non-generate axes; must have 1 or 2.' % (var.name, Z.naxes)

  fig = kwargs.pop('fig', None)

  if Z.naxes == 1:
    ax = vplot(var, *args, **kwargs)

  elif Z.naxes == 2:
    ax = vcontour(var, *args, **kwargs)

    cbar = kwargs.pop('colorbar', dict(orientation='vertical'))
    cf = ax.find_plot(wr.Contourf)
    if cbar and cf is not None:
      ax = wr.colorbar(ax, cf, **cbar)

  import pylab as pyl
  if pyl.isinteractive():
    ax.render(fig)
  return ax
def test_analytic_phase(verbose=3):
    """ 
    >>> test_analytic_phase()
    """
    t=array(range(10000))/100.
    x=sin(t+t**2/30)
    y=cos(t+t**2/30)
    if len(analytic_phase(x)) < len(x):  
        print('shortened from {0} to {1}'
              .format(len(x),len(analytic_phase(x)))) 
    if verbose>2:
        xx0=pl.plot(smooth(analytic_phase(x) - analytic_phase(y), 10), hold=0)
        xx1=pl.plot(smooth(analytic_phase(x) - analytic_phase(y+100), 10),
                     'k--', hold=1)
        pl.title('black dash and blue should overlay well')
        if not(pl.isinteractive()): pl.show()
Exemple #53
0
def bar_timeseries(data, **kwargs):
    try:
        step = kwargs.pop('step')
        ts = data.reduce_avg(data.begin - data.begin % step, step)
    except KeyError:
        ts = data
    x = __x_from_ts(ts)
    was_inter = pylab.isinteractive()
    pylab.ioff()
    bars = pylab.bar(x, ts, ts.step / cmf.day, **kwargs)
    ax = pylab.gca()
    ax.xaxis_date()
    if was_inter:
        pylab.draw()
        pylab.ion()
    return bars
def test_analytic_phase(verbose=3):
    """ 
    >>> test_analytic_phase()
    """
    t=array(range(10000))/100.
    x=sin(t+t**2/30)
    y=cos(t+t**2/30)
    if len(analytic_phase(x)) < len(x):  
        print('shortened from {0} to {1}'
              .format(len(x),len(analytic_phase(x)))) 
    if verbose>2:
        xx0=pl.plot(smooth(analytic_phase(x) - analytic_phase(y), 10), hold=0)
        xx1=pl.plot(smooth(analytic_phase(x) - analytic_phase(y+100), 10),
                     'k--', hold=1)
        pl.title('black dash and blue should overlay well')
        if not(pl.isinteractive()): pl.show()
Exemple #55
0
def graticule(dpar=None, dmer=None, coord=None, local=None, **kwds):
    """Draw a graticule on the current Axes.

    Parameters
    ----------
    dpar, dmer : float, scalars
      Interval in degrees between meridians and between parallels
    coord : {'E', 'G', 'C'}
      The coordinate system of the graticule (make rotation if needed,
      using coordinate system of the map if it is defined).
    local : bool
      If True, draw a local graticule (no rotation is performed, useful for
      a gnomonic view, for example)

    Notes
    -----
    Other keyword parameters will be transmitted to the projplot function.

    See Also
    --------
    delgraticules
    """
    import pylab

    f = pylab.gcf()
    wasinteractive = pylab.isinteractive()
    pylab.ioff()
    try:
        if len(f.get_axes()) == 0:
            ax = PA.HpxMollweideAxes(f, (0.02, 0.05, 0.96, 0.9), coord=coord)
            f.add_axes(ax)
            ax.text(
                0.86,
                0.05,
                ax.proj.coordsysstr,
                fontsize=14,
                fontweight="bold",
                transform=ax.transAxes,
            )
        for ax in f.get_axes():
            if isinstance(ax, PA.SphericalProjAxes):
                ax.graticule(dpar=dpar, dmer=dmer, coord=coord, local=local, **kwds)
    finally:
        pylab.draw()
        if wasinteractive:
            pylab.ion()
Exemple #56
0
def hinton(W, labels=['', ''], axes=[[], []], name="", maxWeight=None):
    """
    Draws a Hinton diagram for visualizing a weight matrix. 
    Temporarily disables matplotlib interactive mode if it is on, 
    otherwise this takes forever.
    """
    reenable = False
    if P.isinteractive():
        P.ioff()
    P.clf()
    height, width = W.shape
    if not maxWeight:
        maxWeight = 2**N.ceil(N.log(N.max(N.abs(W))) / N.log(2))

    P.fill(N.array([0, width, width, 0]), N.array([0, 0, height, height]),
           'gray')
    #P.axis('off')
    P.axis('equal')
    P.axis('image')
    P.xlabel(labels[0])
    P.ylabel(labels[1])
    #fig = P.figure()
    #ax = fig.add_subplot(111)
    #ax.set_xticklabels(axes[0])
    #ax.set_yticklabels(axes[1])
    P.xticks(N.arange(len(axes[0])) + 0.5, axes[0], fontsize=10)
    P.yticks(N.arange(len(axes[1])) + 0.5, axes[1], fontsize=10)
    for x in xrange(width):
        for y in xrange(height):
            _x = x + 1
            _y = y + 1
            w = W[y, x]
            if w > 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, w / maxWeight),
                      'white')
            elif w < 0:
                _blob(_x - 0.5, height - _y + 0.5, min(1, -w / maxWeight),
                      'black')
    if reenable:
        P.ion()
    #P.show()
    if name == "":
        P.savefig("hinton.png")
    else:
        P.savefig(name + ".png")
Exemple #57
0
def plot_tseries(dtimes, data, ax=None, labels=None, datefmt='%b %d, %H:%M', colors=None, ylabel="",
                 title="", fontsize="medium", saveto="", **kwargs):
    """Plot time series data (e.g. gage recordings)

    Parameters
    ----------
    dtimes : array of datetime objects (time steps)
    data : 2D array of shape ( num time steps, num data series )
    labels : list of strings (names of data series)
    title : string
    kwargs : keyword arguments related to pylab.plot

    """
    if ax is None:
        returnax = False
        fig = pl.figure()
        ax = fig.add_subplot(1, 1, 1, title=title)
    else:
        returnax = True
    # if labels==None:
    #    labels = ["series%d"%i for i in range(1, data.shape[1]+1)]
    # for i, label in enumerate(labels):
    #    ax.plot_date(mpl.dates.date2num(dtimes),data[:,i],label=label, color=colors[i], **kwargs)
    ax.plot_date(mpl.dates.date2num(dtimes), data, **kwargs)
    ax.xaxis.set_major_formatter(mdates.DateFormatter(datefmt))
    pl.setp(ax.get_xticklabels(), visible=True)
    pl.setp(ax.get_xticklabels(), rotation=-30, horizontalalignment='left')
    ax.set_ylabel(ylabel, size=fontsize)
    ax = set_ticklabel_size(ax, fontsize)
    ax.legend(loc='best')

    if returnax:
        return ax

    if saveto == "":
        # show plot
        pl.show()
        if not pl.isinteractive():
            # close figure explicitely if pylab is not in interactive mode
            pl.close()
    else:
        # save plot to file
        if (path.exists(path.dirname(saveto))) or (path.dirname(saveto) == ''):
            pl.savefig(saveto)
            pl.close()