pymodaq 4.2.4__py3-none-any.whl → 5.0.0__py3-none-any.whl

pymodaq/utils/plotting/gant_chart.py

@@ -1,123 +0,0 @@
-import sys
-from qtpy import QtWidgets
-from qtpy.QtCore import QDateTime, Signal, QPointF, QObject
-import numpy as np
-import pyqtgraph as pg
-from pymodaq.utils.plotting.widgets.image import ImageWidget
-from pymodaq.utils.managers.roi_manager import ROIBrushable
-
-from pyqtgraph.graphicsItems.GradientEditorItem import Gradients
-
-pos = []
-colors = []
-for ticks in Gradients['thermal']['ticks']:
-    pos.append(ticks[0])
-    colors.append(ticks[1])
-cmap = pg.ColorMap(pos, colors, Gradients['thermal']['mode'])
-
-
-def setTicksLabels(values):
-    strings = []
-    for v in values:
-        d = QDateTime()
-        d = d.fromSecsSinceEpoch(v * 30 * 60)
-        vstr = d.toString('HH:mm dd/MM/yy')
-        strings.append(vstr)
-    return strings
-
-
-class AxisItemDate(pg.AxisItem):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def tickStrings(self, values, scale, spacing):
-        if self.logMode:
-            return self.logTickStrings(values, scale, spacing)
-
-        places = max(0, np.ceil(-np.log10(spacing * scale)))
-        strings = setTicksLabels(values)
-        return strings
-
-
-class GanttROI(ROIBrushable):
-    index_signal = Signal(int)
-
-    def __init__(self, task='No task', index=0, start=0, stop=1, brush=None, *args, **kwargs):
-        super().__init__(pos=[start, index], size=[stop - start, 1], brush=brush, pen=brush, snapSize=1, scaleSnap=True,
-                         translateSnap=True, *args, **kwargs)  # )
-        self.h1 = self.addScaleHandle([1, 0.5], [0, 0.5])
-        self.h2 = self.addScaleHandle([0, 0.5], [1, 0.5])
-
-        self.task = task
-        self.setToolTip(task)
-        self.index = index
-        self.sigRegionChangeFinished.connect(self.emit_index_signal)
-        self.sigRegionChangeFinished.connect(self.update_tooltip)
-        self.update_tooltip()
-
-    def update_tooltip(self):
-        self.h2.setToolTip(setTicksLabels([self.pos()[0]])[0])
-        self.h1.setToolTip(setTicksLabels([self.pos()[0] + self.size()[0]])[0])
-
-    def center(self):
-        return QPointF(self.pos().x() + self.size().x() / 2, self.pos().y() + self.size().y() / 2)
-
-    def emit_index_signal(self):
-        self.index_signal.emit(self.index)
-
-
-class GanttTask(QObject):
-    alpha = 255
-
-    def __init__(self, task_dict):
-        super().__init__()
-
-        self.task_dict = task_dict  # taskdict=dict(name=  ,idnumber=  ,task_type=int(0 to 12), time_start=, time_end=)
-        qc = cmap.mapToQColor(task_dict['task_type'] / 12)
-        qc.setAlpha(self.alpha)
-        self.roi_item = GanttROI(task_dict['name'], task_dict['idnumber'], start=task_dict['time_start'],
-                                 stop=task_dict['time_end'], brush=qc)
-        self.roi_item.sigRegionChangeFinished.connect(self.show_hide_move_text())
-        self.roi_item.setZValue(-1000)
-        self.text_item = pg.TextItem(task_dict['name'])
-        self.text_item.setPos(task_dict['time_start'], task_dict['idnumber'])
-        self.roi_item.setZValue(-500)
-
-    def show_hide_move_text(self):
-        pass
-
-
-class GanttChart(QObject):
-    def __init__(self):
-        super().__init__()
-        self.setupUI()
-        self.tasks = []
-
-    def setupUI(self):
-        axis = AxisItemDate(orientation='bottom')
-        axis_top = AxisItemDate(orientation='top')
-
-        self.widget = ImageWidget(axisItems=dict(bottom=axis, top=axis_top))
-        self.widget.plotitem.showAxis('top')
-        self.widget.plotitem.vb.setAspectLocked(lock=False)
-        self.widget.view.invertY(True)
-        self.widget.view.setLimits(yMin=0)
-
-    def add_task(self, task_dict):
-        self.tasks.append(GanttTask(task_dict))
-        self.widget.plotItem.addItem(self.tasks[-1].roi_item)
-        self.widget.plotItem.addItem(self.tasks[-1].text_item)
-
-
-# # create GUI
-if __name__ == '__main__':
-    app = QtWidgets.QApplication(sys.argv)
-    gchart = GanttChart()
-    gchart.widget.show()
-
-    gchart.add_task(
-        dict(name='This is task 1, the best of all the tasks!yeeah baby', idnumber=1, task_type=1, time_start=5,
-             time_end=7))
-
-    sys.exit(app.exec_())

pymodaq/utils/plotting/image_viewer.py

