myokit 1.35.0__py3-none-any.whl → 1.35.2__py3-none-any.whl

myokit/gui/datablock_viewer.py

@@ -28,7 +28,7 @@ SETTINGS_FILE = os.path.join(myokit.DIR_USER, 'DataBlockViewer.ini')
 N_RECENT_FILES = 5
 
 # About
-ABOUT = '<h1>' + TITLE + '</h1>' + """
+ABOUT = f'<h1>{TITLE}</h1>' + f"""
 <p>
     Myokit's DataBlock viewer is a utility to examine
     <code>DataBlock1d</code> and <code>DataBlock2d</code> objects
@@ -42,10 +42,10 @@ ABOUT = '<h1>' + TITLE + '</h1>' + """
 </p>
 <p>
     System info:
-    <br />Python: PYTHON
-    <br />Using the BACKEND GUI backend.
+    <br />Python: {sys.version}
+    <br />Using the {myokit.gui.backend} GUI backend.
 </p>
-""".replace('BACKEND', myokit.gui.backend).replace('PYTHON', sys.version)
+"""
 
 # License
 LICENSE = myokit.LICENSE_HTML
@@ -194,7 +194,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         # Variable selection
         self._variable_select = QtWidgets.QComboBox()
         self._variable_select.activated.connect(self.event_variable_selected)
-        self._variable_select.setMinimumWidth(120)
+        self._variable_select.setMinimumWidth(160)
 
         # Colormap selection
         self._colormap = next(iter(myokit.ColorMap.names()))
@@ -204,6 +204,26 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         self._colormap_select.activated.connect(self.event_colormap_selected)
         self._colormap_select.setMinimumWidth(120)
 
+        self._colormap_lower_label = QtWidgets.QLabel('Range')
+        self._colormap_lower_label.setMaximumWidth(50)
+        self._colormap_lower_label.setAlignment(
+            Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        self._colormap_lower_field = AutoFloatField()
+        self._colormap_lower_field.setMaxLength(6)
+        self._colormap_lower_field.setMaximumWidth(80)
+        self._colormap_lower_field.editingFinished.connect(
+            self.event_variable_selected)
+
+        self._colormap_upper_label = QtWidgets.QLabel('to')
+        self._colormap_upper_label.setMaximumWidth(20)
+        self._colormap_upper_label.setAlignment(
+            Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter)
+        self._colormap_upper_field = AutoFloatField()
+        self._colormap_upper_field.setMaxLength(6)
+        self._colormap_upper_field.setMaximumWidth(80)
+        self._colormap_upper_field.editingFinished.connect(
+            self.event_variable_selected)
+
         # Control layout
         self._control_layout = QtWidgets.QHBoxLayout()
         self._control_layout.addWidget(self._play_button)
@@ -216,6 +236,10 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         self._control_layout.addWidget(self._graph_clear_button)
         self._control_layout.addWidget(self._variable_select)
         self._control_layout.addWidget(self._colormap_select)
+        self._control_layout.addWidget(self._colormap_lower_label)
+        self._control_layout.addWidget(self._colormap_lower_field)
+        self._control_layout.addWidget(self._colormap_upper_label)
+        self._control_layout.addWidget(self._colormap_upper_field)
 
         # Graph area
         self._graph_area = GraphArea()
@@ -256,8 +280,8 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         self.update_window_title()
 
         # Set controls to correct values
-        self._colormap_select.setCurrentIndex(self._colormap_select.findText(
-            self._colormap))
+        self._colormap_select.setCurrentIndex(
+            self._colormap_select.findText(self._colormap))
         self._rate_field.setText(str(self._timer_interval))
         self._timer.setInterval(self._timer_interval)
 
@@ -297,20 +321,21 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
                 self._timer.start()
 
     def action_extract_colormap_image(self):
-        """
-        Extracts the current colormap to an image file.
-        """
+        """ Extracts the current colormap to an image file. """
+
         if self._data is None:
             QtWidgets.QMessageBox.warning(
                 self, TITLE,
                 '<h1>No data to export.</h1>'
                 '<p>Please open a data file first.</p>')
             return
+
         fname = QtWidgets.QFileDialog.getSaveFileName(
             self,
             'Extract colormap to image file',
             self._path,
             filter=FILTER_IMG)[0]
+
         if fname:
             fname = str(fname)
             ext = os.path.splitext(fname)[1][1:].upper()
@@ -318,22 +343,28 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
                 QtWidgets.QMessageBox.warning(
                     self, TITLE,
                     '<h1>Image type not recognized.</h1>'
-                    '<p>Unknown image type "' + str(ext) + '".</p>')
+                    f'<p>Unknown image type "{ext}".</p>')
                 return
-            # Get min and max of data
-            data = self._data.get2d(self._variable)
-            lower = np.min(data)
-            upper = np.max(data)
+
             # Create image
             nx = 200
             ny = 800
             image = myokit.ColorMap.image(self._colormap, nx, ny)
             image = QtGui.QImage(
                 image, nx, ny, QtGui.QImage.Format.Format_ARGB32)
+
+            # Add lower and upper bounds
+            lower = self._colormap_lower_field.value()
+            upper = self._colormap_upper_field.value()
+            if lower is None or upper is None:
+                data = self._data.get2d(self._variable)
+                lower = np.min(data) if lower is None else lower
+                upper = np.max(data) if upper is None else upper
             painter = QtGui.QPainter(image)
             painter.drawText(10, 15, str(upper))
             painter.drawText(10, ny - 5, str(lower))
             painter.end()
+
             # Save
             image.save(fname, ext)
 
@@ -379,7 +410,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
                 QtWidgets.QMessageBox.warning(
                     self, TITLE,
                     '<h1>Image type not recognized.</h1>'
-                    '<p>Unknown image type "' + str(ext) + '".</p>')
+                    f'<p>Unknown image type "{ext}".</p>')
                 return
             nt, ny, nx = self._data.shape()
             image = self._video_frames[self._video_iframe]
@@ -474,17 +505,23 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
     def action_set_colormap(self, name):
         """
         Loads the ColorMap specified by ``name``.
