imagebaker 0.0.41__py3-none-any.whl → 0.0.48__py3-none-any.whl

imagebaker/list_views/__init__.py

@@ -0,0 +1,3 @@
+from .layer_list import LayerList  # noqa
+from .annotation_list import AnnotationList  # noqa
+from .layer_settings import LayerSettings  # noqa

imagebaker/list_views/annotation_list.py

@@ -0,0 +1,203 @@
+from PySide6.QtCore import QSize, Qt, Signal
+from PySide6.QtGui import (
+    QColor,
+    QPixmap,
+    QIcon,
+)
+from PySide6.QtWidgets import (
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QPushButton,
+    QLabel,
+    QSizePolicy,
+    QDockWidget,
+    QListWidget,
+    QListWidgetItem,
+)
+
+from imagebaker.layers.annotable_layer import AnnotableLayer
+from imagebaker import logger
+
+
+class AnnotationList(QDockWidget):
+    messageSignal = Signal(str)
+
+    def __init__(self, layer: AnnotableLayer, parent=None):
+        super().__init__("Annotations", parent)
+        self.layer = layer
+        self.init_ui()
+
+    def init_ui(self):
+        logger.info("Initializing AnnotationList")
+        self.setMinimumWidth(150)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
+
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+        self.list_widget = QListWidget()
+
+        # Set the size policy for the list widget to expand dynamically
+        self.list_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        layout.addWidget(self.list_widget)
+        self.setWidget(widget)
+        self.setFeatures(
+            QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable
+        )
+
+    def update_list(self):
+        self.list_widget.clear()
+        if self.layer is None:
+            return
+        for idx, ann in enumerate(self.layer.annotations):
+            item = QListWidgetItem(self.list_widget)
+
+            # Create container widget
+            widget = QWidget()
+            widget.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
+
+            layout = QHBoxLayout(widget)
+            layout.setContentsMargins(1, 1, 2, 2)
+
+            # on clicking this element, select the annotation
+            widget.mousePressEvent = lambda event, i=idx: self.on_annotation_selected(i)
+
+            widget.setCursor(Qt.PointingHandCursor)
+
+            # Color indicator
+            color_label = QLabel()
+            color = QColor(ann.color)
+            if not ann.visible:
+                color.setAlpha(128)
+            pixmap = QPixmap(20, 20)
+            pixmap.fill(ann.color)
+            color_label.setPixmap(pixmap)
+            layout.addWidget(color_label)
+
+            # Text container
+            text_container = QWidget()
+            text_layout = QVBoxLayout(text_container)
+            text_layout.setContentsMargins(0, 0, 0, 0)
+
+            # Main label with conditional color
+            main_label = QLabel(f"{ann.name}")
+            main_color = "#666" if not ann.visible else "black"
+            main_label.setStyleSheet(f"font-weight: bold; color: {main_color};")
+            text_layout.addWidget(main_label)
+
+            # Change the text color of the selected annotation
+            if ann.selected:
+                main_label.setStyleSheet("font-weight: bold; color: blue;")
+            else:
+                main_label.setStyleSheet(f"font-weight: bold; color: {main_color};")
+
+            # Secondary info
+            secondary_text = []
+            score_text = (
+                f"{ann.annotator}: {ann.score:.2f}"
+                if ann.score is not None
+                else ann.annotator
+            )
+            secondary_text.append(score_text)
+            short_path = ann.file_path.stem
+            secondary_text.append(f"<span style='color:#666;'>{short_path}</span>")
+
+            if secondary_text:
+                info_color = "#888" if not ann.visible else "#444"
+                info_label = QLabel("<br>".join(secondary_text))
+                info_label.setStyleSheet(f"color: {info_color}; font-size: 10px;")
+                text_layout.addWidget(info_label)
+
+            text_layout.addStretch()
+            layout.addWidget(text_container)
+            layout.addStretch()
+
+            # Buttons
+            btn_container = QWidget()
+            btn_layout = QHBoxLayout(btn_container)
+
+            layerify_btn = QPushButton("🖨")
+            layerify_btn.setFixedWidth(30)
+            layerify_btn.setToolTip("Make AnnotableLayer from annotation")
+            layerify_btn.clicked.connect(lambda _, i=idx: self.layerify_annotation(i))
+            btn_layout.addWidget(layerify_btn)
+
+            vis_btn = QPushButton("👀" if ann.visible else "👁️")
+            vis_btn.setFixedWidth(30)
+            vis_btn.setCheckable(True)
+            vis_btn.setChecked(ann.visible)
+            vis_btn.setToolTip("Visible" if ann.visible else "Hidden")
+            vis_btn.clicked.connect(lambda _, i=idx: self.toggle_visibility(i))
+            btn_layout.addWidget(vis_btn)
+
+            del_btn = QPushButton("🗑️")
+            del_btn.setFixedWidth(30)
+            del_btn.setToolTip("Delete annotation")
+            del_btn.clicked.connect(lambda _, i=idx: self.delete_annotation(i))
+            btn_layout.addWidget(del_btn)
+
+            layout.addWidget(btn_container)
+
+            item.setSizeHint(widget.sizeHint())
+            self.list_widget.setItemWidget(item, widget)
+        self.update()
+
+    def create_color_icon(self, color):
+        pixmap = QPixmap(16, 16)
+        pixmap.fill(color)
+        return QIcon(pixmap)
+
+    def on_annotation_selected(self, index):
+        if 0 <= index < len(self.layer.annotations):
+            ann = self.layer.annotations[index]
+            ann.selected = not ann.selected
+            # Set other annotations to not selected
+            for i, a in enumerate(self.layer.annotations):
+                if i != index:
+                    a.selected = False
+            self.layer.update()
+            self.update_list()
+
+    def delete_annotation(self, index):
+        if 0 <= index < len(self.layer.annotations):
+            logger.info(f"Deleting annotation: {self.layer.annotations[index].label}")
+            del self.layer.annotations[index]
+            self.layer.update()
+            self.update_list()
+            logger.info("Annotation deleted")
+
+    def toggle_visibility(self, index):
+        if 0 <= index < len(self.layer.annotations):
+            ann = self.layer.annotations[index]
+            ann.visible = not ann.visible
+            self.layer.update()
+            self.update_list()
+            logger.info(f"Annotation visibility toggled: {ann.label}, {ann.visible}")
+
+    def layerify_annotation(self, index):
+        if 0 <= index < len(self.layer.annotations):
+            ann = self.layer.annotations[index]
+            logger.info(f"Layerifying annotation: {ann.label}")
+
+            self.update_list()
+            self.layer.layerify_annotation([ann])
+            self.layer.update()
+
+    def sizeHint(self):
+        """Calculate the preferred size based on the content."""
+        base_size = super().sizeHint()
+        content_width = self.list_widget.sizeHintForColumn(0) + 40  # Add padding
+        return QSize(max(base_size.width(), content_width), base_size.height())
+
+    def keyPressEvent(self, event):
+        key = event.key()
+        logger.info(f"Key pressed in AnnotationList: {key}")
+        if event.key() == Qt.Key_C and event.modifiers() == Qt.ControlModifier:
+            self.layer.copy_annotation()
+        elif event.key() == Qt.Key_V and event.modifiers() == Qt.ControlModifier:
+            self.layer.paste_annotation()
+        elif event.key() == Qt.Key_Delete:
+            self.delete_annotation(self.layer.selected_annotation_index)
+        else:
+            self.parentWidget().keyPressEvent(event)

