Пример #1
0
 def startDrag(self, event):
     """ operations done when we start a drag event """
     drag = Qt.QDrag(self)
     mimedata = Qt.QMimeData()
     passed_string = 'copyColorRange'
     mimedata.setText(passed_string)
     drag.setMimeData(mimedata)
     drag.exec_()
     event.accept()
Пример #2
0
 def create_layout_stuff(self):
     """ create grid layouts into which plotter widgets are inserted """
     if self.layout_parent is None or not self.layout_created:
         self.layout_parent = Qt.QWidget(self.wparent())
         self.layout = Qt.QGridLayout(self.layout_parent)
         self.set_widgets(self.layout_parent,
                          self.dataitem.caption,
                          icon=self.icon())
         self.layout_created = True
     self._wtop = self.layout_parent
Пример #3
0
    def initScale(self, align):
        self.__data = QwtScaleWidget_PrivateData()
        self.__data.layoutFlags = 0
        if align == QwtScaleDraw.RightScale:
            self.__data.layoutFlags |= self.TitleInverted

        self.__data.borderDist = [0, 0]
        self.__data.minBorderDist = [0, 0]
        self.__data.margin = 4
        self.__data.titleOffset = 0
        self.__data.spacing = 2

        self.__data.scaleDraw = QwtScaleDraw()
        self.__data.scaleDraw.setAlignment(align)
        self.__data.scaleDraw.setLength(10)

        self.__data.scaleDraw.setScaleDiv(QwtLinearScaleEngine().divideScale(
            0.0, 100.0, 10, 5))

        self.__data.colorBar.colorMap = QwtLinearColorMap()
        self.__data.colorBar.isEnabled = False
        self.__data.colorBar.width = 10

        flags = Qt.AlignmentFlag(Qt.AlignHCenter | Qt.TextExpandTabs
                                 | Qt.TextWordWrap)
        self.__data.title.setRenderFlags(flags)
        self.__data.title.setFont(self.font())

        policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
        if self.__data.scaleDraw.orientation() == Qt.Vertical:
            policy.transpose()

        self.setSizePolicy(policy)

        self.setAttribute(Qt.WA_WState_OwnSizePolicy, False)
Пример #4
0
 def __init__(self):
     self.isDirty = True
     self.maxColumns = 0
     self.numRows = 0
     self.numColumns = 0
     self.expanding = Qt.Orientations()
     self.itemSizeHints = []
     self.itemList = []
Пример #5
0
    def mightRender(self, text):
        """
        Test if a string can be rendered by this text engine

        :param str text: Text to be tested
        :return: True, if it can be rendered
        """
        return Qt.mightBeRichText(text)
Пример #6
0
    def mightRender(self, text):
        """
        Test if a string can be rendered by this text engine

        :param str text: Text to be tested
        :return: True, if it can be rendered
        """
        return Qt.mightBeRichText(text)
Пример #7
0
def newToQImage(array):
    """Converts a numpy array to a QImage 
    A Python version of PyQt4.Qwt5.toQImage(array) in PyQwt >= 5.2.
    Function written by Gerard Vermeulen
    """
    if array.ndim != 2:
        raise RuntimeError('array must be 2-D')
    height, width = array.shape
    if array.dtype == numpy.uint8:
        # image = QImage(array, width, height, QImage.Format_Indexed8)
        # The next statement shows that QImage does not increase the
        # reference count of the buffer object to keep the data valid.
        image = Qt.QImage(
            array.tostring(), width, height, Qt.QImage.Format_Indexed8)
        image.setNumColors(256)
        for i in range(256):
            image.setColor(i, qRgb(i, i, i))
        return image
    elif array.dtype == numpy.uint32:
        image = Qt.QImage(
            array.tostring(), width, height, Qt.QImage.Format_ARGB32)
        return image
    else:
        raise RuntimeError('array.dtype must be uint8 or uint32')