@@ -1,97 +0,0 @@
-from qtpy import QtCore, QtGui, QtWidgets
-
-
-class Image_Viewer(QtWidgets.QGraphicsView):
-    def __init__(self, parent):
-        super(Image_Viewer, self).__init__(parent)
-        self._zoom = 0
-        self._scene = QtWidgets.QGraphicsScene(self)
-        self._image = QtWidgets.QGraphicsPixmapItem()
-        self._scene.addItem(self._image)
-        self.setScene(self._scene)
-        self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
-        self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
-
-        self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
-        self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(30, 30, 30)))
-        self.setFrameShape(QtWidgets.QFrame.NoFrame)
-
-    def fitInView(self):
-        rect = QtCore.QRectF(self._image.pixmap().rect())
-        if not rect.isNull():
-            unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1))
-            self.scale(1 / unity.width(), 1 / unity.height())
-            viewrect = self.viewport().rect()
-            scenerect = self.transform().mapRect(rect)
-            factor = min(viewrect.width() / scenerect.width(),
-                         viewrect.height() / scenerect.height())
-            self.scale(factor, factor)
-            self.centerOn(rect.center())
-            self._zoom = 0
-
-    def setPhoto(self, pixmap=None):
-        self._zoom = 0
-        if pixmap and not pixmap.isNull():
-            self.setDragMode(QtWidgets.QGraphicsView.ScrollHandDrag)
-            self._image.setPixmap(pixmap)
-            # self.fitInView()
-        else:
-            self.setDragMode(QtWidgets.QGraphicsView.NoDrag)
-            self._image.setPixmap(QtGui.QPixmap())
-
-    def zoomFactor(self):
-        return self._zoom
-
-    def wheelEvent(self, event):
-        try:
-            if not self._image.pixmap().isNull():
-                # delta=QtCore.QPoint()
-                # delta.y
-                if event.angleDelta().y() > 0:
-                    factor = 1.25
-                    self._zoom += 1
-                else:
-                    factor = 0.8
-                    self._zoom -= 1
-                if self._zoom > 0:
-                    self.scale(factor, factor)
-                elif self._zoom == 0:
-                    self.fitInView()
-                else:
-                    self._zoom = 0
-        except Exception as e:
-            pass
-
-
-class Window(QtWidgets.QWidget):
-    def __init__(self):
-        super(Window, self).__init__()
-        self.viewer = Image_Viewer(self)
-        self.edit = QtWidgets.QLineEdit(self)
-        self.edit.setReadOnly(True)
-        self.button = QtWidgets.QToolButton(self)
-        self.button.setText('...')
-        self.button.clicked.connect(self.handleOpen)
-        layout = QtWidgets.QGridLayout(self)
-        layout.addWidget(self.viewer, 0, 0, 1, 2)
-        layout.addWidget(self.edit, 1, 0, 1, 1)
-        layout.addWidget(self.button, 1, 1, 1, 1)
-
-    def handleOpen(self):
-        path = QtWidgets.QFileDialog.getOpenFileName(
-            self, 'Choose Image', self.edit.text())
-        path = path[0]
-        if path:
-            self.edit.setText(path)
-            self.viewer.setPhoto(QtGui.QPixmap(path))
-
-
-if __name__ == '__main__':
-    import sys
-
-    app = QtWidgets.QApplication(sys.argv)
-    window = Window()
-    window.setGeometry(500, 300, 800, 600)
-    window.show()
-    sys.exit(app.exec_())

pymodaq/utils/plotting/items/axis_scaled.py

@@ -1,93 +0,0 @@
-import pyqtgraph as pg
-
-from  pymodaq.utils.data import Axis
-from pymodaq.utils import daq_utils as utils
-
-AXIS_POSITIONS = ['top', 'bottom', 'right', 'left']
-
-
-class AxisItem_Scaled(pg.AxisItem):
-    """
-    Subclass of pg.AxisItem enabling scaling of the tick values with respect to the linked viewbox
-    """
-
-    def __init__(self, *args, scaling=1, offset=0, **kwargs):
-        """
-        ==============  ===============================================================
-        **Arguments:**
-        orientation     one of 'left', 'right', 'top', or 'bottom'
-        scaling         multiplicative coeff applied to the ticks
-        offset          offset applied to the ticks after scaling
-        maxTickLength   (px) maximum length of ticks to draw. Negative values draw
-                        into the plot, positive values draw outward.
-        linkView        (ViewBox) causes the range of values displayed in the axis
-                        to be linked to the visible range of a ViewBox.
-        showValues      (bool) Whether to display values adjacent to ticks
-        pen             (QPen) Pen used when drawing ticks.
-        ==============  ===============================================================
-        """
-        super().__init__(*args, **kwargs)
-        self._scaling = scaling
-        self._offset = offset
-
-    def axis_data(self, Npts):
-        return utils.linspace_step_N(self.axis_offset, self.axis_scaling, Npts)
-
-    def set_scaling_and_label(self, axis_info: Axis):
-        self.setLabel(axis_info.label, axis_info.units)
-        self.axis_offset = axis_info.offset
-        self.axis_scaling = axis_info.scaling
-
-    @property
-    def axis_label(self):
-        return self.labelText
-
-    @axis_label.setter
-    def axis_label(self, label: str):
-        self.setLabel(text=label, units=self.axis_units)
-
-    @property
-    def axis_units(self):
-        return self.labelUnits
-
-    @axis_units.setter
-    def axis_units(self, units: str):
-        self.setLabel(text=self.axis_label, units=units)
-
-    @property
-    def axis_scaling(self):
-        return self._scaling
-
-    @axis_scaling.setter
-    def axis_scaling(self, scaling_factor=1):
-        self._scaling = scaling_factor
-        self.linkedViewChanged()
-
-    @property
-    def axis_offset(self):
-        return self._offset
-
-    @axis_offset.setter
-    def axis_offset(self, offset=0):
-        self._offset = offset
-        self.linkedViewChanged()
-
-    def linkedViewChanged(self, view=None, newRange=None):
-        if view is None:
-            if self.linkedView() is not None:
-                view = self.linkedView()
-            else:
-                return
-
-        if self.orientation in ['right', 'left']:
-            if newRange is None:
-                newRange = [pos * self._scaling + self._offset for pos in view.viewRange()[1]]
-            else:
-                newRange = [pos * self._scaling + self._offset for pos in newRange]
-        else:
-            if newRange is None:
-                newRange = [pos * self._scaling + self._offset for pos in view.viewRange()[0]]
-            else:
-                newRange = [pos * self._scaling + self._offset for pos in newRange]
-
-        super().linkedViewChanged(view, newRange=newRange)

