Esempio n. 1
0
def get_font_array(sz, chars=DEFAULT_CHARS):
    from guidata.qt.QtGui import QFont, QPainter, QColor
    font = QFont()
    font.setFixedPitch(True)
    font.setPixelSize(sz)
    font.setStyleStrategy(QFont.NoAntialias)
    dummy = QImage(10, 10, QImage.Format_ARGB32)
    pnt = QPainter(dummy)
    pnt.setFont(font)
    metric = pnt.fontMetrics()
    rct = metric.boundingRect(chars)
    pnt.end()
    h = rct.height()
    w = rct.width()
    img = QImage(w, h, QImage.Format_ARGB32)
    paint = QPainter()
    paint.begin(img)
    paint.setFont(font)
    paint.setBrush( QColor(255, 255, 255) )
    paint.setPen( QColor(255, 255, 255) )
    paint.drawRect(0, 0, w+1, h+1)
    paint.setPen( QColor(0, 0, 0))
    paint.setBrush( QColor(0, 0, 0) )
    paint.drawText(0, paint.fontMetrics().ascent(), chars)
    paint.end()
    try:
        data = img.bits().asstring(img.numBytes())
    except SystemError:
        # Python 3
        return
    npy = np.frombuffer(data, np.uint8)
    npy.shape = img.height(), img.bytesPerLine()/4, 4
    return npy[:,:, 0]
Esempio n. 2
0
    def __init__(self, parent, ytitle="Y", inity=1000):
        # self.curve_vlf = make.curve( [ ], [ ], '(Curve Name)', QColor( 255, 0, 0 ), shade=0.5 )
        # self.curve_lf = make.curve( [ ], [ ], '(Curve Name)', QColor( 0, 255, 0 ), shade=0.5 )
        # self.curve_hf = make.curve( [ ], [ ], '(Curve Name)', QColor( 0, 0, 255 ), shade=0.5 )
        self.psdcurve = make.curve( [ ], [ ], '(Curve Name)', QColor( 160, 160, 160 ), shade=0.2 )

        def buildrect(x1, x2, filler):
            rect = RectangleShape(x1, 0., x2, inity)
            rect.brush.setStyle( Qt.SolidPattern )
            rect.brush.setColor( filler )
            rect.pen.setStyle( Qt.NoPen )
            return rect

        self.dockwidget    = myDockableWidget(parent, CurveWidget, toolbar=True )
        # self.plot = self.curvewidget.get_plot()
        self.plot = self.dockwidget.widget.plot
        # self.plot.add_item( self.curve_vlf )
        # self.plot.add_item( self.curve_lf )
        # self.plot.add_item( self.curve_hf )
        alpha = 100
        self.plot.add_item( buildrect(0.,0.04, QColor(255,178,178,alpha)) )
        self.plot.add_item( buildrect(0.04,0.15, QColor(178,178,255,alpha)) )
        self.plot.add_item( buildrect(0.15,0.5, QColor(255,255,178,alpha)) )
        self.plot.add_item( self.psdcurve )

        self.plot.set_antialiasing( True )
        self.plot.set_axis_title( QwtPlot.xBottom, 'Frequency' )
        self.plot.set_axis_unit( QwtPlot.xBottom, 'Hz' )
        self.plot.set_axis_title( QwtPlot.yLeft, ytitle )
        self.plot.set_axis_unit( QwtPlot.yLeft, 's^2/Hz' )

        #self.plot.setAxisScale(QwtPlot.xBottom, 0, 0.5)
        self.plot.set_axis_limits( QwtPlot.xBottom, 0, 0.5 )
Esempio n. 3
0
 def set_axis_color(self, axis_id, color):
     """
     Set axis color
     color: color name (string) or QColor instance
     """
     axis_id = self.get_axis_id(axis_id)
     if is_text_string(color):
         color = QColor(color)
     self.axes_styles[axis_id].color = str(color.name())
     self.update_axis_style(axis_id)
Esempio n. 4
0
 def set_axis_color(self, axis_id, color):
     """
     Set axis color
     color: color name (string) or QColor instance
     """
     axis_id = self.get_axis_id(axis_id)
     if is_text_string(color):
         color = QColor(color)
     self.axes_styles[axis_id].color = str(color.name())
     self.update_axis_style(axis_id)
Esempio n. 5
0
    def logmessage( self, text, msgtype='info' ):
        """ Print a message in the message window
        """
        if msgtype == 'error':
            self.logarea.widget.setTextColor( QColor( 255, 0, 0 ) )
        else:
            self.logarea.widget.setTextColor( QColor( 0, 0, 0 ) )

        self.logarea.widget.insertPlainText( text + "\n" )
        sb = self.logarea.widget.verticalScrollBar()
        sb.setValue( sb.maximum() )