Пример #8
0
    def plot_3D_array(self, display_flag_3D):
        # first figure out the actual rank of the array we are plotting
        self.actual_rank = 0
        self.array_shape = self.dataitem.data.shape
        self.array_rank = self.dataitem.data.ndim
        for i in range(len(self.array_shape)):
            if self.array_shape[i] > 1:
                self.actual_rank = self.actual_rank + 1
        if display_flag_3D and self.actual_rank > 2:
            self.set_ND_controls(None, None, num_axes=3)
            self.array_selector = None
        else:
            if not self.ND_Controls is None:
                self.ND_Controls.setParent(Qt.QWidget())
                self.ND_Controls = None
# pass initial array to the plotter
        if self.array_rank > 2:
            self.data = self.dataitem.data
            if self.array_selector is None:
                third_axis = None
                second_axis = None
                first_axis = None
                for i in range(self.array_rank - 1, -1, -1):
                    if self.data.shape[i] > 1:
                        if third_axis is None:
                            third_axis = i
                        elif second_axis is None:
                            second_axis = i
                        else:
                            if first_axis is None:
                                first_axis = i
                if not first_axis is None and not second_axis is None and not third_axis is None:
                    self.array_selector = plot_func.create_array_selector(
                        None, self.array_rank, self.data.shape, first_axis,
                        second_axis, third_axis)
            self.array_tuple = tuple(self.array_selector)
            plot_array = self.data[self.array_tuple]
        else:
            plot_array = self.data
        if plot_array.min() == plot_array.max():
            return
        else:
            self.ND_plotter.array_plot(plot_array, data_label='data ')

# enable & highlight the cell
        self.enable()
        self.flash_refresh()
Пример #9
0
    def setRenderFlags(self, renderFlags):
        """
        Change the render flags

        The default setting is `Qt.AlignCenter`

        :param int renderFlags: Bitwise OR of the flags used like in `QPainter.drawText()`

        .. seealso::
        
            :py:meth:`renderFlags()`, 
            :py:meth:`qwt.text.QwtTextEngine.draw()`
        """
        renderFlags = Qt.AlignmentFlag(renderFlags)
        if renderFlags != self.__data.renderFlags:
            self.__data.renderFlags = renderFlags
            self.__layoutCache.invalidate()
Пример #10
0
    def show_3D_Display(self, display_flag_3D):
        if not has_vtk:
            return
        self.twoD_plotter = delete_2D_Plotters(self.colorbar,
                                               self.twoD_plotter)
        self.status_label.setParent(Qt.QWidget())
        self.status_label = None

        if self.ND_plotter is None:
            self.ND_plotter = plot_func.create_ND_Plotter(
                self.layout, self.layout_parent)
            self.ND_plotter.show_2D_Display.connect(self.show_2D_Display)
            self.ND_plotter.show_ND_Controller.connect(
                self.ND_controller_showDisplay)
        else:
            self.ND_plotter.delete_vtk_renderer()
            self.ND_plotter.show_vtk_controls()


# create 3-D Controller
        self.plot_3D_array(display_flag_3D)
Пример #11
0
 def create_2D_plotter(self):
     if not self.ND_plotter is None:
         self.ND_plotter.close()
         self.ND_plotter = None
     self.twoD_plotter, self.plotPrinter = plot_func.create_2D_Plotters(
         self.layout, self.layout_parent)
     self.twoD_plotter.colorbar_needed.connect(self.set_ColorBar)
     self.twoD_plotter.show_ND_Controller.connect(
         self.ND_controller_showDisplay)
     self.twoD_plotter.show_3D_Display.connect(self.show_3D_Display)
     self.twoD_plotter.do_print.connect(self.plotPrinter.do_print)
     self.twoD_plotter.save_display.connect(self.grab_display)
     # create status label display
     self.status_label = Qt.QLabel(self.layout_parent)
     sansFont = QFont("Helvetica [Cronyx]", 8)
     self.status_label.setFont(sansFont)
     #   self.layout.addMultiCellWidget(self.status_label,1,1,0,2)
     self.layout.addWidget(self.status_label, 1, 0, 1, 2)
     self.status_label.setText("Move the mouse within the plot canvas"
                               " to show the cursor position.")
     self.status_label.show()
     self.twoD_plotter.status_update.connect(self.update_status)
