Exemple #1
0
    def __init__(self, data, radius=15):

        self.data = data

        # Add circular node
        self.node = QGraphicsEllipseItem(0, 0, 1, 1)

        # Set radius
        self.radius = radius

        # Add text label
        self.label = QGraphicsTextItem(data.label)
        font = self.label.font()
        font.setPointSize(10)
        self.label.setFont(font)

        # Add line between label and node
        self.line1 = QGraphicsLineItem(0, 0, 1, 1)
        self.line2 = QGraphicsLineItem(0, 0, 1, 1)

        self.node.setZValue(20)
        self.label.setZValue(10)
        self.line1.setZValue(10)
        self.line2.setZValue(10)

        self.line1.setPen(get_pen('0.5'))
        self.line2.setPen(get_pen('0.5'))

        self.color = '0.8'
Exemple #2
0
    def addPoint(self, text, color, border=None, size=20.0):
        shape = QGraphicsEllipseItem(size / 2.0, size / 2.0, size, size)
        brush = makeBrush(color)
        shape.setBrush(brush)
        shape.setPen(makePen(border))

        self.addEntry(MapLegendEntryItem(shape, text))
Exemple #3
0
    def __init__(self, data, radius=15):

        self.data = data

        # Add circular node
        self.node = QGraphicsEllipseItem(0, 0, 1, 1)

        # Set radius
        self.radius = radius

        # Add text label
        self.label = QGraphicsTextItem(data.label)
        font = self.label.font()
        font.setPointSize(10)
        self.label.setFont(font)

        # Add line between label and node
        self.line1 = QGraphicsLineItem(0, 0, 1, 1)
        self.line2 = QGraphicsLineItem(0, 0, 1, 1)

        self.node.setZValue(20)
        self.label.setZValue(10)
        self.line1.setZValue(10)
        self.line2.setZValue(10)

        self.line1.setPen(get_pen('0.5'))
        self.line2.setPen(get_pen('0.5'))

        self.color = '0.8'
Exemple #4
0
    def __init__(self, longitude, latitude, radius, parent=None):
        """Constructor.

        Args:
            longitude(float): Longitude of the center of the circle.
            latitude(float): Latitude of the center of the circle.
            radius(float): Radius of the circle in pixels.
            scene(MapGraphicsScene): Scene to which the circle belongs.
            parent(QGraphicsItem): Parent item, default None.

        Note:
            The management of the parent item is work in progress.
        """
        QGraphicsEllipseItem.__init__(self, parent=parent)
        MapItem.__init__(self)

        self._lon = longitude
        self._lat = latitude
        self._radius = radius
Exemple #5
0
    def __init__(self, longitude, latitude, radius, parent=None):
        """Constructor.

        Args:
            longitude(float): Longitude of the center of the circle.
            latitude(float): Latitude of the center of the circle.
            radius(float): Radius of the circle in pixels.
            scene(MapGraphicsScene): Scene to which the circle belongs.
            parent(QGraphicsItem): Parent item, default None.

        Note:
            The management of the parent item is work in progress.
        """
        QGraphicsEllipseItem.__init__(self, parent=parent)
        MapItem.__init__(self)
        self.setFlags(QGraphicsItem.ItemIsMovable)

        self._lon = longitude
        self._lat = latitude
        self._radius = radius
    def drawRGBACrosshair(self):
        """
        rgba_topline_item
        rgba_botline_item
        rgba_leftline_item
        rgba_rightline_item:
        rgba_crosshair_item_circle: center portion of crosshair

        """
        # vertical line
        self.rgba_topline_item = DualColoredLineSegment()
        self.rgba_topline_item.setLine(0, 0, 0, self.height())
        self.rgba_botline_item = DualColoredLineSegment()
        self.rgba_botline_item.setLine(0, 0, 0, self.height())

        # horizontal line
        self.rgba_leftline_item = DualColoredLineSegment()
        self.rgba_leftline_item.setLine(0, 0, self.width(), 0)
        self.rgba_rightline_item = DualColoredLineSegment()
        self.rgba_rightline_item.setLine(0, 0, self.width(), 0)

        # crosshair circle
        self.rgba_crosshair_item_circle = QGraphicsEllipseItem()

        self.rgba_crosshair_item_circle.setRect(
            -(self.CROSSHAIR_RADIUS * 0.5),
            -(self.CROSSHAIR_RADIUS * 0.5),
            self.CROSSHAIR_RADIUS,
            self.CROSSHAIR_RADIUS
        )

        # add items
        self.rgba_crosshair_item = QGraphicsItemGroup()

        self.rgba_crosshair_item.addToGroup(self.rgba_crosshair_item_circle)
        self.rgba_crosshair_item.addToGroup(self.rgba_topline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_botline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_leftline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_rightline_item)

        self.addItem(self.rgba_crosshair_item)