Esempio n. 6
0
def text_to_qcolor(text):
    """Create a QColor from specified string"""
    color = QColor()
    if not is_text_string(text): # testing for QString (PyQt API#1)
        text = str(text)
    if text.startswith('#') and len(text)==7:
        correct = '#0123456789abcdef'
        for char in text:
            if char.lower() not in correct:
                return color
    elif text not in list(QColor.colorNames()):
        return color
    color.setNamedColor(text)
    return color
Esempio n. 7
0
def text_to_qcolor(text):
    """Create a QColor from specified string"""
    color = QColor()
    if not is_text_string(text):  # testing for QString (PyQt API#1)
        text = str(text)
    if text.startswith('#') and len(text) == 7:
        correct = '#0123456789abcdef'
        for char in text:
            if char.lower() not in correct:
                return color
    elif text not in list(QColor.colorNames()):
        return color
    color.setNamedColor(text)
    return color
Esempio n. 8
0
def get_brush(conf, section, option="", color="black", alpha=1.0):
    """
    Construct a QBrush from the specified configuration file entry
    conf: UserConfig instance
    section [, option]: configuration entry
    [color]: default color
    [alpha]: default alpha-channel
    """
    if 'brush' not in option:
        option += '/brush'
    color = conf.get(section, option+"/color", color)
    color = QColor(color)
    alpha = conf.get(section, option+"/alphaF", alpha)
    color.setAlphaF(alpha)
    return QBrush(color)
Esempio n. 9
0
    def __init__(self):
        QMainWindow.__init__(self)
        self.setWindowIcon(get_icon(os.path.join(APP_RESOURCES, 'icons',
                                                  'python.png')))
        self.setupUi(self)
        
        # Redirect output to GUI's QTextEdit
        sys.stdout = OutLog(self.outputTextEdit, sys.stdout)
        sys.stderr = OutLog(self.outputTextEdit, sys.stderr, QColor(255,0,0) )
        
        settings = QSettings()
        size = settings.value("MainWindow/Size",
                              QVariant(QSize(600, 500))).toSize()
        self.resize(size)
        position = settings.value("MainWindow/Position",
                                  QVariant(QPoint(0, 0))).toPoint()
        self.move(position)
        self.restoreState(
        settings.value("MainWindow/State").toByteArray())
    
        self.logger = Logger('Zupport.GUIloader')
        self.logger.debugging = settings.value("Logging/debugging").toBool()
         
        # Set up a ZupportManager to deal with the plugins
        self.manager = Manager(self)
        self.plugins = {}

        # Set up the extents menu
        self.extent = ExtentContainer()
        self.menuExtent = QMenu("Extent")
        resolutions = self.extent.resolutions
        self.extenactiongroup = QActionGroup(self.menuExtent)  
        noneaction = QAction("None", self.menuExtent)
        self.extenactiongroup.addAction(noneaction)
        self.menuExtent.addAction(noneaction)
        for resolution in resolutions:
            resolution_text = str(resolution)
            submenu = self.menuExtent.addMenu(resolution_text) 
            self.menuExtent.addMenu(submenu)
            for area in self.extent.get_names(resolution):
                subaction = QAction(str(area) + ": %s" % resolution_text, 
                                    submenu)
                subaction.setCheckable(True)
                self.extenactiongroup.addAction(subaction)
                submenu.addAction(subaction)
        
        noneaction.isChecked()
        self.menuSettings.addMenu(self.menuExtent)
        
        self.actionDebugging_messages.setChecked(self.logger.debugging)

        self.setWindowTitle("Zupport GUI")
        
        self.load_tools()
        
        self.toolTreeWidget.itemSelectionChanged.connect(self.update_ui)
        self.actionDebugging_messages.toggled.connect(self._set_debugging)
        self.menuExtent.triggered.connect(self.update_ui)
        self.actionLoad_tool.triggered.connect(self.show_tool_gui)
        self.toolTreeWidget.doubleClicked.connect(self.show_tool_gui)