+
+        If data is loaded, this will also call :meth:`action_set_variable` to
+        update the video frames.
         """
         name = str(name)
         if not myokit.ColorMap.exists(name):
             return  # Silent return?
+
         # Set colormap
         self._colormap = name
+
         # Update colormap controls
-        self._colormap_select.setCurrentIndex(self._colormap_select.findText(
-            self._colormap))
+        self._colormap_select.setCurrentIndex(
+            self._colormap_select.findText(self._colormap))
+
+        # Update colorbar
         if self._data is not None:
-            # Update colorbar
             nx = self._colorbar_width
             ny = self._colorbar_height
             image = myokit.ColorMap.image(self._colormap, nx, ny)
@@ -497,21 +534,31 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
     def action_set_variable(self, var):
         """
         Loads the variable specified by the name ``var`` into the main display.
+
+        This method is also responsible for converting the data into frames to
+        be displayed on the video widget.
         """
         if self._data is None:
             return
         self._variable = str(var)
-        self._variable_select.setCurrentIndex(self._variable_select.findText(
-            self._variable))
+        self._variable_select.setCurrentIndex(
+            self._variable_select.findText(self._variable))
         self.action_pause_timer()
         self._video_frames = self._data.images(
-            self._variable, colormap=self._colormap)
+            self._variable,
+            self._colormap,
+            self._colormap_lower_field.value(),
+            self._colormap_upper_field.value()
+        )
         self.action_set_frame(self._video_iframe)
         self.action_depause_timer()
 
     def action_set_frame(self, frame):
         """
         Move to a specific frame.
+
+        This method updates the display to show a video frame created by an
+        earlier call to :meth:`action_set_variable`.
         """
         # Check frame index
         nt, ny, nx = self._data.shape()
@@ -551,9 +598,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         self._play_button.setIcon(self._play_icon_play)
 
     def closeEvent(self, event=None):
-        """
-        Called when window is closed.)
-        """
+        # Called when window is closed.
         self.save_config()
         if event:
             event.accept()
@@ -630,18 +675,14 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         self._menu_help.addAction(self._tool_license)
 
     def display_exception(self):
-        """
-        Displays the last exception.
-        """
+        """ Displays the last exception in a messagebox. """
         QtWidgets.QMessageBox.warning(
             self, TITLE,
             '<h1>An error has occurred.</h1>'
-            '<pre>' + traceback.format_exc() + '</pre>')
+            f'<pre>{traceback.format_exc()}</pre>')
 
     def event_colormap_selected(self):
-        """
-        Colormap is selected by user.
-        """
+        """ Colormap is selected by user. """
         self.action_set_colormap(str(self._colormap_select.currentText()))
 
     def event_graph_mouse_move(self, x, y):
@@ -649,29 +690,21 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         Graph cursur moved: Display the current cursor position on the graph
         scene in the status bar.
         """