Exemple #7
0
    def addPoint(self, text, color, border=None, size=20.0):
        shape = QGraphicsEllipseItem(size / 2.0, size / 2.0, size, size)
        brush = makeBrush(color)
        shape.setBrush(brush)
        shape.setPen(makePen(border))

        self.addEntry(MapLegendEntryItem(shape, text))
Exemple #8
0
class DataNode:
    def __init__(self, data, radius=15):

        self.data = data

        # Add circular node
        self.node = QGraphicsEllipseItem(0, 0, 1, 1)

        # Set radius
        self.radius = radius

        # Add text label
        self.label = QGraphicsTextItem(data.label)
        font = self.label.font()
        font.setPointSize(10)
        self.label.setFont(font)

        # Add line between label and node
        self.line1 = QGraphicsLineItem(0, 0, 1, 1)
        self.line2 = QGraphicsLineItem(0, 0, 1, 1)

        self.node.setZValue(20)
        self.label.setZValue(10)
        self.line1.setZValue(10)
        self.line2.setZValue(10)

        self.line1.setPen(get_pen('0.5'))
        self.line2.setPen(get_pen('0.5'))

        self.color = '0.8'

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        self._radius = value
        self.node.setRect(-value, -value, 2 * value, 2 * value)

    def contains(self, point):

        # Check label
        if self.label.contains(self.label.mapFromScene(point)):
            return True

        # Check node
        if self.node.contains(self.node.mapFromScene(point)):
            return True

        return False

    def update(self):
        self.node.update()

    def add_to_scene(self, scene):
        scene.addItem(self.node)
        scene.addItem(self.label)
        scene.addItem(self.line1)
        scene.addItem(self.line2)

    def remove_from_scene(self, scene):
        scene.removeItem(self.node)
        scene.removeItem(self.label)
        scene.removeItem(self.line1)
        scene.removeItem(self.line2)

    @property
    def node_position(self):
        pos = self.node.pos()
        return pos.x(), pos.y()

    @node_position.setter
    def node_position(self, value):
        self.node.setPos(value[0], value[1])
        self.update_lines()

    @property
    def label_position(self):
        pos = self.label.pos()
        return pos.x(), pos.y()

    @label_position.setter
    def label_position(self, value):
        self.label.setPos(value[0], value[1])
        self.update_lines()

    def update_lines(self):
        x0, y0 = self.label_position
        x2, y2 = self.node_position
        x1 = 0.5 * (x0 + x2)
        y1 = y0
        self.line1.setLine(x0, y0, x1, y1)
        self.line2.setLine(x1, y1, x2, y2)

    @property
    def color(self):
        return qt_to_mpl_color(self.node.brush().color())

    @color.setter
    def color(self, value):
        self.node.setBrush(mpl_to_qt_color(value))
Exemple #9
0
 def __init__(self, size: int, key: Optional[int] = None, **kwargs):
     QGraphicsEllipseItem.__init__(self, 0, 0, size, size)
     Marker.__init__(self, key, **kwargs)