Esempio n. 10
0
    def _setup_layout(self):
        # Allow dockable widgets to be side by side
        self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks)
        self.setGeometry(300,100,1500,900)

        self.rrplot         = RealTimePlot( self, 'RR-Interval', 'ms', QColor( 255, 0, 0 ) )
        self.bwplot         = RealTimePlot( self, 'Breathing','', QColor( 0, 0, 255 ) )
        self.ecgplot        = RealTimePlot( self, 'ECG Waveform','', QColor( 0, 0, 255 ) )
        self.logarea        = myDockableWidget(self, QTextEdit)
        self.bwpsd          = RealTimePSD( self, 'Breathing PSD', inity=25000 )
        self.rrpsd          = RealTimePSD( self, 'RR-Interval PSD')

        self.logarea.widget.setReadOnly( True )
        self.logarea.widget.setFont( QFont("Courier", 8) )
        self.logarea.widget.setMinimumHeight(150)

        # Add the DockWidget to the main window
        self.ecgplot_dock = self.add_dockwidget( self.ecgplot.dockwidget, _("ECG Waveform") )
        self.rrcurve_dock = self.add_dockwidget( self.rrplot.dockwidget, _("RR-Intervals Plot") )
        self.rrpsd_dock = self.add_dockwidget( self.rrpsd.dockwidget, _("RRI PSD"))
        self.bwcurve_dock = self.add_dockwidget( self.bwplot.dockwidget, _("Breathing Plot") )
        self.bwpsd_dock = self.add_dockwidget( self.bwpsd.dockwidget, _("Breathing PSD (not implemented)") )
        self.splitDockWidget(self.rrcurve_dock, self.rrpsd_dock, Qt.Horizontal)
        self.splitDockWidget(self.bwcurve_dock, self.bwpsd_dock, Qt.Horizontal)
        self.log_dock = self.add_dockwidget( self.logarea, _("Messages"),  position=Qt.BottomDockWidgetArea)

        #self.splitDockWidget(self.rrcurve_dock, self.ecgplot_dock, Qt.Horizontal)

        # setting the name of the dock widget is required to save correclty
        # the postion of the widget when the application close
        self.rrcurve_dock.setObjectName('rrcurve_dock')
        self.rrpsd_dock.setObjectName('rrpsd_dock')
        self.bwcurve_dock.setObjectName('bwcurve_dock')
        self.bwpsd_dock.setObjectName('bwpsd_dock')
        self.log_dock.setObjectName('log_dock')
        self.ecgplot_dock.setObjectName('ecgplot_dock')

        #self.log_dock.setMinimumHeight( 20 )


        self.rrcurve_dock.setMinimumSize( 400, 200 )
        self.bwcurve_dock.setMinimumSize( 400, 200 )
        self.rrpsd_dock.setMinimumSize( 400, 200 )
        self.bwpsd_dock.setMinimumSize( 400, 200 )
        self.log_dock.setMinimumSize( 400, 100 )
        self.log_dock.setMaximumHeight( 250 )
Esempio n. 11
0
    def __init__(self, parent):
        tabs = parent.sp
        r = range(len(tabs))

        # Prepare unique names in ugly manner
        self.names = [n.spec.name
                      for n in tabs] if tabs[0].spec is not None else ['']
        test = []
        for n in r:
            if self.names.count(self.names[n]) > 1 or self.names[n] in test:
                test.append(self.names[n])
                self.names[n] += ' {}'.format(test.count(self.names[n]))

        plots = [[
            {
                'name': 'Calibrated',
                'curves': ['Calibrated ' + self.names[n] for n in r]
            },
            {
                'name': 'Integrated',
                'curves': ['Integrated ' + self.names[n] for n in r]
            },
            {
                'name': 'System noise',
                'curves': ['Noise ' + self.names[n] for n in r]
            },
        ]]

        df = [n.axisLimits[1] - n.axisLimits[0] for n in tabs]
        df2 = max(df) / 2

        axisLimits = [
            -df2, df2,
            min([n.axisLimits[2] for n in tabs]),
            max([n.axisLimits[3] for n in tabs])
        ]

        PlotPanel.__init__(self,
                           parent=parent,
                           plots=plots,
                           axisLimits=axisLimits)
        self.tabs = tabs
        cmap = get_cmap('tab10', len(tabs))
        self.colors = [
            QPen(QColor(x[0] * 255, x[1] * 255, x[2] * 255), 1)
            for x in cmap.colors
        ]

        cPanel = self.curves['Calibrated ' + self.names[0]].parent
        cPanel.add_item(make.legend("BL"))
        cPanel.setActive()
        cPanel = self.curves['Integrated ' + self.names[0]].parent
        cPanel.add_item(make.legend("BL"))
        cPanel.setActive()
        cPanel = self.curves['Noise ' + self.names[0]].parent
        cPanel.add_item(make.legend("BL"))
        cPanel.setActive()
