Python plotter.EmPlotter类代码示例

    def _visualize(self, obj, **kwargs):
        fnResults = self.protocol._getPath("results.txt")

        if exists(fnResults):
            X, Y, _, _ = self.protocol.getXYValues(False)

            minX = min(X)
            maxX = max(X)
            step = (maxX - minX) / 50
            xValues = np.arange(minX, maxX+step, step)
            yValues = self.protocol.evalFunction(xValues)

            plotter = EmPlotter()
            varNameX = self.protocol.labelX.get()
            varNameY = self.protocol.labelY.get()
            ax = plotter.createSubPlot("Regression Plot",
                                       "%s [%s]"%(varNameX,strUnit(self.protocol.experiment.variables[varNameX].units.unit)),
                                       "%s [%s]"%(varNameY,strUnit(self.protocol.experiment.variables[varNameY].units.unit)))
            ax.plot(xValues, yValues)
            ax.plot(X, Y, 'o')

            return [plotter]
        else:
            return [self.errorMessage("Result file '%s' not produced yet. "
                                      % fnResults)]

    def _visualizeMatrix(self,e=None):
        views = []
        self.isComputed()
        inputCTFs=self.protocol.inputCTFs
        shape=len(inputCTFs)#number of methods
        _matrix = np.zeros(shape=(shape, shape))
        ticksLablesMajorX=[None] * shape
        ticksLablesMajorY=[None] * shape
        for ctf in self.setOfCTFsConst:
            m1 = int(self.extract(ctf.getAttributeValue('method1')))-1
            m2 = int(self.extract(ctf.getAttributeValue('method2')))-1
            _matrix[m1][m2] += 1
            _matrix[m2][m1] = _matrix[m1][m2]
            #rather inefficient but since  outputCTF is not ordered...
            if ticksLablesMajorX[m1] is None:
                ticksLablesMajorX[m1] = "(%d)"%(m1+1)
                ticksLablesMajorY[m1] = ctf.getAttributeValue('method1')
            if ticksLablesMajorX[m2] is None:
                ticksLablesMajorX[m2] = "(%d)"%(m2+1)
                ticksLablesMajorY[m2] = ctf.getAttributeValue('method2')

        plotter = EmPlotter(fontsize=14)
        resolution=self.resolutionThreshold.get()
        plotter.createSubPlot("# micrographs with resolution (A)\n lower than %d"%(resolution),
                      "Method #", "Method")