Exemple #10
0
    def updateTime(self, frame):
        if frame == self.previousframe:
            return
        self.previousframe = frame
        idx = self.currentPuff.currentIndex()
        currentPuff = self.group.puffs[idx]

        image1 = np.copy(self.I[frame])
        mmax = np.max(self.I)
        image1 = image1 / mmax
        image2 = np.copy(self.I_fits[idx][frame])
        image2 = image2 / mmax
        self.puff_3D.update_images(image1, image2)

        rel_frame = frame - (currentPuff.kinetics['t_start'] -
                             currentPuff.kinetics['before'])
        for line in [self.vLine1, self.vLine2,
                     self.vLine5]:  # self.vLine3,self.vLine4,self.vLine5]:
            line.setValue(rel_frame)
        for bar in self.error_bars:
            bar.plot.removeItem(bar)
        self.error_bars = []
        for item in self.addedItems:
            self.imageview.view.removeItem(item)
        self.addedItems = []

        scatter = pg.ScatterPlotItem(size=8, pen=pg.mkPen(None))
        self.imageview.view.addItem(scatter)
        self.addedItems.append(scatter)
        spots = []
        for i in np.arange(len(self.group.puffs)):
            rel_frame2 = frame - ((currentPuff.kinetics['t_start'] -
                                   currentPuff.kinetics['before']) -
                                  (self.group.puffs[i].kinetics['t_start'] -
                                   self.group.puffs[i].kinetics['before']))
            if self.puffCheckBoxes[i].isChecked(
            ) and rel_frame2 >= 0 and rel_frame2 < self.params[i].shape[0]:
                centers = self.params[i][:, :2] - self.bounds[1:, 0]
                center = centers[rel_frame2, :]
                amps = np.copy(self.params[i][:, -1])
                amps[amps <= 0] = .00000001
                amp = amps[rel_frame2]
                std = self.group.puffs[0].clusters.standard_deviations[i]
                color = np.array(self.colors[i])
                color[3] = 50
                ### FIRST ADD THE POINT TO THE SCATTER PLOT
                if 0.8 / amp < std:  # if the amplitude>0 and the error (0.8/SNR) is within the fitting bounds
                    ### FIRST PLOT THE
                    """ WARNING!!! the amp should really be the signal to noise ratio, so it is only valid when the image has been ratiod by the standard deviation of the noise """
                    sigma = 0.8 / amp
                    sigmas = 0.8 / amps
                    # add error bars to x and y
                    # first add X
                    color[3] = 255
                    err = pg.ErrorBarItem(
                        x=np.array([rel_frame]),
                        y=np.array([self.params[i][rel_frame2, 0]]),
                        top=np.array([sigma]),
                        bottom=np.array([sigma]),
                        beam=0.5,
                        pen=pg.mkPen(pg.mkColor(tuple(color))))
                    self.p3.addItem(err)
                    err.plot = self.p3
                    self.error_bars.append(err)
                    # second add Y
                    err = pg.ErrorBarItem(
                        x=np.array([rel_frame]),
                        y=np.array([self.params[i][rel_frame2, 1]]),
                        top=np.array([sigma]),
                        bottom=np.array([sigma]),
                        beam=0.5,
                        pen=pg.mkPen(pg.mkColor(tuple(color))))
                    self.p4.addItem(err)
                    err.plot = self.p4
                    self.error_bars.append(err)

                    reasonable_fit = sigmas < 2 * std
                    bounds = QRectF(
                        QPointF(center[0] - sigma, center[1] - sigma),
                        QSizeF(2 * sigma, 2 * sigma))

                    ### plot outer circle
                    pathitem = QGraphicsEllipseItem(bounds)
                    color[-1] = 127  # alpha channel
                    pathitem.setPen(pg.mkPen(pg.mkColor(tuple(color))))
                    pathitem.setBrush(pg.mkColor((0, 0, 0, 0)))
                    self.imageview.view.addItem(pathitem)
                    self.addedItems.append(pathitem)

                    ### plot line
                    frame_i = rel_frame2 - 6
                    if frame_i < 0:
                        frame_i = 0
                    alpha = 255
                    for ii in np.arange(rel_frame2, frame_i, -1) - 1:
                        if alpha <= 0 or not reasonable_fit[ii]:
                            break
                        color[-1] = alpha  # alpha channel
                        alpha = alpha - (255 * 1. / 6.)
                        pathitem = QGraphicsPathItem()
                        pathitem.setPen(pg.mkColor(tuple(color)))
                        path = QPainterPath(QPointF(*centers[ii]))
                        path.lineTo(QPointF(*centers[ii + 1]))
                        pathitem.setPath(path)
                        self.imageview.view.addItem(pathitem)
                        self.addedItems.append(pathitem)
                    color[3] = 255  # make the spot transparent
                spots.append({
                    'pos': center,
                    'brush': pg.mkBrush(pg.mkColor(tuple(color)))
                })
        scatter.addPoints(spots)