imagebaker/list_views/canvas_list.py

@@ -0,0 +1,185 @@
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QPushButton,
+    QLabel,
+    QSizePolicy,
+    QDockWidget,
+    QListWidget,
+    QListWidgetItem,
+    QInputDialog,
+)
+from functools import partial
+from imagebaker.layers.canvas_layer import CanvasLayer
+from imagebaker import logger
+
+
+class CanvasList(QDockWidget):
+    canvasSelected = Signal(CanvasLayer)
+    canvasDeleted = Signal(CanvasLayer)
+    canvasAdded = Signal(CanvasLayer)
+
+    def __init__(self, canvases: list[CanvasLayer], parent=None):
+        """
+        :param canvases: List of CanvasLayer objects to display.
+        """
+        super().__init__("Canvas List", parent)
+        self.canvases = canvases
+        self.current_page = 0
+        self.canvases_per_page = 10
+        self.init_ui()
+
+    def init_ui(self):
+        """Initialize the UI for the canvas list panel."""
+        logger.info("Initializing CanvasList")
+        self.setMinimumWidth(150)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
+
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+
+        # Add "Create New Canvas" button
+        self.create_canvas_button = QPushButton("Create New Canvas")
+        self.create_canvas_button.clicked.connect(self.create_new_canvas)
+        layout.addWidget(self.create_canvas_button)
+
+        # Canvas list widget
+        self.list_widget = QListWidget()
+        self.list_widget.itemClicked.connect(self.handle_item_clicked)
+        layout.addWidget(self.list_widget)
+        # set first item as selected
+        if len(self.canvases) > 0:
+            self.list_widget.setCurrentRow(0)
+
+        # Pagination controls
+        pagination_layout = QHBoxLayout()
+        self.prev_page_btn = QPushButton("Prev")
+        self.prev_page_btn.clicked.connect(self.show_prev_page)
+        self.next_page_btn = QPushButton("Next")
+        self.next_page_btn.clicked.connect(self.show_next_page)
+        pagination_layout.addWidget(self.prev_page_btn)
+        pagination_layout.addWidget(self.next_page_btn)
+        layout.addLayout(pagination_layout)
+
+        # Pagination info
+        self.pagination_label = QLabel("Showing 0 of 0")
+        layout.addWidget(self.pagination_label)
+
+        self.setWidget(widget)
+        self.setFeatures(
+            QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable
+        )
+
+        self.update_canvas_list()
+
+    def create_new_canvas(self):
+        """Create a new canvas and emit the canvasAdded signal."""
+        canvas_idx = len(self.canvases) + 1
+        default_name = f"Canvas {canvas_idx}"
+
+        # Show input dialog to ask for canvas name
+        canvas_name, ok = QInputDialog.getText(
+            self, "New Canvas", "Enter canvas name:", text=default_name
+        )
+
+        # If the user cancels or provides an empty name, use the default name
+        if not ok or not canvas_name.strip():
+            canvas_name = default_name
+
+        # Create the new canvas
+        new_canvas = CanvasLayer(parent=self.parent())
+        new_canvas.layer_name = canvas_name  # Assign the name to the canvas
+        self.canvases.append(new_canvas)  # Add the new canvas to the list
+        self.canvasAdded.emit(
+            new_canvas
+        )  # Emit the signal to notify about the new canvas
+        self.update_canvas_list()  # Refresh the canvas list
+
+    def show_next_page(self):
+        """Show the next page of canvases."""
+        if (self.current_page + 1) * self.canvases_per_page < len(self.canvases):
+            self.current_page += 1
+            self.update_canvas_list()
+
+    def show_prev_page(self):
+        """Show the previous page of canvases."""
+        if self.current_page > 0:
+            self.current_page -= 1
+            self.update_canvas_list()
+
+    def update_canvas_list(self):
+        """Update the canvas list with pagination."""
+        self.list_widget.clear()
+
+        canvases_list = list(self.canvases)
+
+        start_idx = self.current_page * self.canvases_per_page
+        end_idx = min(start_idx + self.canvases_per_page, len(canvases_list))
+
+        for idx, canvas in enumerate(canvases_list[start_idx:end_idx], start=start_idx):
+            item_widget = QWidget()
+            item_layout = QHBoxLayout(item_widget)
+            item_layout.setContentsMargins(5, 5, 5, 5)
+
+            # Thumbnail
+            thumbnail_label = QLabel()
+            thumbnail_pixmap = canvas.get_thumbnail().scaled(
+                50, 50, Qt.KeepAspectRatio, Qt.SmoothTransformation
+            )
+            thumbnail_label.setPixmap(thumbnail_pixmap)
+            item_layout.addWidget(thumbnail_label)
+
+            # Canvas name
+            canvas_name = getattr(canvas, "layer_name", f"Canvas {idx + 1}")
+            name_label = QLabel(canvas_name)
+            name_label.setStyleSheet("font-weight: bold;")
+            item_layout.addWidget(name_label)
+
+            # Delete button
+            delete_button = QPushButton("Delete")
+            delete_button.setStyleSheet(
+                "background-color: red; color: white; font-weight: bold;"
+            )
+            delete_button.clicked.connect(partial(self.delete_canvas, canvas))
+            item_layout.addWidget(delete_button)
+
+            item_layout.addStretch()
+
+            # Add the custom widget to the list
+            list_item = QListWidgetItem(self.list_widget)
+            list_item.setSizeHint(item_widget.sizeHint())
+            self.list_widget.addItem(list_item)
+            self.list_widget.setItemWidget(list_item, item_widget)
+
+            # Store metadata for the canvas
+            list_item.setData(Qt.UserRole, canvas)
+
+        # Select the first item by default if it exists
+        if self.list_widget.count() > 0:
+            self.list_widget.setCurrentRow(0)
+            first_item = self.list_widget.item(0)
+            self.handle_item_clicked(first_item)
+
+        self.pagination_label.setText(
+            f"Showing {start_idx + 1} to {end_idx} of {len(canvases_list)}"
+        )
+        self.update()
+
+    def handle_item_clicked(self, item: QListWidgetItem):
+        """Handle item click and emit the canvasSelected signal."""
+        canvas = item.data(Qt.UserRole)
+        if canvas:
+            self.canvasSelected.emit(canvas)
+
+    def delete_canvas(self, canvas: CanvasLayer):
+        """Delete a canvas from the list."""
+        if canvas in self.canvases:
+            canvas.layers.clear()
+            logger.info(f"Deleting canvas: {canvas.layer_name}")
+            canvas.setVisible(False)
+            canvas.deleteLater()
+            self.canvases.remove(canvas)
+            self.canvasDeleted.emit(canvas)
+            self.update_canvas_list()