Пример #12
0
def oldToQImage(array):
    """Converts a numpy array to a QImage 
    A Python version of PyQt4.Qwt5.toQImage(array) in PyQwt < 5.2.
    Function written by Gerard Vermeulen 
    """
    if array.ndim != 2:
        raise RuntimeError('array must be 2-D')
    nx, ny = array.shape # width, height
    xstride, ystride = array.strides
    if array.dtype == numpy.uint8:
        image = QImage(nx, ny, QImage.Format_Indexed8)
        f_array = numpy.reshape(array,(nx*ny,),order='F')
        for j in range(ny):
            pointer = image.scanLine(j)
            pointer.setsize(nx*array.itemsize)
            memory = numpy.frombuffer(pointer, numpy.uint8)
            first_value = j*nx
            last_value = (j+1)*nx 
            memory[:] = f_array[first_value:last_value]
        image.setColorCount(256)
        for i in range(256):
            image.setColor(i, qRgb(i, i, i))
        return image
    elif array.dtype == numpy.uint32:
        image = Qt.QImage(
            array.tostring(), width, height, Qt.QImage.Format_ARGB32)
        f_array = numpy.reshape(array,(nx*ny,),order='F')
        for j in xrange(ny):
            pointer = image.scanLine(j)
            pointer.setsize(nx*array.itemsize)
            memory = numpy.frombuffer(pointer, numpy.uint32)
            first_value = j*nx
            last_value = (j+1)*nx 
            memory[:] = f_array[first_value:last_value]
        return image
    else:
        raise RuntimeError('array.dtype must be uint8 or uint32')
Пример #13
0
 def drawLabel(self, painter, canvasRect, pos):
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             alignPos.setY(canvasRect.bottom() - 1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right() - 1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF() / 2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x() - (xOff + spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height())
         else:
             alignPos.setX(alignPos.x() - textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x() + xOff + spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height() / 2)
         else:
             alignPos.setX(alignPos.x() - textSize.width() / 2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y() - (yOff + spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y() - textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y() + yOff + spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width() / 2)
         else:
             alignPos.setY(alignPos.y() - textSize.height() / 2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Пример #14
0
 def setRenderFlags(self, renderFlags):
     renderFlags = Qt.AlignmentFlag(renderFlags)
     if renderFlags != self.__data.renderFlags:
         self.__data.renderFlags = renderFlags
         self.__layoutCache.invalidate()
Пример #15
0
 def mightRender(self, text):
     return Qt.mightBeRichText(text)
Пример #16
0
 def drawLabel(self, painter, canvasRect, pos):
     """
     Align and draw the text label of the marker
     
     :param QPainter painter: Painter
     :param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
     :param QPointF pos: Position of the marker, translated into widget coordinates
     
     .. seealso::
     
         :py:meth:`drawLabel()`, 
         :py:meth:`qwt.symbol.QwtSymbol.drawSymbol()`
     """
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         #  In VLine-style the y-position is pointless and
         #  the alignment flags are relative to the canvas
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             #  In HLine-style the x-position is pointless and
             #  the alignment flags are relative to the canvas
             alignPos.setY(canvasRect.bottom() - 1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right() - 1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF() / 2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x() - (xOff + spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height())
         else:
             alignPos.setX(alignPos.x() - textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x() + xOff + spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height() / 2)
         else:
             alignPos.setX(alignPos.x() - textSize.width() / 2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y() - (yOff + spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y() - textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y() + yOff + spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width() / 2)
         else:
             alignPos.setY(alignPos.y() - textSize.height() / 2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Пример #17
0
 def mightRender(self, text):
     return Qt.mightBeRichText(text)