class ColorGraphicsScene(QGraphicsScene):
    """
    The widget that is responsible for displaying the color gradient to the user
    """

    def __init__(self, parent=None):
        super(ColorGraphicsScene, self).__init__(parent)
        # setup default attrs
        self.CROSSHAIR_RADIUS = 10
        self._rgba_crosshair_pos = QPoint(0, 0)
        self._linear_crosshair_pos = QPoint(0, 0)
        self._linear_crosshair_size = 15

        # create scene
        self.setSceneRect(0, 0, 500, 500)
        self.gradient_type = attrs.RGBA
        self.drawRGBACrosshair()
        self.drawLinearCrosshair()
        self._drawRGBAForegroundItem()

    """ DRAW GRADIENTS """
    def drawGradient(self):
        """
        Draws the gradient that will be displayed to the user
        """

        _gradient = draw.drawColorTypeGradient(self.gradient_type, self.width(), self.height())
        direction = self.linearCrosshairDirection()
        self.rgba_foreground.hide()

        # show gradient for RGBA gradient
        if self.gradient_type == attrs.RGBA:
            """
            for some reason the darker it gets the harder of a time the picker has
            and the steps become larger and larger =/
            """
            # get value
            main_widget = getWidgetAncestor(self.views()[0], ColorGradientDelegate)
            value = main_widget.color().valueF()
            self.rgba_foreground.updateSize(QRectF(0, 0, self.width(), self.height()))
            self.rgba_foreground.updateGradient(value, self.width(), self.height())

            self.rgba_foreground.show()

        # update linear gradient
        else:
            if direction == Qt.Horizontal:
                _gradient.setFinalStop(QPoint(self.width(), 0))
            elif direction == Qt.Vertical:
                # TODO Move this to draw utils (gradient inversion)
                _gradient.setStart(QPoint(0, self.height()))
                _gradient.setFinalStop(QPoint(0, 0))

        self.setBackgroundBrush(QBrush(_gradient))

    """ PROPERTIES """
    @property
    def gradient_type(self):
        return self._gradient_type

    @gradient_type.setter
    def gradient_type(self, gradient_type):
        self._gradient_type = gradient_type

    """ CROSSHAIR"""
    def drawLinearCrosshair(self):
        """
        Creates the initial linear crosshair.  Note that this is hard coded to setup
        to be drawn horizontally.  You can update the direction with
        setLinearCrosshairDirection(Qt.Direction) on the
        ColorInputWidget.
        """
        self.linear_crosshair_item = ColorPickerItem1D()
        self.linear_crosshair_item.setWidth(self.width())
        self.linear_crosshair_item.setHeight(self.height())
        self.linear_crosshair_item.setDirection(Qt.Horizontal)

        # add group item
        self.addItem(self.linear_crosshair_item)

        # hide by default
        self.linear_crosshair_item.hide()

    def setLinearCrosshairDirection(self, direction):
        """
        Sets the direction of travel of the linear crosshair.  This will also update
        the display of the crosshair

        Args:
            direction (Qt.Vertical | Qt. Horizontal): what direction this gradient will be
                displayed as.
        """
        # set direction
        self._linear_crosshair_direction = direction
        self.linear_crosshair_item.setDirection(direction)

    def linearCrosshairDirection(self):
        return self._linear_crosshair_direction

    """ RGBA """
    def drawRGBACrosshair(self):
        """
        rgba_topline_item
        rgba_botline_item
        rgba_leftline_item
        rgba_rightline_item:
        rgba_crosshair_item_circle: center portion of crosshair

        """
        # vertical line
        self.rgba_topline_item = DualColoredLineSegment()
        self.rgba_topline_item.setLine(0, 0, 0, self.height())
        self.rgba_botline_item = DualColoredLineSegment()
        self.rgba_botline_item.setLine(0, 0, 0, self.height())

        # horizontal line
        self.rgba_leftline_item = DualColoredLineSegment()
        self.rgba_leftline_item.setLine(0, 0, self.width(), 0)
        self.rgba_rightline_item = DualColoredLineSegment()
        self.rgba_rightline_item.setLine(0, 0, self.width(), 0)

        # crosshair circle
        self.rgba_crosshair_item_circle = QGraphicsEllipseItem()

        self.rgba_crosshair_item_circle.setRect(
            -(self.CROSSHAIR_RADIUS * 0.5),
            -(self.CROSSHAIR_RADIUS * 0.5),
            self.CROSSHAIR_RADIUS,
            self.CROSSHAIR_RADIUS
        )

        # add items
        self.rgba_crosshair_item = QGraphicsItemGroup()

        self.rgba_crosshair_item.addToGroup(self.rgba_crosshair_item_circle)
        self.rgba_crosshair_item.addToGroup(self.rgba_topline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_botline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_leftline_item)
        self.rgba_crosshair_item.addToGroup(self.rgba_rightline_item)

        self.addItem(self.rgba_crosshair_item)

    def getRGBACrosshairPos(self):
        return self._rgba_crosshair_pos

    def setRGBACrosshairPos(self, pos):
        """
        Places the crosshair at a specific  location in the widget.  This is generally
        used when updating color values, and passing them back to the color widget.

        Args:
            pos (QPoint): in LOCAL space
        """


        crosshair_radius = self.CROSSHAIR_RADIUS * 0.5
        xpos = pos.x()
        ypos = pos.y()

        # update items positions
        self.rgba_crosshair_item_circle.setPos(pos)
        self.rgba_topline_item.setLine(xpos, 0, xpos, ypos - crosshair_radius)
        self.rgba_botline_item.setLine(xpos, ypos + crosshair_radius, xpos, self.height())
        self.rgba_leftline_item.setLine(0, ypos, xpos - crosshair_radius, ypos)
        self.rgba_rightline_item.setLine(xpos + crosshair_radius, ypos, self.width(), ypos)

        # set attr
        self._rgba_crosshair_pos = pos

    def updateRGBACrosshair(self):
        main_widget = getWidgetAncestor(self, ColorGradientDelegate)
        xpos = (main_widget.color().hueF() * self.width())
        ypos = math.fabs((main_widget.color().saturationF() * self.height()) - self.height())
        pos = QPoint(xpos, ypos)
        self.setRGBACrosshairPos(pos)

    def _drawRGBAForegroundItem(self):
        """
        Creates the RGBA Foreground item.  This item is just one big rectangle
        that spans the entire scene with a 1D gradient in it to compensate for the
        Saturation portion of the RGBA gradient.
        """
        self.rgba_foreground = RGBAForegroundGradient(self.width(), self.height())
        self.addItem(self.rgba_foreground)
        self.rgba_foreground.setZValue(-10)