-        F = '{:< 1.6g}'
-        x, y = F.format(x), F.format(y)
-        self._label_cursor.setText('(' + x + ', ' + y + ')')
+        self._label_cursor.setText(f'({x:< 1.6g}, {y:< 1.6g})')
 
     def event_rate_changed(self, e=None):
-        """
-        User changed frame interval.
-        """
+        """ User changed frame interval. """
         self._timer_interval = int(self._rate_field.text())
         self._timer.setInterval(self._timer_interval)
 
     def event_variable_selected(self):
-        """
-        Variable is selected by user.
-        """
+        """ Variable is selected by user. """
         self._variable = self._variable_select.currentText()
         if self._data is not None:
             self.action_set_variable(self._variable)
 
     def event_video_single_click(self, x, y):
-        """
-        Video clicked: Add a graph at the location of the click
-        """
+        """ Video clicked: Add a graph at the location of the click. """
         self._graph_area.graph(self._variable, x, y)
 
     def event_video_double_click(self, x, y):
@@ -689,19 +722,16 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         # Cursor position is in scene coordinates, so already matches datablock
         # dimensions!
         if self._data is not None:
-            F = '{:< 1.6g}'
             try:
                 z = self._data.get2d(self._variable)[self._video_iframe, y, x]
-                z = F.format(z)
+                z = '{:< 1.6g}'.format(z)
             except IndexError:
                 z = '?'
-            x, y = F.format(x), F.format(y)
-            self._label_cursor.setText('(' + x + ', ' + y + ', ' + z + ')')
+            self._label_cursor.setText(f'({x:< 1.6g}, {y:< 1.6g}, {z}')
 
     def keyPressEvent(self, e):
-        """
-        Catch key presses?
-        """
+        # A key has been pressed
+
         if e.key() == Qt.Key.Key_Space:
             self.action_start_stop()
 
@@ -797,14 +827,16 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         try:
             data = myokit.DataBlock2d.load(fname, progress=reporter)
             del reporter
-        except myokit.DataBlockReadError:
+        except myokit.DataBlockReadError as e:
             pd.reset()
             self.statusBar().showMessage('Load failed.')
             QtWidgets.QMessageBox.warning(
                 self, TITLE,
                 '<h1>Unable to read file.</h1>'
-                '<p>The given filename <code>' + str(fname) + '</code>'
-                ' could not be read as a <code>myokit.DataBlock2d</code>.</p>')
+                f'<p>The given filename <code>{fname}</code>'
+                ' could not be read as a <code>myokit.DataBlock2d</code>.</p>'
+                f'<p>{e}</p>'
+            )
             return
         except Exception:
             pd.reset()
@@ -822,7 +854,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
             QtWidgets.QMessageBox.warning(
                 self, TITLE,
                 '<h1>Unable to read file.</h1>'
-                '<p>The given filename <code>' + str(fname) + '</code>'
+                f'<p>The given filename <code>{fname}</code>'
                 ' does not contain any 2d data.</p>')
             return
 
@@ -853,8 +885,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
 
         # Add empty video item to video scene
         self._video_pixmap = QtGui.QPixmap(nx, ny)
-        self._video_item = QtWidgets.QGraphicsPixmapItem(
-            self._video_pixmap)
+        self._video_item = QtWidgets.QGraphicsPixmapItem(self._video_pixmap)
         self._video_scene.addItem(self._video_item)
 
         # Update colormap scene
@@ -944,7 +975,7 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         """
         for k, fname in enumerate(self._recent_files):
             t = self._recent_file_tools[k]
-            t.setText(str(k + 1) + '. ' + os.path.basename(fname))
+            t.setText(f'{k + 1}. {os.path.basename(fname)}')
             t.setData(fname)
             t.setVisible(True)
         for i in range(len(self._recent_files), N_RECENT_FILES):
@@ -954,15 +985,22 @@ class DataBlockViewer(myokit.gui.MyokitApplication):
         """
         Sets this window's title based on the current state.
         """
-        title = TITLE + ' ' + myokit.__version__
+        title = f'{TITLE} {myokit.__version__}'
         if self._file:
-            title = os.path.basename(self._file) + ' - ' + title
+            title = f'{os.path.basename(self._file)} - {title}'
         self.setWindowTitle(title)
 
 
 class VideoScene(QtWidgets.QGraphicsScene):
     """
     Color data display scene.
