Beispiel #1
0
def getpgcmap(cmp='BuRd'):
   import pyqtgraph as pg
   import numpy as np
   if cmp =='bryw':
      STEPS = np.array([0.0, 0.2, 0.6, 1.0])
      CLRS =           ['k', 'r', 'y', 'w']
      ## Create a ColorMap
      clrmp = pg.ColorMap(STEPS, np.array([pg.colorTuple(pg.Color(c)) for c in CLRS]))
      ## Get the LookupTable
      lut = clrmp.getLookupTable()
   elif cmp == 'TrmBlk':
      pos = np.array([0.0, 0.5, 1.0])
      color = np.array([[0,0,0,255], [255,128,0,255], [255,255,0,255]], dtype=np.ubyte)
      map = pg.ColorMap(pos, color)
      lut = map.getLookupTable(0.0, 1.0, 256)
   elif cmp == 'RdBu':
      pos = np.array([0.0,0.5,1.0])
      color = np.array([[255,0,0,0],[255,255,255,255],[0,0,255,0]],dtype=np.ubyte)
      map = pg.ColorMap(pos,color)
      lut = map.getLookupTable(0.0,1.0,256)
   elif cmp == 'BuRd':
      pos = np.array([0.0,0.5,1.0])
      color = np.array([[0,0,255,0],[255,255,255,255],[255,0,0,0]],dtype=np.ubyte)
      map = pg.ColorMap(pos,color)
      lut = map.getLookupTable(0.0,1.0,256)
   return lut
Beispiel #2
0
    def __init__(self, parent=None):
        pyqtgraph.setConfigOption('background', 'k')  #before loading widget
        super(HyperSpecApp, self).__init__(parent)
        self.setupUi(self)
        self.updateBtn.clicked.connect(self.update)

        #self.view = pyqtgraph.ViewBox(self.gView0)
        #self.scene = pyqtgraph.ImageItem(self.view)
        STEPS = np.array([0.0, 0.2, 0.6, 1.0])
        CLRS = ['k', 'r', 'y', 'w']
        clrmp = pyqtgraph.ColorMap(
            STEPS,
            np.array([pyqtgraph.colorTuple(pyqtgraph.Color(c)) for c in CLRS]))
        data = np.random.normal(size=(100, 200, 200))

        #imv = pyqtgraph.image(data)
        self.ImageView2.setImage(data)

        #self.ImageView2.ui.histogram.gradient.setColorMap(clrmp)

        #self.img_array = np.zeros((1000, CHUNKSZ / 2 + 1))

        # bipolar colormap

        #pos = np.array([0., 1., 0.5, 0.25, 0.75])
        #color = np.array([[0, 255, 255, 255], [255, 255, 0, 255], [0, 0, 0, 255], (0, 0, 255, 255), (255, 0, 0, 255)],
        #                         dtype=np.ubyte)
        #cmap = pyqtgraph.ColorMap(pos, color)
        #lut = cmap.getLookupTable(0.0, 1.0, 256)
        #self.img.setLookupTable(lut)

        self.pltView1.plotItem.showGrid(True, True, 0.7)
        self.pltView2.plotItem.showGrid(True, True, 0.7)
Beispiel #3
0
 def update(self):
     start = time.time()
     if not self.paused and not self.doingPlot and hasattr(
             self, 'data') and len(self.data) > 1:
         self.doingPlot = True
         data = list(self.data)
         if len(data) > self.decimateScale:
             del data[:len(data) - self.decimateScale]
         x, y = zip(*data)
         y2, x2 = np.histogram(y, bins=self.numberBins)
         if self.parent.subtractMeans:
             x2 = x2 - np.mean(x2)
         if self.parent.normalise:
             mean = np.mean(x2)
             x2 = x2 - mean
             x2 = x2 / np.std(x2)
             x2 = x2 + mean
         r, g, b, a = pg.colorTuple(pg.mkColor(self.recordspen))
         self.pencolor = pg.mkColor(r, g, b, 255)
         self.brushcolor = pg.mkColor(r, g, b, 64)
         self.plot.setData({
             'x': x2,
             'y': y2
         },
                           pen=self.pencolor,
                           stepMode=True,
                           fillLevel=0,
                           fillBrush=self.brushcolor)
     self.doingPlot = False
Beispiel #4
0
    def setColor(self, color):
        if color != self._color:
            self._color = color
            self.colorChanged.emit()

        # handles different color formats
        try:
            r,g,b,a = pg.colorTuple(self._color)
        except:
            r,g,b,a = pg.colorTuple(pg.mkColor(self._color))
            
        if self._color:
                self.setStyleSheet('background-color: rgba(%d,%d,%d,%d);' %(r,g,b,a))
                self._color = pg.mkColor(self._color)
        else:
            self.setStyleSheet("")
    def matrix(self, rows, cols, size=50, header_color='w', no_data_color='k'):
        w = pg.GraphicsLayoutWidget()
        v = w.addViewBox()
        v.setAspectLocked()
        v.invertY()

        colormap = pg.ColorMap(
            [0, 0.01, 0.03, 0.1, 0.3, 1.0],
            [(0, 0, 100), (80, 0, 80), (140, 0, 0), (255, 100, 0),
             (255, 255, 100), (255, 255, 255)],
        )
        default = no_data_color

        summary = self.connectivity_summary(cre_type=None)

        shape = (len(rows), len(cols))
        text = np.empty(shape, dtype=object)
        fgcolor = np.empty(shape, dtype=object)
        bgcolor = np.empty(shape, dtype=object)

        for i, row in enumerate(rows):
            for j, col in enumerate(cols):
                if (row, col) in summary:
                    conn = summary[(row, col)]['connected']
                    uconn = summary[(row, col)]['unconnected']
                    color = colormap.map(conn / (conn + uconn))
                else:
                    conn, uconn = 0, 0
                    color = default
                color = pg.colorTuple(pg.mkColor(color))
                bgcolor[i, j] = color
                text[i, j] = "%d/%d" % (conn, conn + uconn)
                fgcolor[i, j] = 'w' if sum(color[:3]) < 200 else 'k'
                if conn == uconn == 0:
                    fgcolor[i, j] = 0.3

        w.matrix = MatrixItem(text=text,
                              fgcolor=fgcolor,
                              bgcolor=bgcolor,
                              rows=rows.values(),
                              cols=cols.values(),
                              size=size,
                              header_color=header_color)
        v.addItem(w.matrix)

        # colormap is logarithmic; remap to linear for legend
        colors = colormap.color
        x = np.linspace(0, 1, len(colors))
        cmap2 = pg.ColorMap(x, colors)
        legend = pg.GradientLegend([25, 300], [-20, -30])
        legend.setGradient(cmap2.getGradient())
        legend.setLabels(
            {'%d' % int(a * 100): b
             for a, b in zip(colormap.pos, x)})
        v.addItem(legend)
        w.show()
        self.matrix_widget = w

        return w