#        plotter.plotMatrix(_matrix,cmap='seismic_r'
        plotter.plotMatrix(_matrix,cmap='Greens'
                        , xticksLablesMajor=ticksLablesMajorX,rotationX=0
                        , yticksLablesMajor=ticksLablesMajorY)
        views.append(plotter)
        return views

    def _displayAngDist(self, *args):
        #print "_displayAngDist...."
        iterations = self._getIterations()
        nparts = self.protocol.inputParticles.get().getSize()
        views = []
        
        if self.displayAngDist == ANGDIST_2DPLOT:
	    #print " self.displayAngDist == ANGDIST_2DPLO "
            for it in iterations:
                anglesSqlite = self._getFinalPath('angular_dist_%03d.sqlite' % it)
                title = 'Angular distribution iter %03d' % it
                plotter = EmPlotter(x=1, y=1, windowTitle=title)
                self.createAngDistributionSqlite(anglesSqlite, nparts, 
                                                 itemDataIterator=self._iterAngles(it))
                plotter.plotAngularDistributionFromMd(anglesSqlite, title)
                views.append(plotter)
        else:
            it = iterations[-1]
            print "Using last iteration: ", it
            anglesSqlite = self._getFinalPath('angular_dist_%03d.sqlite' % it)
            self.createAngDistributionSqlite(anglesSqlite, nparts, 
                                                 itemDataIterator=self._iterAngles(it))
            volumes = self.getVolumeNames(it)
            views.append(em.ChimeraClientView(volumes[0], 
                                              showProjection=True, 
                                              angularDistFile=anglesSqlite, 
                                              spheresDistance=2))#self.spheresScale.get()))
            
        return views

 def _plotFactorMaps(self, param=None):
     # Parse the file
     fn = self.protocol._getFileName('imcFile')
     f = open(fn)
     values = f.readline().split()
     n = int(values[0]) # Number of images
     nf = int(values[1]) # Number of factors
     
     x = self.firstFactor.get()
     y = self.secondFactor.get()
     xFactors = []
     yFactors = []
     i = 0
     while i < n:
         imgFactors = []
         while len(imgFactors) < nf:
             values = f.readline().split()
             imgFactors += [float(v) for v in values]
         xFactors.append(imgFactors[x-1])
         yFactors.append(imgFactors[y-1])
         i += 1
     f.close() 
     
     # Create the plot
     xplotter = EmPlotter(1,1)
     a = xplotter.createSubPlot("Factor %d vs %d" % (x, y), 
                                "Factor %d" % x, "Factor %d" % y)
     a.plot(xFactors, yFactors, 'o')
     
     return [xplotter]

 def _showFSC(self, paramName=None):
     threshold = self.resolutionThresholdFSC.get()
     gridsize = self._getGridSize(1)
     xplotter = EmPlotter(x=gridsize[0], y=gridsize[1], windowTitle='Resolution FSC')
     
     plot_title = 'FSC'
     a = xplotter.createSubPlot(plot_title, 'Angstroms^-1', 'FSC', yformat=False)
     legends = []
     
     show = False
     for it in self._iterations:
         if self.resolutionPlotsFSC.get() == FSC_UNMASK:
             fscUnmask = self.protocol._getFileName('fscUnmasked',run=self.protocol._getRun(), iter=it)
             if os.path.exists(fscUnmask):
                 show = True
                 self._plotFSC(a, fscUnmask)
                 legends.append('unmasked map iter %d' % it)
             xplotter.showLegend(legends)
             
         elif self.resolutionPlotsFSC.get() == FSC_MASK:
             fscMask = self.protocol._getFileName('fscMasked',run=self.protocol._getRun(), iter=it)
             if os.path.exists(fscMask):
                 show = True
                 self._plotFSC(a, fscMask)
                 legends.append('masked map iter %d' % it)
             xplotter.showLegend(legends)
             
         elif self.resolutionPlotsFSC.get() == FSC_MASKTIGHT:
             fscMaskTight = self.protocol._getFileName('fscMaskedTight',run=self.protocol._getRun(), iter=it)
             if os.path.exists(fscMaskTight):
                 show = True
                 self._plotFSC(a, fscMaskTight)
                 legends.append('masked tight map iter %d' % it)
             xplotter.showLegend(legends)
         elif self.resolutionPlotsFSC.get() == FSC_ALL:
             fscUnmask = self.protocol._getFileName('fscUnmasked',run=self.protocol._getRun(), iter=it)
             fscMask = self.protocol._getFileName('fscMasked',run=self.protocol._getRun(), iter=it)
             fscMaskTight = self.protocol._getFileName('fscMaskedTight',run=self.protocol._getRun(), iter=it)
             if os.path.exists(fscUnmask):
                 show = True
                 self._plotFSC(a, fscUnmask)
                 legends.append('unmasked map iter %d' % it)
                 self._plotFSC(a, fscMask)
                 legends.append('masked map iter %d' % it)
                 self._plotFSC(a, fscMaskTight)
                 legends.append('masked tight map iter %d' % it)
             xplotter.showLegend(legends)
     
     if show:
         if threshold < self.maxFrc:
             a.plot([self.minInv, self.maxInv],[threshold, threshold], color='black', linestyle='--')
         a.grid(True)
     else:
         raise Exception("Set a valid iteration to show its FSC")
     
     return [xplotter]

 def _visualizeHistogram(self, e=None):
     views = []
     self.isComputed()
     numberOfBins = self.visualizeHistogram.get()
     numberOfBins = min(numberOfBins, self.setOfCTFsConst.getSize())
     plotter = EmPlotter()
     plotter.createSubPlot("Resolution Discrepancies histogram", 
                   "Resolution (A)", "# of Comparisons")
     resolution = [ctf.resolution.get() for ctf in self.setOfCTFsConst]
     plotter.plotHist(resolution, nbins=numberOfBins)
     return views.append(plotter)

    def press(self,event):

        sys.stdout.flush()
        if event.key == 'S':
            self.stop = True
            self.ax.set_title('Plot is Stopped. Press C to continue plotting')
        elif event.key == 'C':
            self.ax.set_title(self._getTitle())
            self.stop = False
            self.animate()
        EmPlotter.show(self)

    def paint(self, labels):
        for label in labels:
            self.lines[label], = self.ax.plot([], [], '-', label=label)

        anim = animation.FuncAnimation(
                self.fig, self.animate,
                interval=self.monitor.samplingInterval * 1000)  # miliseconds

        self.fig.canvas.mpl_connect('scroll_event', self.onscroll)
        self.fig.canvas.mpl_connect('key_press_event', self.press)
        EmPlotter.show(self)

 def _createAngDist2D(self, it):
     fnDir = self.protocol._getExtraPath("Iter%03d"%it)
     fnAngles = join(fnDir,"angles.xmd")
     view=None
     if exists(fnAngles):
         fnAnglesSqLite = join(fnDir,"angles.sqlite")
         from pyworkflow.em.metadata.utils import getSize
         from pyworkflow.em.plotter import EmPlotter
         self.createAngDistributionSqlite(fnAnglesSqLite, getSize(fnAngles), itemDataIterator=self._iterAngles(fnAngles))
         view = EmPlotter(x=1, y=1, mainTitle="Iteration %d" % it, windowTitle="Angular distribution")
         view.plotAngularDistributionFromMd(fnAnglesSqLite, 'iter %d' % it)
     return view

            def _plot(varLabelX, varLabelY, x, y, yp):
                plotter = EmPlotter()
                ax = plotter.createSubPlot("Plot", varLabelX, varLabelY)
                xValues = _values(x, useLog=self.useTimeLog())
                ax.plot(xValues, _values(y), 'x', label="Observations")
                idx = np.argsort(xValues)
                ypValues = _values(yp)
                ax.plot(np.asarray(xValues)[idx], np.asarray(ypValues)[idx], 'g', label="Fit")
                leg = ax.legend()
                if leg:
                    leg.draggable()

                plotter.show()

    def visualize(self, obj, **kwargs):
        model = PKPDAllometricScale()
        model.load(obj.fnScale.get())

        x = np.log10(np.asarray(model.X))
        xlabel = "%s [%s]" % (model.predictor, model.predictorUnits)
        for varName, varUnits in model.scaled_vars:
            plotter = EmPlotter()
            y = np.log10(np.asarray(model.Y[varName]))
            ylabel = "%s [%s]" % (varName, varUnits)
            ax = plotter.createSubPlot(varName, xlabel, ylabel)
            ax.plot(x, y, '.', label='Species')
            ax.plot(x, np.log10(model.models[varName][0])+x*model.models[varName][1],'r', label='R2=%f'%model.qualifiers[varName][0])
            leg = ax.legend(loc='upper right')
            if leg:
                leg.draggable()
            plotter.show()

        for varName, varUnits in model.averaged_vars:
            plotter = EmPlotter()
            y = np.asarray(model.Y[varName])
            ylabel = "%s [%s]" % (varName, varUnits)
            ax = plotter.createSubPlot("Scatter Plot", xlabel, ylabel)
            ax.plot(x, y, '.', label='Species')
            ax.plot(x, model.models[varName][0]*np.ones(x.shape),'r',label='Std=%f'%model.qualifiers[varName][0])
            leg = ax.legend(loc='upper right')
            if leg:
                leg.draggable()
            plotter.show()

    def onscroll(self, event):

        if event.button == 'up':
            self.win += self.step
        else:
            self.win -= self.step
            if self.win < self.step:
               self.win = self.step

        if self.oldWin != self.win:
            self.ax.set_title(self._getTitle())
            self.oldWin= self.win
        self.animate()
        EmPlotter.show(self)

 def _showGuinier(self, volume):
     nrefs = len(self._refsList)
     gridsize = self._getGridSize(nrefs)
     guinierFn = volume + ".guinier"
     
     d2 = self._getGuinierValue(guinierFn, 0)
     
     legends = ["lnFweighted ln(F)", "corrected ln(F)", "model"]
     xplotter = EmPlotter(*gridsize, windowTitle='Guinier Plots')
     subPlot = xplotter.createSubPlot(basename(volume), 'd^-2(A^-2)', 'ln(F)', yformat=False)
     for i, legend in enumerate(legends):
         y = self._getGuinierValue(guinierFn, i+2)
         subPlot.plot(d2, y)
         xplotter.showLegend(legends)
     subPlot.grid(True)
     return xplotter

    def _onPlotClick(self, e=None):
        sampleKeys = self.samplesTree.selection()

        if sampleKeys:
            if self.plotter is None or self.plotter.isClosed():
                self.plotter = EmPlotter()
                doShow = True
                ax = self.plotter.createSubPlot("Plot", self.getTimeLabel(),
                                                self.getMeasureLabel())
                self.plotDict = {}
            else:
                doShow = False
                ax = self.plotter.getLastSubPlot()

            samples = [self.experiment.samples[k] for k in sampleKeys]
            for s in samples:
                if not s.sampleName in self.plotDict:
                    x, y = self.getPlotValues(s)
                    ax.plot(x, y, label=s.sampleName)
                    self.plotDict[s.sampleName] = True
            leg = ax.legend()
            if leg:
                leg.draggable()

            if doShow:
                self.plotter.show()
            else:
                self.plotter.draw()
        else:
            self.showInfo("Please select some sample(s) to plot.")

    def __init__(self, monitor):
        EmPlotter.__init__(self, windowTitle="CTF Monitor")
        self.monitor = monitor
        self.y2 = 0.; self.y1 = 100.
        self.win = 250 # number of samples to be ploted
        self.step = 50 # self.win  will be modified in steps of this size

        self.createSubPlot(self._getTitle(), "Micrographs", "Defocus (A)")
        self.fig = self.getFigure()
        self.ax = self.getLastSubPlot()
        self.ax.margins(0.05)
        self.ax.grid(True)
        self.oldWin = self.win

        self.lines = {}
        self.init = True
        self.stop = False