imagebaker/list_views/image_list.py

@@ -0,0 +1,138 @@
+from imagebaker import logger
+
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import (
+    QWidget,
+    QVBoxLayout,
+    QHBoxLayout,
+    QPushButton,
+    QLabel,
+    QSizePolicy,
+    QDockWidget,
+    QListWidget,
+    QListWidgetItem,
+)
+from pathlib import Path
+
+
+class ImageListPanel(QDockWidget):
+    imageSelected = Signal(Path)
+
+    def __init__(
+        self,
+        image_entries: list["ImageEntry"],
+        processed_images: set[Path],
+        parent=None,
+    ):
+        """
+        :param image_entries: List of image paths to display.
+        :param processed_images: Set of image paths that have already been processed.
+        """
+        super().__init__("Image List", parent)
+        self.image_entries: list["ImageEntry"] = image_entries
+        self.processed_images = processed_images
+        self.current_page = 0
+        self.images_per_page = 10
+        self.init_ui()
+
+    def init_ui(self):
+        """Initialize the UI for the image list panel."""
+        logger.info("Initializing ImageListPanel")
+        self.setMinimumWidth(150)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
+
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+
+        # Image list widget
+        self.list_widget = QListWidget()
+        self.list_widget.itemClicked.connect(self.handle_item_clicked)  # Connect signal
+        layout.addWidget(self.list_widget)
+
+        # Pagination controls
+        pagination_layout = QHBoxLayout()
+        self.prev_page_btn = QPushButton("Prev")
+        self.prev_page_btn.clicked.connect(self.show_prev_page)
+        self.next_page_btn = QPushButton("Next")
+        self.next_page_btn.clicked.connect(self.show_next_page)
+        pagination_layout.addWidget(self.prev_page_btn)
+        pagination_layout.addWidget(self.next_page_btn)
+        layout.addLayout(pagination_layout)
+
+        # Pagination info
+        self.pagination_label = QLabel("Showing 0 of 0")
+        layout.addWidget(self.pagination_label)
+
+        self.setWidget(widget)
+        self.setFeatures(
+            QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable
+        )
+
+        self.update_image_list(self.image_entries)
+
+    def show_next_page(self):
+        """Show the next page of images"""
+        if (self.current_page + 1) * self.images_per_page < len(self.image_entries):
+            self.current_page += 1
+            self.update_image_list(self.image_entries)
+
+    def show_prev_page(self):
+        """Show the previous page of images"""
+        if self.current_page > 0:
+            self.current_page -= 1
+            self.update_image_list(self.image_entries)
+
+    def update_image_list(self, image_entries):
+        """Update the image list with image paths and baked results."""
+        self.list_widget.clear()
+
+        for idx, image_entry in enumerate(image_entries):
+            item_widget = QWidget()
+            item_layout = QHBoxLayout(item_widget)
+            item_layout.setContentsMargins(5, 5, 5, 5)
+
+            # Generate thumbnail
+            thumbnail_label = QLabel()
+            if image_entry.is_baked_result:
+                thumbnail_pixmap = (
+                    image_entry.data.get_thumbnail()
+                )  # Baked result thumbnail
+                name_label_text = f"Baked Result {idx + 1}"
+            else:
+                thumbnail_pixmap = QPixmap(str(image_entry.data)).scaled(
+                    50, 50, Qt.KeepAspectRatio, Qt.SmoothTransformation
+                )
+                name_label_text = Path(image_entry.data).name
+
+            thumbnail_label.setPixmap(thumbnail_pixmap)
+            item_layout.addWidget(thumbnail_label)
+
+            # Text for image
+            name_label = QLabel(name_label_text)
+            name_label.setStyleSheet("font-weight: bold;")
+            item_layout.addWidget(name_label)
+
+            item_layout.addStretch()
+
+            # Add the custom widget to the list
+            list_item = QListWidgetItem(self.list_widget)
+            list_item.setSizeHint(item_widget.sizeHint())
+            self.list_widget.addItem(list_item)
+            self.list_widget.setItemWidget(list_item, item_widget)
+
+            # Store metadata for the image
+            list_item.setData(Qt.UserRole, image_entry)
+        self.pagination_label.setText(
+            f"Showing {self.current_page * self.images_per_page + 1} to "
+            f"{min((self.current_page + 1) * self.images_per_page, len(image_entries))} "
+            f"of {len(image_entries)}"
+        )
+        self.update()
+
+    def handle_item_clicked(self, item: QListWidgetItem):
+        """Handle item click and emit the imageSelected signal."""
+        item_data = item.data(Qt.UserRole)
+        if item_data:
+            self.imageSelected.emit(item_data)