GUI_draft_live.py

import sys
import math
import numpy as np

# For smoothing the path
from scipy.signal import savgol_filter

from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QGraphicsView, QGraphicsScene,
    QGraphicsEllipseItem, QGraphicsPixmapItem, QPushButton,
    QHBoxLayout, QVBoxLayout, QWidget, QFileDialog, QGraphicsTextItem,
    QSlider, QLabel, QCheckBox, QGridLayout, QSizePolicy
)
from PyQt5.QtGui import QPixmap, QPen, QBrush, QColor, QFont, QImage
from PyQt5.QtCore import Qt, QRectF, QSize

# live_wire.py must contain something like:
#   from skimage import exposure
#   from skimage.filters import gaussian
#   def preprocess_image(image, sigma=3, clip_limit=0.01): ...
#   def compute_cost_image(path, user_radius, sigma=3, clip_limit=0.01): ...
#   def find_path(cost_image, points): ...
#   ...
from live_wire import compute_cost_image, find_path, preprocess_image


# ------------------------------------------------------------------------
# A pan & zoom QGraphicsView
# ------------------------------------------------------------------------
class PanZoomGraphicsView(QGraphicsView):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setDragMode(QGraphicsView.NoDrag)  # We'll handle panning manually
        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
        self._panning = False
        self._pan_start = None

        # Let it expand in layouts
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)

    def wheelEvent(self, event):
        """ Zoom in/out with mouse wheel. """
        zoom_in_factor = 1.25
        zoom_out_factor = 1 / zoom_in_factor
        if event.angleDelta().y() > 0:
            self.scale(zoom_in_factor, zoom_in_factor)
        else:
            self.scale(zoom_out_factor, zoom_out_factor)
        event.accept()

    def mousePressEvent(self, event):
        """ If left button: Start panning (unless overridden). """
        if event.button() == Qt.LeftButton:
            self._panning = True
            self._pan_start = event.pos()
            self.setCursor(Qt.ClosedHandCursor)
        super().mousePressEvent(event)

    def mouseMoveEvent(self, event):
        """ If panning, translate the scene. """
        if self._panning and self._pan_start is not None:
            delta = event.pos() - self._pan_start
            self._pan_start = event.pos()
            self.translate(delta.x(), delta.y())
        super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        """ End panning. """
        if event.button() == Qt.LeftButton:
            self._panning = False
            self.setCursor(Qt.ArrowCursor)
        super().mouseReleaseEvent(event)


# ------------------------------------------------------------------------
# A specialized PanZoomGraphicsView for the circle editor
# ------------------------------------------------------------------------
class CircleEditorGraphicsView(PanZoomGraphicsView):
    def __init__(self, circle_editor_widget, parent=None):
        super().__init__(parent)
        self._circle_editor_widget = circle_editor_widget

    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            # Check if user clicked on the circle item
            clicked_item = self.itemAt(event.pos())
            if clicked_item is not None:
                # climb up parent chain
                it = clicked_item
                while it is not None and not hasattr(it, "boundingRect"):
                    it = it.parentItem()

                if isinstance(it, DraggableCircleItem):
                    # Let normal item-dragging occur, no pan
                    return QGraphicsView.mousePressEvent(self, event)
        super().mousePressEvent(event)

    def wheelEvent(self, event):
        """
        If the mouse is hovering over the circle, we adjust the circle's radius
        instead of zooming the image.
        """
        pos_in_widget = event.pos()
        item_under = self.itemAt(pos_in_widget)
        if item_under is not None:
            it = item_under
            while it is not None and not hasattr(it, "boundingRect"):
                it = it.parentItem()

            if isinstance(it, DraggableCircleItem):
                delta = event.angleDelta().y()
                step = 1 if delta > 0 else -1
                old_r = it.radius()
                new_r = max(1, old_r + step)
                it.set_radius(new_r)
                self._circle_editor_widget.update_slider_value(new_r)
                event.accept()
                return

        super().wheelEvent(event)


# ------------------------------------------------------------------------
# Draggable circle item (centered at (x, y) with radius)
# ------------------------------------------------------------------------
class DraggableCircleItem(QGraphicsEllipseItem):
    def __init__(self, x, y, radius=20, color=Qt.red, parent=None):
        super().__init__(0, 0, 2*radius, 2*radius, parent)
        self._r = radius

        pen = QPen(color)
        brush = QBrush(color)
        self.setPen(pen)
        self.setBrush(brush)

        # Enable item-based dragging
        self.setFlags(QGraphicsEllipseItem.ItemIsMovable |
                      QGraphicsEllipseItem.ItemIsSelectable |
                      QGraphicsEllipseItem.ItemSendsScenePositionChanges)

        # Position so that (x, y) is the center
        self.setPos(x - radius, y - radius)

    def set_radius(self, r):
        old_center = self.sceneBoundingRect().center()
        self._r = r
        self.setRect(0, 0, 2*r, 2*r)
        new_center = self.sceneBoundingRect().center()
        diff_x = old_center.x() - new_center.x()
        diff_y = old_center.y() - new_center.y()
        self.moveBy(diff_x, diff_y)

    def radius(self):
        return self._r


# ------------------------------------------------------------------------
# Circle editor widget with slider + done
# ------------------------------------------------------------------------
class CircleEditorWidget(QWidget):
    def __init__(self, pixmap, init_radius=20, done_callback=None, parent=None):
        super().__init__(parent)
        self._pixmap = pixmap
        self._done_callback = done_callback
        self._init_radius = init_radius

        layout = QVBoxLayout(self)
        self.setLayout(layout)

        #
        # 1) ADD A CENTERED LABEL ABOVE THE IMAGE, WITH BIGGER FONT
        #
        label_instructions = QLabel("Scale the dot to be of the size of your ridge")
        label_instructions.setAlignment(Qt.AlignCenter)
        big_font = QFont("Arial", 20)
        big_font.setBold(True)
        label_instructions.setFont(big_font)
        layout.addWidget(label_instructions)

        #
        # 2) THE SPECIALIZED GRAPHICS VIEW THAT SHOWS THE IMAGE
        #
        self._graphics_view = CircleEditorGraphicsView(circle_editor_widget=self)
        self._scene = QGraphicsScene(self)
        self._graphics_view.setScene(self._scene)
        layout.addWidget(self._graphics_view)

        # Show the image
        self._image_item = QGraphicsPixmapItem(self._pixmap)
        self._scene.addItem(self._image_item)

        # Put circle in center
        cx = self._pixmap.width() / 2
        cy = self._pixmap.height() / 2
        self._circle_item = DraggableCircleItem(cx, cy, radius=self._init_radius, color=Qt.red)
        self._scene.addItem(self._circle_item)

        # Fit in view
        self._graphics_view.setSceneRect(QRectF(self._pixmap.rect()))
        self._graphics_view.fitInView(self._image_item, Qt.KeepAspectRatio)