Esempio n. 12
0
 def get(self):
     """Override AbstractDataSetWidget method"""
     value = self.item.get()
     if value is not None:
         color = QColor(value)
         self.picture = QPicture()
         painter = QPainter()
         painter.begin(self.picture)
         painter.fillRect(QRect(0, 0, 60, 20), QBrush(color))
         painter.end()
         self.group.setPicture(self.picture)
Esempio n. 13
0
 def draw(self, painter, xMap, yMap, canvasRect):
     self.update_text()
     x, y = self.get_top_left(xMap, yMap, canvasRect)
     x0, y0 = self.get_origin(xMap, yMap, canvasRect)
     painter.save()
     self.marker.drawSymbols(painter, [QPointF(x0, y0)])
     painter.restore()
     sz = self.text.size()
     self.draw_frame(painter, x, y, sz.width(), sz.height())
     painter.setPen(QPen(QColor(self.labelparam.color)))
     painter.translate(x, y)
     self.text.drawContents(painter)
Esempio n. 14
0
def _setup_colormap(cmap, cmdata):
    """Setup a QwtLinearColorMap according to
    matplotlib's data
    """
    red = array(cmdata["red"])
    green = array(cmdata["green"])
    blue = array(cmdata["blue"])
    qmin = QColor()
    qmin.setRgbF(red[ 0, 2], green[ 0, 2], blue[ 0, 2])
    qmax = QColor()
    qmax.setRgbF(red[-1, 2], green[-1, 2], blue[-1, 2])
    cmap.setColorInterval( qmin, qmax )
    indices = sorted(set(red[:, 0]) | set(green[:, 0]) | set(blue[:, 0]))
    for i in indices[1:-1]:
        idxr = red[:, 0].searchsorted(i)
        idxg = green[:, 0].searchsorted(i)
        idxb = blue[:, 0].searchsorted(i)
        compr = _interpolate(i, red[idxr-1], red[idxr])
        compg = _interpolate(i, green[idxg-1], green[idxg])
        compb = _interpolate(i, blue[idxb-1], blue[idxb] )
        col = QColor()
        col.setRgbF(compr, compg, compb)
        cmap.addColorStop(i, col)
Esempio n. 15
0
def get_pen(conf, section, option="",
            color="black", width=1, style='SolidLine'):
    """
    Construct a QPen from the specified configuration file entry
    conf: UserConfig instance
    section [, option]: configuration entry
    [color]: default color
    [width]: default width
    [style]: default style
    """
    if 'pen' not in option:
        option += '/pen'
    color = conf.get(section, option+"/color", color)
    color = QColor(color)
    width = conf.get(section, option+"/width", width)
    style_name = conf.get(section, option+"/style", style)
    style = getattr(Qt, style_name)
    return QPen(color, width, style)
Esempio n. 16
0
 def __init__(self, parent, ytitle="Y", yunit='', color=QColor( 255, 0, 0 )):
     self.curve = make.curve( [ ], [ ], '(Curve Name)', color )
     self.dockwidget    = myDockableWidget(parent, CurveWidget, toolbar=True )
     # widget class: CurveWidget
     # plot class: CurvePlot
     # curve class: CurveItem
     self.plot = self.dockwidget.widget.plot
     self.plot.add_item( self.curve )
     self.plot.set_antialiasing( True )
     self.plot.set_axis_title( QwtPlot.xBottom, 'Time' )
     self.plot.set_axis_unit( QwtPlot.xBottom, 's' )
     self.plot.set_axis_title( QwtPlot.yLeft, ytitle )
     self.plot.set_axis_unit( QwtPlot.yLeft, yunit )
     self.plot.setAxisScaleDraw( QwtPlot.xBottom, DateTimeScaleDraw() )
     #self.toolbar = QToolBar(_("Tools"))
     #self.curvewidget.widget.add_toolbar(self.toolbar, "default")
     #self.curvewidget.widget.register_tools()
     self.startIdx = 0
     self.window_length = 60 # seconds
Esempio n. 17
0
    def update_axis_style(self, axis_id):
        """Update axis style"""
        axis_id = self.get_axis_id(axis_id)
        style = self.axes_styles[axis_id]

        title_font = style.title_font.build_font()
        ticks_font = style.ticks_font.build_font()
        self.setAxisFont(axis_id, ticks_font)

        if style.title and style.unit:
            title = "%s (%s)" % (style.title, style.unit)
        elif style.title:
            title = style.title
        else:
            title = style.unit
        axis_text = self.axisTitle(axis_id)
        axis_text.setFont(title_font)
        axis_text.setText(title)
        axis_text.setColor(QColor(style.color))
        self.setAxisTitle(axis_id, axis_text)
        self.SIG_PLOT_LABELS_CHANGED.emit(self)