Exemple #12
0
class DataNode:

    def __init__(self, data, radius=15):

        self.data = data

        # Add circular node
        self.node = QGraphicsEllipseItem(0, 0, 1, 1)

        # Set radius
        self.radius = radius

        # Add text label
        self.label = QGraphicsTextItem(data.label)
        font = self.label.font()
        font.setPointSize(10)
        self.label.setFont(font)

        # Add line between label and node
        self.line1 = QGraphicsLineItem(0, 0, 1, 1)
        self.line2 = QGraphicsLineItem(0, 0, 1, 1)

        self.node.setZValue(20)
        self.label.setZValue(10)
        self.line1.setZValue(10)
        self.line2.setZValue(10)

        self.line1.setPen(get_pen('0.5'))
        self.line2.setPen(get_pen('0.5'))

        self.color = '0.8'

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        self._radius = value
        self.node.setRect(-value, -value, 2 * value, 2 * value)

    def contains(self, point):

        # Check label
        if self.label.contains(self.label.mapFromScene(point)):
            return True

        # Check node
        if self.node.contains(self.node.mapFromScene(point)):
            return True

        return False

    def update(self):
        self.node.update()

    def add_to_scene(self, scene):
        scene.addItem(self.node)
        scene.addItem(self.label)
        scene.addItem(self.line1)
        scene.addItem(self.line2)

    def remove_from_scene(self, scene):
        scene.removeItem(self.node)
        scene.removeItem(self.label)
        scene.removeItem(self.line1)
        scene.removeItem(self.line2)

    @property
    def node_position(self):
        pos = self.node.pos()
        return pos.x(), pos.y()

    @node_position.setter
    def node_position(self, value):
        self.node.setPos(value[0], value[1])
        self.update_lines()

    @property
    def label_position(self):
        pos = self.label.pos()
        return pos.x(), pos.y()

    @label_position.setter
    def label_position(self, value):
        self.label.setPos(value[0], value[1])
        self.update_lines()

    def update_lines(self):
        x0, y0 = self.label_position
        x2, y2 = self.node_position
        x1 = 0.5 * (x0 + x2)
        y1 = y0
        self.line1.setLine(x0, y0, x1, y1)
        self.line2.setLine(x1, y1, x2, y2)

    @property
    def color(self):
        return qt_to_mpl_color(self.node.brush().color())

    @color.setter
    def color(self, value):
        self.node.setBrush(mpl_to_qt_color(value))