Beispiel #6
0
 def export(self, fileName=None):
     
     if isinstance(self.item, pg.PlotItem):
         mpw = MatplotlibWindow()
         MatplotlibExporter.windows.append(mpw)
         fig = mpw.getFigure()
         
         ax = fig.add_subplot(111)
         ax.clear()
         #ax.grid(True)
         
         for item in self.item.curves:
             x, y = item.getData()
             opts = item.opts
             pen = pg.mkPen(opts['pen'])
             if pen.style() == QtCore.Qt.NoPen:
                 linestyle = ''
             else:
                 linestyle = '-'
             color = tuple([c/255. for c in pg.colorTuple(pen.color())])
             symbol = opts['symbol']
             if symbol == 't':
                 symbol = '^'
             symbolPen = pg.mkPen(opts['symbolPen'])
             symbolBrush = pg.mkBrush(opts['symbolBrush'])
             markeredgecolor = tuple([c/255. for c in pg.colorTuple(symbolPen.color())])
             markerfacecolor = tuple([c/255. for c in pg.colorTuple(symbolBrush.color())])
             
             if opts['fillLevel'] is not None and opts['fillBrush'] is not None:
                 fillBrush = pg.mkBrush(opts['fillBrush'])
                 fillcolor = tuple([c/255. for c in pg.colorTuple(fillBrush.color())])
                 ax.fill_between(x=x, y1=y, y2=opts['fillLevel'], facecolor=fillcolor)
             
             ax.plot(x, y, marker=symbol, color=color, linewidth=pen.width(), linestyle=linestyle, markeredgecolor=markeredgecolor, markerfacecolor=markerfacecolor)
             
             xr, yr = self.item.viewRange()
             ax.set_xbound(*xr)
             ax.set_ybound(*yr)
         mpw.draw()
     else:
         raise Exception("Matplotlib export currently only works with plot items")
Beispiel #7
0
    def __init__(self, elems, path, sdisp, color, spec_size, max_nspec,
                 max_density, auto_adjust, *args, **kwargs):
        *_loc, elem = path

        self.id = elem.name
        self.display = sdisp
        self.smesh = elems.mesh._getStepsObjects()[0]

        if len(path) != 3:
            raise Exception(
                f'Invalid path for plotting elements in tetrahedrons: {path}')

        self.bound_min = elems.mesh.bbox.min * self.display.scale
        self.bound_max = elems.mesh.bbox.max * self.display.scale

        if color is None:
            self.col = pg.colorTuple(
                pg.intColor(
                    _GenericScatterElem.COLOR_IND,
                    hues=_GenericScatterElem.COLOR_NB,
                    alpha=_GenericScatterElem.DEFAULT_ALPHA * 255,
                ))
            _GenericScatterElem.COLOR_IND += 1
        elif hasattr(color, '__call__'):
            self.col = color(elem)
        else:
            self.col = color

        self.spec_size = spec_size
        self.max_nspec = max_nspec
        self.max_density = max_density
        self.auto_adjust = auto_adjust

        self.elems = np.array([tet.idx for tet in elems], dtype=INDEX_DTYPE)
        self.rspath = self._getResSelect(path)

        data = self._getData()

        pg.opengl.GLScatterPlotItem.__init__(self,
                                             pos=data,
                                             color=self.col,
                                             size=self.spec_size,
                                             pxMode=False)
        self.display.addItem(self)
Beispiel #8
0
    def update_display(self):
        if self.data is None:
            self.image.setImage(np.zeros((1, 1)))
            return
        axes = self.selected_axes
        self.plot.setLabels(left=axes[1], bottom=axes[0])
        data, colors = self.get_data()
        
        levels = self.levels or self.data_bounds
        
        if colors is None:
            self.image.setImage(data, levels=levels)
        else:
            comp = np.zeros(data.shape[:-1] + (3,), dtype=data.dtype)
            for i,color in enumerate(colors):
                color = np.array(pg.colorTuple(color)[:3], dtype=float).reshape(1, 1, 3) / 255.
                comp += data[..., i:i+1] * color
            self.image.setImage(comp, levels=levels)

        xvals = self.data_axes[axes[0]].values
        yvals = self.data_axes[axes[1]].values
        self.plot.getAxis('bottom').setTicks([[(i, "%0.2g"%xvals[i]) for i in range(len(xvals))]])
        self.plot.getAxis('left').setTicks([[(i, "%0.2g"%yvals[i]) for i in range(len(yvals))]])
Beispiel #9
0
    def __init__(self, parent=None):
        pyqtgraph.setConfigOption('background', 'k')  #before loading widget
        super(HyperSpecApp, self).__init__(parent)
        self.setupUi(self)
        self.updateBtn.clicked.connect(self.update)

        #self.view = pyqtgraph.ViewBox(self.gView0)
        #self.scene = pyqtgraph.ImageItem(self.view)
        STEPS = np.array([0.0, 0.2, 0.6, 1.0])
        CLRS = ['k','r','y','w']
        clrmp = pyqtgraph.ColorMap(STEPS, np.array([pyqtgraph.colorTuple(pyqtgraph.Color(c)) for c in CLRS]))
        data = np.random.normal(size=(100, 200, 200))

        #imv = pyqtgraph.image(data)
        self.ImageView2.setImage(data)

        #self.ImageView2.ui.histogram.gradient.setColorMap(clrmp)






        #self.img_array = np.zeros((1000, CHUNKSZ / 2 + 1))

        # bipolar colormap

        #pos = np.array([0., 1., 0.5, 0.25, 0.75])
        #color = np.array([[0, 255, 255, 255], [255, 255, 0, 255], [0, 0, 0, 255], (0, 0, 255, 255), (255, 0, 0, 255)],