Esempio n. 18
0
def _setup_colormap(cmap, cmdata):
    """Setup a QwtLinearColorMap according to
    matplotlib's data
    """
    red = array(cmdata["red"])
    green = array(cmdata["green"])
    blue = array(cmdata["blue"])
    qmin = QColor()
    qmin.setRgbF(red[0, 2], green[0, 2], blue[0, 2])
    qmax = QColor()
    qmax.setRgbF(red[-1, 2], green[-1, 2], blue[-1, 2])
    cmap.setColorInterval(qmin, qmax)
    indices = sorted(set(red[:, 0]) | set(green[:, 0]) | set(blue[:, 0]))
    for i in indices[1:-1]:
        idxr = red[:, 0].searchsorted(i)
        idxg = green[:, 0].searchsorted(i)
        idxb = blue[:, 0].searchsorted(i)
        compr = _interpolate(i, red[idxr - 1], red[idxr])
        compg = _interpolate(i, green[idxg - 1], green[idxg])
        compb = _interpolate(i, blue[idxb - 1], blue[idxb])
        col = QColor()
        col.setRgbF(compr, compg, compb)
        cmap.addColorStop(i, col)
Esempio n. 19
0
 def fun(shape):
     shape.symbol.pen().setWidth(2)
     shape.symbol.setColor(QColor(255, 0, 0))
Esempio n. 20
0
    def __init__(self, parent):
        n = len(parent.sp)
        cmap = get_cmap('tab10', n * 2 + 3)
        self.colors = [
            QPen(QColor(x[0] * 255, x[1] * 255, x[2] * 255), 1)
            for x in cmap.colors
        ]


        plots=\
         [[
          {'name':'Average Signal and Retrieved Signal','curves':[]},
          {'name':'Residual Signal','curves':[]}],
         [
        #				{'name':'Averaging kernel for OEM retrieval','curves':['Averaging']},
          {'name':'Measurement response to OEM retrieval','curves':[]}],
         [
          {'name':'Altitude vs. H2O VMR','curves':['Prior']}],
         ]

        for i in range(n):
            plots[0][0]['curves'].append('Data' + str(i))
            plots[0][0]['curves'].append('Retrieval' + str(i))
            plots[0][1]['curves'].append('Residual' + str(i))
            plots[1][0]['curves'].append('Response' + str(i))
            plots[2][0]['curves'].append('OEM Retrieval' + str(i))

        PlotPanel.__init__(self, parent=parent,
                           plots=plots)  #,axisLimits=axisLimits)

        self.colors[2 * n + 2].setWidth(3)
        self.curves['Prior'].setPen(self.colors[2 * n + 2])

        for i in range(n):
            self.curves['OEM Retrieval' + str(i)].setPen(self.colors[2 * i])
            self.curves['Data' + str(i)].setPen(self.colors[2 * i])
            self.curves['Residual' + str(i)].setPen(self.colors[2 * i])
            self.curves['Response' + str(i)].setPen(self.colors[2 * i])
            self.colors[2 * i + 1].setWidth(3)
            self.curves['Retrieval' + str(i)].setPen(self.colors[2 * i + 1])

            pDaRe = self.curves['Data' + str(i)].parent
            pResi = self.curves['Residual' + str(i)].parent
            #		pAver=self.curves['Averaging'].parent
            pResp = self.curves['Response' + str(i)].parent
            pPOEM = self.curves['Prior'].parent

            pPOEM.set_titles(ylabel='Altitude [m]', xlabel='Retrieval')
            pDaRe.set_titles(ylabel='Brightness Temperature [K]',
                             xlabel='Frequency [GHz]')
            pResi.set_titles(ylabel='Residual [K]', xlabel='Frequency [GHz]')
            #		pAver.set_titles(ylabel='Altitude [m]',xlabel='')
            pResp.set_titles(ylabel='Altitude [m]', xlabel='')

            pDaRe.add_item(make.legend("TR"))
            pDaRe.setActive()

            pPOEM.add_item(make.legend("TR"))
            pPOEM.setActive()

            pDaRe.setDefaultAxis(axis=[142.1, 142.2, 100., 200.])
            pResi.setDefaultAxis(axis=[142.1, 142.2, -.5, .5])
            #		pAver.setDefaultAxis(axis=[xmin,xmax,0.,1e5])
            pResp.setDefaultAxis(axis=[-.1, 2., 0., 1e5])
            pPOEM.setDefaultAxis(axis=[-.1, 12., 0., 1e5])