pymodaq/utils/plotting/items/crosshair.py

@@ -1,94 +0,0 @@
-import os
-import numpy as np
-from qtpy import QtCore, QtGui
-from qtpy.QtCore import Signal
-import pyqtgraph as pg
-import numpy as np
-
-
-class Crosshair(pg.GraphicsObject):
-    crosshair_dragged = Signal(float, float, name='crosshair_dragged')
-    # signal used to pass crosshair position to other methods
-
-    def __init__(self, plotitem, orientation='both', pen=None):
-        super().__init__()
-        
-        if hasattr(plotitem, 'plotitem'):
-            # in case one pass a plot or image widget
-            self.plotitem = plotitem.plotitem
-        else:
-            self.plotitem = plotitem
-
-        # self.crosshair_dragged[float,float].connect(self.print_pos) #exemple on how to use the crosshair_dragged signal
-        if orientation == 'both':
-            self.vline_visible = True
-            self.hline_visible = True
-        elif orientation == 'vertical':
-            self.vline_visible = True
-            self.hline_visible = False
-        else:
-            self.vline_visible = False
-            self.hline_visible = True
-
-        self.vLine = pg.InfiniteLine(angle=90, movable=True, pen=pen)
-        self.hLine = pg.InfiniteLine(angle=0, movable=True, pen=pen)
-
-        self.plotitem.addItem(self.vLine, ignoreBounds=True)
-        self.plotitem.addItem(self.hLine, ignoreBounds=True)
-
-        self.vLine.sigDragged.connect(self.update_hline)
-        self.hLine.sigDragged.connect(self.update_vline)
-
-    def show_hide_crosshair(self):
-        if self.vline_visible:
-            self.vLine.show()
-        else:
-            self.vLine.hide()
-        if self.hline_visible:
-            self.hLine.show()
-        else:
-            self.hLine.hide()
-
-    def set_crosshair_position(self, xpos=0, ypos=0):
-        self.vLine.setValue(xpos)
-        self.hLine.setValue(ypos)
-        self.crosshair_dragged.emit(xpos, ypos)
-
-    def update_hline(self):
-        self.hLine.sigDragged.disconnect(self.update_vline)
-        p = self.vLine.getYPos() - self.vLine.cursorOffset[1]
-        self.hLine.setPos(p)
-        self.hLine.sigDragged.connect(self.update_vline)
-        self.crosshair_dragged.emit(self.vLine.getXPos(), self.hLine.getYPos())
-
-    def get_positions(self):
-        return (self.vLine.getXPos(), self.hLine.getYPos())
-
-    def update_vline(self):
-        self.vLine.sigDragged.disconnect(self.update_hline)
-        p = self.hLine.getXPos() - self.hLine.cursorOffset[0]
-        self.vLine.setPos(p)
-        self.vLine.sigDragged.connect(self.update_hline)
-        self.crosshair_dragged.emit(self.vLine.getXPos(), self.hLine.getYPos())
-
-    def hide(self):
-        self.vLine.hide()
-        self.hLine.hide()
-
-    def show(self):
-        self.show_hide_crosshair()
-
-    def value(self):
-        """
-        value returns a tuple containing (x,y) positions of the crosshair
-        """
-        return (self.vLine.value(), self.hLine.value())
-
-    def setVisible(self, state):
-        self.hLine.setVisible(state)
-        self.vLine.setVisible(state)
-        if state:
-            self.show_hide_crosshair()
-
-    def isVisible(self):
-        return self.hLine.isVisible()