#                         dtype=np.ubyte)
        #cmap = pyqtgraph.ColorMap(pos, color)
        #lut = cmap.getLookupTable(0.0, 1.0, 256)
        #self.img.setLookupTable(lut)


        self.pltView1.plotItem.showGrid(True, True, 0.7)
        self.pltView2.plotItem.showGrid(True, True, 0.7)
Beispiel #10
0
    def intColor(self, index=0, range=9, palette=None):

        #--- Sanity-check arguments

        if isinstance(index, QColor):
            print "BUG WARNING: ColorPalette.intColor() called with a QColor as index (ignored)"
            print index
            return index

        if isinstance(index, (int, long)) != True:
            print "BUG WARNING: ColorPalette.intColor() called with index of wrong type (ignored)"
            print index
            index = 0

        # print "MARC: ColorPalette.intColor(index=%d, range=%d)" % (index, range)

        #--- Map index into range

        if range > 0:
            index = index % range

        #--- dual-tone palette

        if palette == 'mono':
            r, g, b = [25, 25, 25]  # dark gray
            return QColor(r, g, b, 255)

        if palette == 'dual':
            r, g, b = self.ColorPalette2[index % 2]
            return QColor(r, g, b, 255)

        if palette == 'accessible':
            index = index % len(self.ColorPalette2)
            r, g, b = self.ColorPalette2[index]
            return QColor(r, g, b, 255)

        #--- Few colors requested: Use the hardcoded palette

        if (palette != 'rainbow') and (range <= self.recommendedSize):
            r, g, b = self.ColorPalette2[index]
            return QColor(r, g, b, 255)

        #--- Many colors requested: Generate a rainbow palette
        #
        #    The "pyqtgraph.intColor" function works in HSV space, and has two issues:
        #
        #        1) Some colors are difficult to see against the white background.
        #        2) Some colors are very similar to each other.
        #
        #    Avoid issue #1: We calculate contrast and darken the worst offenders.
        #    Avoid issue #2: FIXME

        color = pg.intColor(index, range)

        #--- Calculate relative luminance according to rec.709 (SRGB)
        #
        #    Discussion: http://ux.stackexchange.com/questions/82056

        r, g, b, a = pg.colorTuple(color)

        rg = (float(r) / 3294) if (r <= 10) else (((float(r) / 269) +
                                                   0.0513)**2.4)
        gg = (float(g) / 3294) if (g <= 10) else (((float(g) / 269) +
                                                   0.0513)**2.4)
        bg = (float(b) / 3294) if (b <= 10) else (((float(b) / 269) +
                                                   0.0513)**2.4)

        L_color = (0.2126 * rg) + (0.7152 * gg) + (0.0722 * bg)
        L_white = 1.0

        contrast_actual = (L_white + 0.05) / (L_color + 0.05)

        #--- Darken the color if contrast is too low (against white background)
        #
        #    The threshold value is arbitrary.  Usability experts recommend a
        #    contrast ratio of 7, but that would render the thin traces too dark.

        contrast_desired = 1.368

        if contrast_actual < contrast_desired:

            #--- Adjust (linear)

            adjust = contrast_actual / contrast_desired

            rg = rg * (0.2126 * adjust)
            gg = gg * (0.7152 * adjust)
            bg = bg * (0.0722 * adjust)

            #--- Convert to 8-bit SRGB

            r = ((rg**(1 / 2.4)) - 0.0513) * 269 if rg > 0.0031 else rg * 3294
            g = ((gg**(1 / 2.4)) - 0.0513) * 269 if gg > 0.0031 else gg * 3294
            b = ((bg**(1 / 2.4)) - 0.0513) * 269 if bg > 0.0031 else bg * 3294

            r = int(r + 0.5)
            g = int(g + 0.5)
            b = int(b + 0.5)

            r = r if r > 0 else 0
            g = g if g > 0 else 0
            b = b if b > 0 else 0

            r = r if r < 255 else 255
            g = g if g < 255 else 255
            b = b if b < 255 else 255

            #--- Convert to native

            color = QColor(r, g, b, a)

        return color
    def matrix(self,
               rows,
               cols,
               size=50,
               header_color='k',
               no_data_color=0.9,
               mode='connectivity'):
        w = pg.GraphicsLayoutWidget()
        w.setRenderHints(w.renderHints() | pg.QtGui.QPainter.Antialiasing)
        v = w.addViewBox()
        v.setBackgroundColor('w')
        v.setAspectLocked()
        v.invertY()

        if mode == 'connectivity':
            colormap = pg.ColorMap(
                [0, 0.01, 0.03, 0.1, 0.3, 1.0],
                [(0, 0, 100), (80, 0, 80), (140, 0, 0), (255, 100, 0),
                 (255, 255, 100), (255, 255, 255)],
            )
        else:
            colormap = pg.ColorMap(
                [0, 0.25, 0.5, 0.75, 1.0],
                [(0, 0, 100), (80, 0, 80), (140, 0, 0), (255, 100, 0),
                 (255, 255, 100)],
            )
        default = no_data_color

        summary = self.connectivity_summary(cre_type=None)

        shape = (len(rows), len(cols))
        text = np.empty(shape, dtype=object)
        fgcolor = np.empty(shape, dtype=object)
        bgcolor = np.empty(shape, dtype=object)
        bordercolor = np.empty(shape, dtype=object)

        for i, row in enumerate(rows):
            for j, col in enumerate(cols):
                if (row, col) in summary:
                    conn = summary[(row, col)]['connected']
                    uconn = summary[(row, col)]['unconnected']
                else:
                    conn, uconn = 0, 0
                probed = conn + uconn

                if probed == 0:
                    color = default
                else:
                    if mode == 'connectivity':
                        color = default if probed == 0 else colormap.map(
                            conn / probed)
                        color = pg.colorTuple(pg.mkColor(color))
                        bgcolor[i, j] = color
                    elif mode == 'progress':
                        prg = max(probed / 80., conn / 10.)
                        color = pg.colorTuple(pg.mkColor(colormap.map(prg)))

                bordercolor[i, j] = 0.8 if probed == 0 else 'k'
                bgcolor[i, j] = color
                fgcolor[i, j] = 0.6 if probed == 0 else (
                    'w' if sum(color[:3]) < 200 else 'k')
                text[i, j] = "%d/%d" % (conn, probed) if probed > 0 else ''

        w.matrix = MatrixItem(text=text,
                              fgcolor=fgcolor,
                              bgcolor=bgcolor,
                              border_color=bordercolor,
                              rows=rows.values(),
                              cols=cols.values(),
                              size=size,
                              header_color=header_color)
        v.addItem(w.matrix)

        # colormap is logarithmic; remap to linear for legend
        colors = colormap.color
        x = np.linspace(0, 1, len(colors))
        cmap2 = pg.ColorMap(x, colors)
        legend = pg.GradientLegend([25, 300], [-20, -30])
        legend.setGradient(cmap2.getGradient())
        legend.setLabels(
            {'%d' % int(a * 100): b
             for a, b in zip(colormap.pos, x)})
        v.addItem(legend)
        w.show()
        self.matrix_widget = w

        return w