+
+    Note that, despite the name, this item does not manage the conversion from
+    data to the image. The actual drawing happens by calling ``setPixmap`` on a
+    ``QGraphicsPixmapItem`` that gets added to this scene.
+
+    See :meth:`DataBlockViewer.action_set_variable()` and
+    :meth:`DataBlockViewer.action_set_frame()`.
     """
     # Signals
     # Somebody moved the mouse
@@ -984,11 +1022,9 @@ class VideoScene(QtWidgets.QGraphicsScene):
         self.resize(1, 1)
 
     def mousePressEvent(self, event):
-        """
-        Single-click
-        """
+        # Single-click event
         if event.button() == Qt.MouseButton.LeftButton:
-            if event.modifiers() == Qt.KeyBoardModifier.NoModifier:
+            if event.modifiers() == Qt.KeyboardModifier.NoModifier:
                 p = event.scenePos()
                 x, y = int(p.x()), int(p.y())
                 if x >= 0 and x < self._w and y >= 0 and y < self._h:
@@ -996,11 +1032,9 @@ class VideoScene(QtWidgets.QGraphicsScene):
                     return
 
     def mouseDoubleClickEvent(self, event):
-        """
-        Double-click
-        """
+        # Double-click event
         if event.button() == Qt.MouseButton.LeftButton:
-            if event.modifiers() == Qt.KeyBoardModifier.NoModifier:
+            if event.modifiers() == Qt.KeyboardModifier.NoModifier:
                 p = event.scenePos()
                 x, y = int(p.x()), int(p.y())
                 if x >= 0 and x < self._w and y >= 0 and y < self._h:
@@ -1008,17 +1042,13 @@ class VideoScene(QtWidgets.QGraphicsScene):
                     return
 
     def mouseMoveEvent(self, event):
-        """
-        Show mouse position in status bar
-        """
+        # The mouse has moved!
         p = event.scenePos()
         x, y = int(p.x()), int(p.y())
         self.mouse_moved.emit(x, y)
 
     def resize(self, w, h):
-        """
-        Resizes the scene to match the given dimensions.
-        """
+        """ Resize the scene to match the given dimensions. """
         self._w = float(w)
         self._h = float(h)
         self.setSceneRect(0, 0, self._w, self._h)
@@ -1081,9 +1111,8 @@ class VideoView(QtWidgets.QGraphicsView):
         self.centerOn(rect.center())
 
     def resizeEvent(self, event=None):
-        """
-        Called when the view is resized.
-        """
+        # Called when the view is resized.
+
         # Tell others a resize is happening
         # (This is used to pause the video playback)
         self.resize_event.emit()
@@ -1365,3 +1394,41 @@ class GraphArea(QtWidgets.QWidget):
         Tells Qt that this widget shout expand.
         """
         return QtCore.QSizePolicy.Expanding
+
+
+class AutoFloatField(QtWidgets.QLineEdit):
+    """
+    A QLineEdit that requires floats as input, but will show "(Auto)" when a
+    non-float is entered and return ``None`` as its value.
+    """
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Colors
+        self._color_ok = QtGui.QTextCharFormat().foreground().color().getRgb()
+        self._color_auto = (127, 127, 127)
+        self._auto_text = '(Auto)'
+
+        # Show text
+        self.editingFinished.connect(self._autofy)
+        self._autofy()
+
+    def _autofy(self):
+        """ Put (Auto) if not valid """
+        if self.value() is None:
+            self.setText(self._auto_text)
+            c = self._color_auto
+        else:
+            c = self._color_ok
+        self.setStyleSheet(f'color: rgb({c[0]}, {c[1]}, {c[2]})')
+
+    def focusInEvent(self, event):
+        super().focusInEvent(event)
+        QtCore.QTimer.singleShot(0, self.selectAll)
+
+    def value(self):
+        try:
+            return float(super().text())
+        except ValueError:
+            return None
+