Beispiel #12
0
fit = gaussian(*params)
print params
height, center_x, center_y, width_x, width_y = params
center_x += 256
center_y += 256
#tmp = np.fromfunction(lambda x,y: height*np.exp(-(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2), (1024,1024))
tmp = np.fromfunction(lambda x,y: np.sin(0.1*(x+y)), (512,512))
################################### Visualization
app = QtGui.QApplication([])
## Create window with four ImageView widgets
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')

STEPS = np.array([0.0, 0.33, 0.66, 1.0])
CLRS = ['k', 'r', 'y', 'w']
clrmp = pg.ColorMap(STEPS, np.array([pg.colorTuple(pg.Color(c)) for c in CLRS]))

win = QtGui.QMainWindow()
win.show()
win.resize(900,900)
win.setWindowTitle('Seeing of '+data_filename)

cw = QtGui.QWidget()
win.setCentralWidget(cw)
l = QtGui.QGridLayout()
cw.setLayout(l)
imv1, imv2, imv3, imv4 = pg.ImageView(), pg.ImageView(), pg.ImageView(), pg.ImageView()
l.addWidget(imv1, 0, 0), l.addWidget(imv2, 0, 1), l.addWidget(imv3, 1, 0), l.addWidget(imv4, 1, 1)

imv1.setImage(frame, levels=(300, 2000)), imv1.ui.normBtn.hide(), imv1.ui.histogram.gradient.setColorMap(clrmp)
imv2.setImage(avg), imv2.ui.normBtn.hide(), imv2.ui.histogram.gradient.setColorMap(clrmp)
from misura.canon.indexer import SharedFile
from misura.canon.reference import get_node_reference

try:
    import pyqtgraph as pg
    import pyqtgraph.opengl as gl
except:
    pg = False
    gl = False

STEPS = np.array([0.0, 0.33, 0.66, 1.0])
CLRS = ['b', 'r', 'y', 'w']

if pg:
    clrmp = pg.ColorMap(STEPS,
                        np.array([pg.colorTuple(pg.Color(c)) for c in CLRS]))


#TODO: add decoding
def read_file(profile, start=3500, end=-1, max_layers=1000, cut=0):
    xs = []
    ys = []
    zs = []
    colors = []

    c = 0.
    n = len(profile)
    if end < 0:
        end += n
    n = end - start + 1
    step = max(n // max_layers, 1)
Beispiel #14
0
 def contrasting_text_color(self, color):
     r, g, b, a = pg.colorTuple(pg.mkColor(color))
     return pg.mkBrush(
         '000' if 1 -
         (r * 0.299 + g * 0.587 + b * 0.114) / 255 < 0.5 else 'fff')
def distance_plot(connected, distance, plots=None, color=(100, 100, 255), size=10, window=40e-6, spacing=None, name=None, fill_alpha=30):
    """Draw connectivity vs distance profiles with confidence intervals.
    
    Parameters
    ----------
    connected : boolean array
        Whether a synaptic connection was found for each probe
    distance : array
        Distance between cells for each probe
    plots : list of PlotWidget | PlotItem
        (optional) Two plots used to display distance profile and scatter plot.
    color : tuple
        (R, G, B) color values for line and confidence interval. The confidence interval
        will be drawn with alpha=100
    size: int
        size of scatter plot symbol
    window : float
        Width of distance window over which proportions are calculated for each point on
        the profile line.
    spacing : float
        Distance spacing between points on the profile line


    Note: using a spacing value that is smaller than the window size may cause an
    otherwise smooth decrease over distance to instead look more like a series of downward steps.
    """
    color = pg.colorTuple(pg.mkColor(color))[:3]
    connected = np.array(connected).astype(float)
    distance = np.array(distance)
    pts = np.vstack([distance, connected]).T
    
    # scatter points a bit
    conn = pts[:,1] == 1
    unconn = pts[:,1] == 0
    if np.any(conn):
        cscat = pg.pseudoScatter(pts[:,0][conn], spacing=10e-6, bidir=False)
        mx = abs(cscat).max()
        if mx != 0:
            cscat = cscat * 0.2# / mx
        pts[:,1][conn] = -5e-5 - cscat
    if np.any(unconn):
        uscat = pg.pseudoScatter(pts[:,0][unconn], spacing=10e-6, bidir=False)
        mx = abs(uscat).max()
        if mx != 0:
            uscat = uscat * 0.2# / mx
        pts[:,1][unconn] = uscat

    # scatter plot connections probed
    if plots is None:
        grid = PlotGrid()
        grid.set_shape(2, 1)
        grid.grid.ci.layout.setRowStretchFactor(0, 5)
        grid.grid.ci.layout.setRowStretchFactor(1, 10)
        plots = (grid[1,0], grid[0,0])
        plots[0].grid = grid
        plots[0].addLegend()
        grid.show()
        plots[0].setLabels(bottom=('distance', 'm'), left='connection probability')

    if plots[1] is not None:
        plots[1].setXLink(plots[0])
        plots[1].hideAxis('bottom')
        plots[1].hideAxis('left')

        color2 = color + (100,)
        scatter = plots[1].plot(pts[:,0], pts[:,1], pen=None, symbol='o', labels={'bottom': ('distance', 'm')}, size=size, symbolBrush=color2, symbolPen=None, name=name)
        scatter.scatter.opts['compositionMode'] = pg.QtGui.QPainter.CompositionMode_Plus

    # use a sliding window to plot the proportion of connections found along with a 95% confidence interval
    # for connection probability

    if spacing is None:
        spacing = window / 4.0
        
    xvals = np.arange(window / 2.0, 500e-6, spacing)
    upper = []
    lower = []
    prop = []
    ci_xvals = []
    for x in xvals:
        minx = x - window / 2.0
        maxx = x + window / 2.0
        # select points inside this window
        mask = (distance >= minx) & (distance <= maxx)
        pts_in_window = connected[mask]
        # compute stats for window
        n_probed = pts_in_window.shape[0]
        n_conn = pts_in_window.sum()
        if n_probed == 0:
            prop.append(np.nan)
        else:
            prop.append(n_conn / n_probed)
            ci = proportion_confint(n_conn, n_probed, method='beta')
            lower.append(ci[0])
            upper.append(ci[1])
            ci_xvals.append(x)

    # plot connection probability and confidence intervals
    color2 = [c / 3.0 for c in color]
    mid_curve = plots[0].plot(xvals, prop, pen={'color': color, 'width': 3}, antialias=True, name=name)
    upper_curve = plots[0].plot(ci_xvals, upper, pen=(0, 0, 0, 0), antialias=True)
    lower_curve = plots[0].plot(ci_xvals, lower, pen=(0, 0, 0, 0), antialias=True)
    upper_curve.setVisible(False)
    lower_curve.setVisible(False)
    color2 = color + (fill_alpha,)
    fill = pg.FillBetweenItem(upper_curve, lower_curve, brush=color2)
    fill.setZValue(-10)
    plots[0].addItem(fill, ignoreBounds=True)
    
    return plots, ci_xvals, prop, upper, lower
Beispiel #16
0
	def	__init__(self,map='map'):
		prefileMeas = sorted([x for x in [y for y in os.listdir("./")] if re.search("axion.m.[0-9]{5}$", x)])
		fileMeas = []
		for maes in prefileMeas:
			try:
				with h5py.File(maes, 'r') as f:
					if (map in f) :
						fileMeas.append(maes)
			except:
				print('Error opening file: %s'%maes)

		fileHdf5 = h5py.File(fileMeas[0], "r")

		self.Lx = fileHdf5["/"].attrs.get("Size")
		self.Ly = fileHdf5["/"].attrs.get("Size")
		self.Lz = fileHdf5["/"].attrs.get("Depth")

		self.z = fileHdf5["/"].attrs.get("z")
		self.R = self.z

		fileHdf5.close()

		self.allData = []

		self.step  = 1
		self.tStep = 100
		self.pause = False

		self.timer = pg.QtCore.QTimer()

		# Read all data

		self.i = 0
		self.size = 0

#		if os.path.exists("./Strings.PyDat"):
#			fp = gzip.open("./Strings.PyDat", "rb")
#			self.allData = pickle.load(fp)
#			fp.close()
#			self.size = len(self.allData)
#		else:
		for meas in fileMeas:
#			print(meas)
			fileHdf5 = h5py.File(meas, "r")

			Lx = fileHdf5["/"].attrs.get("Size")
			Ly = fileHdf5["/"].attrs.get("Size")
			Lz = fileHdf5["/"].attrs.get("Depth")
			zR = fileHdf5["/"].attrs.get("z")
			R  = zR
			if 'R' in fileHdf5:
				R = fileHdf5["/"].attrs.get("R")

			fl = fileHdf5["/"].attrs.get("Field type").decode()

			if self.Lx != Lx or self.Ly != Ly or self.Lz != Lz:
				print("Error: Size mismatch (%d %d %d) vs (%d %d %d)\nAre you mixing files?\n" % (Lx, Ly, Lz, self.Lx, self.Ly, self.Lz))
				exit()

			if fl == "Saxion":
				mTmp  = fileHdf5[map]['m'].value.reshape(Ly,Lx,2)
				rData = np.sqrt(mTmp[:,:,0]**2 + mTmp[:,:,1]**2)
				rMax = np.amax(rData)
				rData = rData/R
				aData = (np.arctan2(mTmp[:,:,1], mTmp[:,:,0]) + 2*np.pi)/(4.*np.pi)
			elif fl == "Axion":
				aData = fileHdf5[map]['m'].value.reshape(Ly,Lx)
#				pm = np.amax(aData)
#				print ("BMax %f" % pm)
				aData = aData/R
				rData = np.ones(aData.shape)
				pData = np.ones(aData.shape)*(2*np.pi)
				aData = (aData + pData)/(4.*np.pi)
#				iData = np.trunc(aData/(2*np.pi))
#				aData = aData - iData*(2*np.pi)
#				aData = aData - pData
#				pm = np.amax(aData)
#				print ("AMax %f" % pm)
				rMax  = R
			else:
				print("Unrecognized field type %s" % fl)
				exit()

			self.allData.append([rData, aData, zR, rMax])
			fileHdf5.close()

			self.size = self.size + 1

#			fp = gzip.open("Strings.PyDat", "wb")
#			pickle.dump(self.allData, fp, protocol=2)
#			fp.close()


		self.app  = QtGui.QApplication([])
		self.pWin = pg.GraphicsLayoutWidget()
		self.pWin.setWindowTitle('Axion / Saxion evolution')
		self.pWin.resize(1600,1600)
		pg.setConfigOptions(antialias=True)

		self.aPlot = self.pWin.addPlot(row=0, col=0)
		self.sPlot = self.pWin.addPlot(row=0, col=1)

		self.aPlot.setXRange(0,Lx*1.2)
		self.aPlot.setYRange(0,Lx*1.2)
		self.sPlot.setXRange(0,Lx*1.2)
		self.sPlot.setYRange(0,Lx*1.2)

		self.zAtxt = pg.TextItem("z=0.000000")
		self.zStxt = pg.TextItem("z=0.000000")

		data = self.allData[0]

		aPos = np.array([0.00, 0.10, 0.25, 0.4, 0.5, 0.6, 0.75, 0.9, 1.0 ])
		aCol = ['#006600', 'b', 'w', 'r', 'k', 'b', 'w', 'r', '#006600']

		vb = self.aPlot.getViewBox()

		aSzeX = vb.size().width()*0.96
		aSzeY = vb.size().height()*0.8

		self.aMap  = pg.ColorMap(aPos, np.array([pg.colorTuple(pg.Color(c)) for c in aCol]))
		self.aLut  = self.aMap.getLookupTable()
		self.aLeg  = pg.GradientLegend((aSzeX/20, aSzeY), (aSzeX, aSzeY/12.))
		self.aLeg.setLabels({ "-pi": 0.0, "-pi/2": 0.25, "0.0": 0.50, "+pi/2": 0.75, "+pi": 1.00 })
		self.aLeg.setParentItem(self.aPlot)
		self.aLeg.gradient.setColorAt(0.00, QtGui.QColor(255,255,255))
		self.aLeg.gradient.setColorAt(0.25, QtGui.QColor(255,  0,  0))
		self.aLeg.gradient.setColorAt(0.50, QtGui.QColor(  0,  0,  0))
		self.aLeg.gradient.setColorAt(0.75, QtGui.QColor(  0,  0,255))
		self.aLeg.gradient.setColorAt(1.00, QtGui.QColor(255,255,255))

		self.aImg = pg.ImageItem(lut=self.aLut)
		self.aPlot.addItem(self.aImg)
		self.aPlot.addItem(self.zAtxt)

#		sPos = np.linspace(0.0, data[3], 5)
		sPos = np.array([0.00, 0.25, 0.50, 0.75, 1.00])
		sLab = ["%.2f" % mod for mod in sPos]
		sCol = ['w', 'r', 'y', 'c', 'k']

		vs = self.sPlot.getViewBox()

		sSzeX = vs.size().width()*0.96
		sSzeY = vs.size().height()*0.8

		self.sMap  = pg.ColorMap(sPos, np.array([pg.colorTuple(pg.Color(c)) for c in sCol]))
		self.s**t  = self.sMap.getLookupTable()
		self.sLeg  = pg.GradientLegend((sSzeX/20, sSzeY), (aSzeX/0.96 + sSzeX, sSzeY/12.))
		self.sLeg.setLabels({ sLab[0]: 0.0, sLab[1]: 0.25, sLab[2]: 0.50, sLab[3]: 0.75, sLab[4]: 1.00 })
		self.sLeg.setParentItem(self.sPlot)
		self.sLeg.gradient.setColorAt(0.00, QtGui.QColor(255,255,255))
		self.sLeg.gradient.setColorAt(0.25, QtGui.QColor(255,  0,  0))
		self.sLeg.gradient.setColorAt(0.50, QtGui.QColor(255,255,  0))
		self.sLeg.gradient.setColorAt(0.75, QtGui.QColor(  0,255,255))
		self.sLeg.gradient.setColorAt(1.00, QtGui.QColor(  0,  0,  0))

		self.sImg = pg.ImageItem(lut=self.s**t)
		self.sPlot.addItem(self.sImg)
		self.sPlot.addItem(self.zStxt)


		self.sImg.setImage(data[0], levels=(0.,1.))
		self.aImg.setImage(data[1], levels=(0.,1.))

		self.pWin.show()


		self.baseKeyPress = self.pWin.keyPressEvent
    def __init__(self, model_runner):
        QtGui.QWidget.__init__(self)
        self.layout = QtGui.QGridLayout()
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.setLayout(self.layout)
        self.splitter = QtGui.QSplitter(QtCore.Qt.Vertical)
        self.layout.addWidget(self.splitter)

        self.slicer = NDSlicer(model_runner.param_space.axes())
        self.slicer.selection_changed.connect(self.selection_changed)
        self.splitter.addWidget(self.slicer)

        self.result_widget = ModelSingleResultWidget()
        self.splitter.addWidget(self.result_widget)

        # set up a few default 2D slicer views
        v1 = self.slicer.params.child('2D views').addNew()
        v1['axis 0'] = 'n_release_sites'
        v1['axis 1'] = 'base_release_probability'
        v2 = self.slicer.params.child('2D views').addNew()
        v2['axis 0'] = 'vesicle_recovery_tau'
        v2['axis 1'] = 'facilitation_recovery_tau'
        self.slicer.dockarea.moveDock(v2.viewer.dock, 'bottom', v1.viewer.dock)
        v3 = self.slicer.params.child('2D views').addNew()
        v3['axis 0'] = 'vesicle_recovery_tau'
        v3['axis 1'] = 'base_release_probability'
        v4 = self.slicer.params.child('2D views').addNew()
        v4['axis 0'] = 'facilitation_amount'
        v4['axis 1'] = 'facilitation_recovery_tau'
        self.slicer.dockarea.moveDock(v4.viewer.dock, 'bottom', v3.viewer.dock)

        # turn on max projection for all parameters by default
        for ch in self.slicer.params.child('max project'):
            if ch.name() == 'synapse':
                continue
            ch.setValue(True)

        self.model_runner = model_runner
        self.param_space = model_runner.param_space

        result_img = np.zeros(self.param_space.result.shape)
        for ind in np.ndindex(result_img.shape):
            result_img[ind] = self.param_space.result[ind]['likelihood']
        self.slicer.set_data(result_img)
        self.results = result_img

        # select best result
        best = np.unravel_index(np.argmax(result_img), result_img.shape)
        self.select_result(best)

        max_like = self.results.max()

        # if results are combined across synapses, set up colors
        if 'synapse' in self.param_space.params:
            self.slicer.params['color axis', 'axis'] = 'synapse'
            syn_axis = list(self.param_space.params.keys()).index('synapse')
            max_img = np.array([
                result_img.take(i, axis=syn_axis).max()
                for i in range(result_img.shape[syn_axis])
            ])
            max_like = max_img.min()
            max_img = max_img.min() / max_img
            syns = self.param_space.params['synapse']
            for i in syns:
                c = pg.colorTuple(pg.intColor(i, len(syns) * 1.2))
                c = pg.mkColor(c[0] * max_img[i], c[1] * max_img[i],
                               c[2] * max_img[i])
                self.slicer.params['color axis', 'colors', str(i)] = c

        # set histogram range
        self.slicer.histlut.setLevels(max_like * 0.85, max_like)
Beispiel #18
0
def distance_plot(connected,
                  distance,
                  plots=None,
                  color=(100, 100, 255),
                  size=10,
                  window=40e-6,
                  name=None,
                  fill_alpha=30):
    """Draw connectivity vs distance profiles with confidence intervals.
    
    Parameters
    ----------
    connected : boolean array
        Whether a synaptic connection was found for each probe
    distance : array
        Distance between cells for each probe
    plots : list of PlotWidget | PlotItem
        (optional) Two plots used to display distance profile and scatter plot.
    color : tuple
        (R, G, B) color values for line and confidence interval. The confidence interval
        will be drawn with reduced opacity (see *fill_alpha*)
    size: int
        size of scatter plot symbol
    window : float
        Width of distance window over which proportions are calculated for each point on
        the profile line.
    fill_alpha : int
        Opacity of confidence interval fill (0-255)

    Note: using a spacing value that is smaller than the window size may cause an
    otherwise smooth decrease over distance to instead look more like a series of downward steps.
    """
    color = pg.colorTuple(pg.mkColor(color))[:3]
    connected = np.array(connected).astype(float)
    distance = np.array(distance)

    # scatter plot connections probed
    if plots is None:
        grid = PlotGrid()
        grid.set_shape(2, 1)
        grid.grid.ci.layout.setRowStretchFactor(0, 5)
        grid.grid.ci.layout.setRowStretchFactor(1, 10)
        plots = (grid[1, 0], grid[0, 0])
        plots[0].grid = grid
        plots[0].addLegend()
        grid.show()
        plots[0].setLabels(bottom=('distance', 'm'),
                           left='connection probability')

    if plots[1] is not None:
        # scatter points a bit
        pts = np.vstack([distance, connected]).T
        conn = pts[:, 1] == 1
        unconn = pts[:, 1] == 0
        if np.any(conn):
            cscat = pg.pseudoScatter(pts[:, 0][conn],
                                     spacing=10e-6,
                                     bidir=False)
            mx = abs(cscat).max()
            if mx != 0:
                cscat = cscat * 0.2  # / mx
            pts[:, 1][conn] = -5e-5 - cscat
        if np.any(unconn):
            uscat = pg.pseudoScatter(pts[:, 0][unconn],
                                     spacing=10e-6,
                                     bidir=False)
            mx = abs(uscat).max()
            if mx != 0:
                uscat = uscat * 0.2  # / mx
            pts[:, 1][unconn] = uscat

        plots[1].setXLink(plots[0])
        plots[1].hideAxis('bottom')
        plots[1].hideAxis('left')

        color2 = color + (100, )
        scatter = plots[1].plot(pts[:, 0],
                                pts[:, 1],
                                pen=None,
                                symbol='o',
                                labels={'bottom': ('distance', 'm')},
                                size=size,
                                symbolBrush=color2,
                                symbolPen=None,
                                name=name)
        scatter.scatter.opts[
            'compositionMode'] = pg.QtGui.QPainter.CompositionMode_Plus

    # use a sliding window to plot the proportion of connections found along with a 95% confidence interval
    # for connection probability
    bin_edges = np.arange(0, 500e-6, window)
    xvals, prop, lower, upper = connectivity_profile(connected, distance,
                                                     bin_edges)

    # plot connection probability and confidence intervals
    color2 = [c / 3.0 for c in color]
    xvals = (xvals[:-1] + xvals[1:]) * 0.5
    mid_curve = plots[0].plot(xvals,
                              prop,
                              pen={
                                  'color': color,
                                  'width': 3
                              },
                              antialias=True,
                              name=name)
    upper_curve = plots[0].plot(xvals, upper, pen=(0, 0, 0, 0), antialias=True)
    lower_curve = plots[0].plot(xvals, lower, pen=(0, 0, 0, 0), antialias=True)
    upper_curve.setVisible(False)
    lower_curve.setVisible(False)
    color2 = color + (fill_alpha, )
    fill = pg.FillBetweenItem(upper_curve, lower_curve, brush=color2)
    fill.setZValue(-10)
    plots[0].addItem(fill, ignoreBounds=True)

    return plots, xvals, prop, upper, lower
def distance_plot(connected,
                  distance,
                  plots=None,
                  color=(100, 100, 255),
                  window=40e-6,
                  spacing=None,
                  name=None,
                  fill_alpha=30):
    """Draw connectivity vs distance profiles with confidence intervals.
    
    Parameters
    ----------
    connected : boolean array
        Whether a synaptic connection was found for each probe
    distance : array
        Distance between cells for each probe
    plots : list of PlotWidget | PlotItem
        (optional) Two plots used to display distance profile and scatter plot.
    color : tuple
        (R, G, B) color values for line and confidence interval. The confidence interval
        will be drawn with alpha=100
    window : float
        Width of distance window over which proportions are calculated for each point on
        the profile line.
    spacing : float
        Distance spacing between points on the profile line


    Note: using a spacing value that is smaller than the window size may cause an
    otherwise smooth decrease over distance to instead look more like a series of downward steps.
    """
    color = pg.colorTuple(pg.mkColor(color))[:3]
    connected = np.array(connected).astype(float)
    distance = np.array(distance)
    pts = np.vstack([distance, connected]).T

    # scatter points a bit
    conn = pts[:, 1] == 1
    unconn = pts[:, 1] == 0
    if np.any(conn):
        cscat = pg.pseudoScatter(pts[:, 0][conn], spacing=10e-6, bidir=False)
        mx = abs(cscat).max()
        if mx != 0:
            cscat = cscat * 0.2  # / mx
        pts[:, 1][conn] = -2e-5 - cscat
    if np.any(unconn):
        uscat = pg.pseudoScatter(pts[:, 0][unconn], spacing=10e-6, bidir=False)
        mx = abs(uscat).max()
        if mx != 0:
            uscat = uscat * 0.2  # / mx
        pts[:, 1][unconn] = uscat

    # scatter plot connections probed
    if plots is None:
        grid = PlotGrid()
        grid.set_shape(2, 1)
        grid.grid.ci.layout.setRowStretchFactor(0, 5)
        grid.grid.ci.layout.setRowStretchFactor(1, 10)
        plots = (grid[1, 0], grid[0, 0])
        plots[0].grid = grid
        plots[0].addLegend()
        grid.show()
    plots[0].setLabels(bottom=('distance', 'm'), left='connection probability')

    if plots[1] is not None:
        plots[1].setXLink(plots[0])
        plots[1].hideAxis('bottom')
        plots[1].hideAxis('left')

        color2 = color + (100, )
        scatter = plots[1].plot(pts[:, 0],
                                pts[:, 1],
                                pen=None,
                                symbol='o',
                                labels={'bottom': ('distance', 'm')},
                                symbolBrush=color2,
                                symbolPen=None,
                                name=name)
        scatter.scatter.opts[
            'compositionMode'] = pg.QtGui.QPainter.CompositionMode_Plus

    # use a sliding window to plot the proportion of connections found along with a 95% confidence interval
    # for connection probability

    if spacing is None:
        spacing = window / 4.0

    xvals = np.arange(window / 2.0, 500e-6, spacing)
    upper = []
    lower = []
    prop = []
    ci_xvals = []
    for x in xvals:
        minx = x - window / 2.0
        maxx = x + window / 2.0
        # select points inside this window
        mask = (distance >= minx) & (distance <= maxx)
        pts_in_window = connected[mask]
        # compute stats for window
        n_probed = pts_in_window.shape[0]
        n_conn = pts_in_window.sum()
        if n_probed == 0:
            prop.append(np.nan)
        else:
            prop.append(n_conn / n_probed)
            ci = binomial_ci(n_conn, n_probed)
            lower.append(ci[0])
            upper.append(ci[1])
            ci_xvals.append(x)

    # plot connection probability and confidence intervals
    color2 = [c / 3.0 for c in color]
    mid_curve = plots[0].plot(xvals,
                              prop,
                              pen={
                                  'color': color,
                                  'width': 3
                              },
                              antialias=True,
                              name=name)
    upper_curve = plots[0].plot(ci_xvals,
                                upper,
                                pen=(0, 0, 0, 0),
                                antialias=True)
    lower_curve = plots[0].plot(ci_xvals,
                                lower,
                                pen=(0, 0, 0, 0),
                                antialias=True)
    upper_curve.setVisible(False)
    lower_curve.setVisible(False)
    color2 = color + (fill_alpha, )
    fill = pg.FillBetweenItem(upper_curve, lower_curve, brush=color2)
    fill.setZValue(-10)
    plots[0].addItem(fill, ignoreBounds=True)

    return plots
    def matrix(self, rows, cols, size=50, header_color='k', no_data_color=0.9, mode='connectivity', title='Connectivity Matrix'):
        w = pg.GraphicsLayoutWidget()
        w.setRenderHints(w.renderHints() | pg.QtGui.QPainter.Antialiasing)
        w.setWindowTitle(title)
        v = w.addViewBox()
        v.setBackgroundColor('w')
        v.setAspectLocked()
        v.invertY()

        if mode == 'connectivity':
            colormap = pg.ColorMap(
                [0, 0.01, 0.03, 0.1, 0.3, 1.0],
                [(0,0,100), (80,0,80), (140,0,0), (255,100,0), (255,255,100), (255,255,255)],
            )
        else:
            colormap = pg.ColorMap(
                [0, 0.25, 0.5, 0.75, 1.0],
                [(0,0,100), (80,0,80), (140,0,0), (255,100,0), (255,255,100)],
            )
        default = no_data_color

        conn_matrix = self.connectivity_matrix(rows, cols)

        shape = (len(rows), len(cols))
        text = np.empty(shape, dtype=object)
        fgcolor = np.empty(shape, dtype=object)
        bgcolor = np.empty(shape, dtype=object)
        bordercolor = np.empty(shape, dtype=object)

        for i,row in enumerate(rows):
            for j,col in enumerate(cols):
                conn, probed = conn_matrix[i, j]

                if probed == 0:
                    color = default
                else:
                    if mode == 'connectivity':
                        color = default if probed == 0 else colormap.map(conn/probed)
                        color = pg.colorTuple(pg.mkColor(color))
                        bgcolor[i, j] = color
                    elif mode == 'progress':
                        prg = max(probed/80., conn/10.)
                        color = pg.colorTuple(pg.mkColor(colormap.map(prg)))

                bordercolor[i, j] = 0.8 if probed == 0 else 'k'
                bgcolor[i, j] = color
                fgcolor[i, j] = 0.6 if probed == 0 else ('w' if sum(color[:3]) < 200 else 'k')
                text[i, j] = "%d/%d" % (conn, probed) if probed > 0 else ''


        w.matrix = MatrixItem(text=text, fgcolor=fgcolor, bgcolor=bgcolor, border_color=bordercolor,
                              rows=rows.values(), cols=cols.values(), size=size,
                              header_color=header_color)
        v.addItem(w.matrix)

        # colormap is logarithmic; remap to linear for legend
        colors = colormap.color
        x = np.linspace(0, 1, len(colors))
        cmap2 = pg.ColorMap(x, colors)
        legend = pg.GradientLegend([25, 300], [-20, -30])
        legend.setGradient(cmap2.getGradient())
        legend.setLabels({'%d'%int(a*100):b for a,b in zip(colormap.pos, x)})
        v.addItem(legend)
        w.show()
        self.matrix_widget = w

        return w
Beispiel #21
0
 def saveColorState(self):
     state = Parameter.saveState(self)
     state['value'] = pg.colorTuple(self.value())
     return state
Beispiel #22
0
 def contrasting_text_color(self, color):
     # (r, g, b) = (hex_str[:2], hex_str[2:4], hex_str[4:])
     r, g, b, a = pg.colorTuple(pg.mkColor(color))
     return pg.mkBrush(
         '000' if 1 -
         (r * 0.299 + g * 0.587 + b * 0.114) / 255 < 0.5 else 'fff')