PyImageLabeling 1.0.0__py3-none-any.whl

PyImageLabeling/model/File/Files.py

@@ -0,0 +1,166 @@
+
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QFileDialog, QProgressDialog, QMessageBox
+from PyQt6.QtGui import QPixmap, QBitmap, QImage
+
+from PyImageLabeling.model.Core import Core, KEYWORD_SAVE_LABEL
+from PyImageLabeling.model.Utils import Utils
+
+
+import os
+
+        
+class Files(Core):
+    def __init__(self):
+        super().__init__() 
+
+    def set_view(self, view):
+        super().set_view(view)
+    
+    def select_image(self, path_image):
+        #remove all overlays#
+        #self.clear_all()
+        super().select_image(path_image)
+        
+    def save(self):
+        print("save")
+        if self.save_directory == "":
+            # Open a directory        
+            default_path = Utils.load_parameters()["save"]["path"]
+            
+            file_dialog = QFileDialog()
+            current_file_path = file_dialog.getExistingDirectory(
+                parent=self.view, 
+                caption="Save Folder", 
+                directory=default_path)
+            
+            if len(current_file_path) == 0: return
+
+            data = Utils.load_parameters()
+            data["save"]["path"] = current_file_path
+            Utils.save_parameters(data)
+            self.save_directory = current_file_path
+
+        super().save()
+
+    def load(self):
+        print("load")
+        default_path = Utils.load_parameters()["load"]["path"]
+        
+        file_dialog = QFileDialog()
+        current_file_path = file_dialog.getExistingDirectory(
+                parent=self.view, 
+                caption="Open Folder", 
+                directory=default_path)
+        
+        if len(current_file_path) == 0: return
+        current_file_path = current_file_path + os.sep
+        data = Utils.load_parameters()
+        data["load"]["path"] = os.path.dirname(current_file_path)
+        Utils.save_parameters(data)
+
+        # Update the model with the good images
+        # The model variables is update in this method: file_paths and image_items
+        print("current_file_path:", current_file_path)
+        current_files = [current_file_path+os.sep+f for f in os.listdir(current_file_path)]
+        current_files_to_add = []
+        print("current_files:", current_files)
+        labels_json = None
+        labels_images = []
+        for file in current_files:
+            print("file:", file)
+            if file in self.file_paths:
+                continue
+            if file.lower().endswith((".png", ".jpg", ".jpeg", ".gif")):
+                if KEYWORD_SAVE_LABEL in file:
+                    # It is a label file  
+                    labels_images.append(file)
+                else:
+                    # It is a image 
+                    print("file2:", file)
+                    self.file_paths.append(file)
+                    self.image_items[file] = None
+                    current_files_to_add.append(file)
+            elif file.endswith("labels.json"):
+                labels_json = file # Load it later 
+        self.view.file_bar_add(current_files_to_add)
+
+        # Activate previous and next buttons
+        for button_name in self.view.buttons_file_bar:
+            self.view.buttons_file_bar[button_name].setEnabled(True)
+
+        # Select the first item in the list if we have some images and no image selected
+        if self.view.file_bar_list.count() > 0 and self.view.file_bar_list.currentRow() == -1:
+            self.view.file_bar_list.setCurrentRow(0) 
+
+        if (len(labels_images) != 0 and labels_json is None) or \
+            (len(labels_images) == 0 and labels_json is not None):
+            self.controller.error_message("Load Error", "The labeling image or the `labels.json` file is missing !")
+            return 
+
+        if len(labels_images) == 0 and labels_json is None:
+            return
+
+        if labels_json is not None and self.get_edited():
+            msgBox = QMessageBox(self.view.zoomable_graphics_view)
+            msgBox.setWindowTitle("Load")
+            msgBox.setText("Are you sure you want to load the new labeling overview without save our previous works ?")
+            msgBox.setInformativeText("All previous works not saved will be reset.")
+            msgBox.setStandardButtons(QMessageBox.StandardButton.No | QMessageBox.StandardButton.Yes)
+            msgBox.setDefaultButton(QMessageBox.StandardButton.No)
+            msgBox.setModal(True)
+            result = msgBox.exec()
+
+            if result == QMessageBox.StandardButton.No:
+                return
+        
+        # Reset all labeling overview in the model
+        self.reset()
+        self.labeling_overview_was_loaded.clear()
+        self.labeling_overview_file_paths.clear()
+
+        # Reset the view
+        to_delete = []
+        for label_id in self.view.container_label_bar_temporary:
+            widget, separator = self.view.container_label_bar_temporary[label_id]
+            
+            widget.hide()
+            self.view.label_bar_layout.removeWidget(widget)
+            separator.hide()
+            self.view.label_bar_layout.removeWidget(separator)
+            
+            # Clean up the view dictionaries
+            to_delete.append(label_id)
+            if label_id in self.view.buttons_label_bar_temporary:
+                del self.view.buttons_label_bar_temporary[label_id]
+        
+        for label_id in to_delete:
+            del self.view.container_label_bar_temporary[label_id]
+
+        # Clear the labels in the model
+        self.label_items.clear()
+
+        # Reset the icon file 
+        self.update_icon_file()
+
+        # We load the overview labelings
+        if labels_images is not None:
+            for file in labels_images:
+                self.load_labels_images(file)
+
+        # Load the labels and initalize the first one
+        if labels_json is not None:
+            self.load_labels_json(labels_json)
+            first_id = list(self.get_label_items().keys())[0]
+            self.controller.select_label(first_id)
+
+        # Now, we have to save in this directory :)
+        self.save_directory = current_file_path
+
+        
+            
+            
+
+
+    

PyImageLabeling/model/File/NextImage.py

@@ -0,0 +1,36 @@
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QFileDialog
+from PyQt6.QtGui import QPixmap
+import os
+
+class NextImage(Core):
+    def __init__(self):
+        super().__init__()
+
+    def next_image(self):
+        current_row = self.view.file_bar_list.currentRow()
+        total_images = len(self.image_items)
+        if  total_images == 1: return
+        
+        next_row = 0 if current_row == -1 else (current_row + 1) % total_images
+        self.view.file_bar_list.setCurrentRow(next_row)
+
+            # Calculate next row (with wrap-around)
+            # if current_row == -1:  # No selection
+            #     next_row = 0
+            # else:
+            #     next_row = (current_row + 1) % total_images
+            
+            # # Select the next item in the list
+            #self.view.file_bar_list.setCurrentRow(next_row)
+            
+            # Load the next image
+            #file_path = self.loaded_image_paths[next_row]
+            #image = QPixmap(file_path)
+            #if not image.isNull():
+            #    self.load_image(image)
+            #    print(f"Next image loaded: {os.path.basename(file_path)}")
+            #else:
+            #    self.error_message("Load Image", f"Could not load the image: {os.path.basename(file_path)}")

PyImageLabeling/model/File/PreviousImage.py

@@ -0,0 +1,19 @@
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QFileDialog
+from PyQt6.QtGui import QPixmap
+import os
+
+class PreviousImage(Core):
+    def __init__(self):
+        super().__init__()
+
+    def previous_image(self):
+        current_row = self.view.file_bar_list.currentRow()
+        total_images = len(self.image_items)
+        if  total_images == 1: return
+        
+        next_row = total_images - 1 if current_row == -1 else (current_row - 1) % total_images
+        self.view.file_bar_list.setCurrentRow(next_row)
+

PyImageLabeling/model/Image/MoveImage.py

@@ -0,0 +1,32 @@
+
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtWidgets import QGraphicsView
+
+
+class MoveImage(Core):
+    def __init__(self):
+        super().__init__() 
+        self.move_tool_activation = False 
+        self.last_cursor = None
+        
+    def move_image(self):
+        self.checked_button = self.move_image.__name__
+
+    def start_move_tool(self, event):
+        self.last_cursor = self.view.zoomable_graphics_view.viewport().cursor()
+        self.view.zoomable_graphics_view.change_cursor("move")
+        self.last_mouse_pos = event.scenePos()
+        self.move_tool_activation = True
+        
+
+    def move_move_tool(self, event):
+        if self.move_tool_activation is True:
+            self.view.zoomable_graphics_view.horizontalScrollBar().setValue(int(self.view.zoomable_graphics_view.horizontalScrollBar().value() - (event.scenePos().x() - self.last_mouse_pos.x())))
+            self.view.zoomable_graphics_view.verticalScrollBar().setValue(int(self.view.zoomable_graphics_view.verticalScrollBar().value() - (event.scenePos().y() - self.last_mouse_pos.y())))
+        
+    def end_move_tool(self):
+        self.view.zoomable_graphics_view.change_cursor("move")
+        self.view.zoomable_graphics_view.viewport().setCursor(self.last_cursor)
+        self.move_tool_activation = False
+        

PyImageLabeling/model/Image/ResetMoveZoomImage.py

@@ -0,0 +1,16 @@
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtCore import Qt
+
+class ResetMoveZoomImage (Core):
+    def __init__(self):
+        super().__init__() 
+
+    def set_view(self, view):
+        super().set_view(view)
+    
+    def reset_move_zoom_image(self):
+        self.zoomable_graphics_view.resetTransform()
+        self.zoomable_graphics_view.setSceneRect(self.image_qrectf)
+        self.view.zoom_factor = self.view.initial_zoom_factor 
+        #self.zoomable_graphics_view.fitInView(self.pixmap_item.boundingRect(), Qt.AspectRatioMode.KeepAspectRatio)

PyImageLabeling/model/Image/ZoomMinus.py

@@ -0,0 +1,25 @@
+
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtCore import QTimer
+
+class ZoomMinus(Core):
+    def __init__(self):
+        super().__init__() 
+        self.current_zoom_type = None
+
+    def zoom_minus(self):
+        self.checked_button = self.zoom_minus.__name__
+        
+    def start_zoom_minus(self):
+        self.view.zoomable_graphics_view.change_cursor("zoom_minus")
+        self.view.zoomable_graphics_view.zoom(self.view.minus_zoom_factor-0.2)
+
+        #self.apply_zoom_minus()
+        #self.zoom_timer_plus.start()
+
+    
+
+    #def end_zoom_minus(self):
+    #    self.view.zoomable_graphics_view.change_cursor("zoom_minus")
+    #    self.zoom_timer_plus.stop()

PyImageLabeling/model/Image/ZoomPlus.py

@@ -0,0 +1,16 @@
+
+
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtCore import QTimer
+
+class ZoomPlus(Core):
+    def __init__(self):
+        super().__init__() 
+        
+    def zoom_plus(self):
+        self.checked_button = self.zoom_plus.__name__
+        
+    def start_zoom_plus(self):
+        self.view.zoomable_graphics_view.change_cursor("zoom_plus")
+        self.view.zoomable_graphics_view.zoom(self.view.plus_zoom_factor+0.2)
+        

PyImageLabeling/model/Labeling/ClearAll.py

@@ -0,0 +1,22 @@
+from PyQt6.QtGui import QPainter, QBitmap, QImage, QPixmap
+from PyImageLabeling.model.Core import Core
+from PyQt6.QtWidgets import QMessageBox
+
+class ClearAll(Core):
+    def __init__(self):
+        super().__init__()
+
+    def clear_all(self):
+        msgBox = QMessageBox(self.view.zoomable_graphics_view)
+        msgBox.setWindowTitle("Clear All")
+        msgBox.setText("Are you sure you want to delete the selected label ?")
+        msgBox.setInformativeText("The `Undo` method will be reset.")
+        msgBox.setStandardButtons(QMessageBox.StandardButton.No | QMessageBox.StandardButton.Yes)
+        msgBox.setDefaultButton(QMessageBox.StandardButton.No)
+        msgBox.setModal(True)
+        result = msgBox.exec()
+        if result == QMessageBox.StandardButton.Yes:
+            self.get_current_image_item().get_labeling_overlay().reset()
+        
+    
+

PyImageLabeling/model/Labeling/ContourFilling.py

@@ -0,0 +1,135 @@
+from PyQt6.QtWidgets import QMessageBox, QProgressDialog, QGraphicsItem
+from PyQt6.QtCore import Qt, QPointF, QPoint, QLine, QRectF, QRect
+from PyQt6.QtGui import QPixmap, QImage, QColor,  QPainter, QPen
+from PyImageLabeling.model.Core import Core
+import numpy as np
+import cv2
+import traceback
+
+from PyImageLabeling.model.Utils import Utils
+
+import time
+
+TOLERENCE_PARAMETERS = {
+            1: {'canny_low': 100, 'canny_high': 200, 'blur_kernel': 3, 'dilate_iter': 0, 'min_area': 50},
+            2: {'canny_low': 80, 'canny_high': 180, 'blur_kernel': 3, 'dilate_iter': 1, 'min_area': 30},
+            3: {'canny_low': 70, 'canny_high': 160, 'blur_kernel': 3, 'dilate_iter': 1, 'min_area': 20},
+            4: {'canny_low': 60, 'canny_high': 140, 'blur_kernel': 5, 'dilate_iter': 1, 'min_area': 15},
+            5: {'canny_low': 50, 'canny_high': 150, 'blur_kernel': 5, 'dilate_iter': 1, 'min_area': 10}, 
+            6: {'canny_low': 40, 'canny_high': 120, 'blur_kernel': 5, 'dilate_iter': 2, 'min_area': 8},
+            7: {'canny_low': 30, 'canny_high': 100, 'blur_kernel': 7, 'dilate_iter': 2, 'min_area': 5},
+            8: {'canny_low': 25, 'canny_high': 80, 'blur_kernel': 7, 'dilate_iter': 2, 'min_area': 3},
+            9: {'canny_low': 20, 'canny_high': 60, 'blur_kernel': 9, 'dilate_iter': 3, 'min_area': 2},
+            10: {'canny_low': 15, 'canny_high': 40, 'blur_kernel': 9, 'dilate_iter': 3, 'min_area': 1}
+        }
+class ContourItem():
+
+    def __init__(self, points, color):
+        super().__init__()
+        self.points = points
+        self.color = color
+        
+        self.qrectf = QRectF(points[0][0][0], points[0][0][1], 1, 1)
+        for point in points:   
+            self.qrectf = self.qrectf.united(QRectF(point[0][0], point[0][1], 1, 1))
+        
+        self.qrect = self.qrectf.toRect()
+        contour_numpy_pixels = np.zeros((self.qrect.height(), self.qrect.width(), 4), dtype=np.uint8)
+        
+        for point in self.points:
+            point[0][0], point[0][1] = point[0][0]-self.qrect.x(), point[0][1]-self.qrect.y()
+        
+        cv2.drawContours(contour_numpy_pixels, [self.points], -1, self.color.getRgb(), -1)
+        cv2.drawContours(contour_numpy_pixels, [self.points], 0, self.color.getRgb(), 1)
+        
+        self.image_pixmap = QPixmap.fromImage(QImage(contour_numpy_pixels.data, self.qrect.width(), self.qrect.height(), self.qrect.width() * 4, QImage.Format.Format_RGBA8888))
+    
+    def paint_labeling_overlay(self, labeling_overlay_painter):
+        labeling_overlay_painter.drawPixmap(self.qrect.x(), self.qrect.y(), self.image_pixmap) 
+
+        
+
+class ContourFilling(Core):
+    def __init__(self):
+        super().__init__()
+        self.contours = [] # It is in list of contours. A contour is a list of points (x, y).
+        self.contour_items = [] # QGraphicItem for each contour clicked
+        
+        self.coutour_filling_pixmap = None
+        self.coutour_filling_item = None
+
+    def contour_filling(self):
+        self.checked_button = self.contour_filling.__name__
+
+    def start_contour_filling(self):
+        self.view.zoomable_graphics_view.change_cursor("filling")
+        self.apply_contour()
+    
+    def end_contour_filling(self):
+        # Remove the dislay of all these item
+        for item in self.contour_items:
+            self.zoomable_graphics_view.scene.removeItem(item)
+        self.contour_items.clear()
+        
+    def remove_contour(self):
+        if self.coutour_filling_item is not None:
+            self.view.zoomable_graphics_view.scene.removeItem(self.coutour_filling_item)
+            self.coutour_filling_item = None
+    
+    def get_contours(self):
+        # Convert to grayscale (use OpenCV)
+        image_numpy_pixels_gray = cv2.cvtColor(self.get_current_image_item().get_image_numpy_pixels_rgb(), cv2.COLOR_RGB2GRAY)
+        # Apply Gaussian blur to reduce noise (kernel size based on tolerance)
+        image_numpy_pixels_blurred = cv2.GaussianBlur(image_numpy_pixels_gray, (self.tolerance_parameters["blur_kernel"], self.tolerance_parameters["blur_kernel"]), 0)
+        # Apply Canny edge detection with tolerance-based parameters
+        image_numpy_pixels_canny = cv2.Canny(image_numpy_pixels_blurred, self.tolerance_parameters["canny_low"], self.tolerance_parameters["canny_high"]) 
+        # Apply dilation to connect nearby edges (iterations based on tolerance)
+        if self.tolerance_parameters['dilate_iter'] > 0:
+            image_numpy_pixels_canny = cv2.dilate(image_numpy_pixels_canny, np.ones((2, 2), np.uint8), iterations=self.tolerance_parameters['dilate_iter'])
+        # Find contours with hierarchy to better handle nested shapes
+        contours, _ = cv2.findContours(image_numpy_pixels_canny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)
+        # Filter out small contours based on tolerance level
+        contours = [cnt for cnt in contours if cv2.contourArea(cnt) > self.tolerance_parameters["min_area"]]
+        return contours
+
+    def apply_contour(self):
+        self.width = self.get_current_image_item().get_width()
+        self.height = self.get_current_image_item().get_height()
+        
+        self.tolerance = Utils.load_parameters()["contour_filling"]["tolerance"]
+        self.tolerance_parameters = TOLERENCE_PARAMETERS[self.tolerance]
+        self.contours = self.get_contours() # It is in list of contours. A contour is a list of points (x, y). 
+        if len(self.contours) == 0:
+            raise ValueError("No contours found !")
+
+        self.color = self.get_current_label_item().get_color()
+        # It is more faster to do that because cv2 loop into the points of contours in c++, not python
+        contour_numpy_pixels = np.zeros((self.height, self.width, 4), dtype=np.uint8)
+        cv2.drawContours(contour_numpy_pixels, self.contours, -1, self.color.darker(200).getRgb(), 1)
+        self.coutour_filling_pixmap = QPixmap.fromImage(QImage(contour_numpy_pixels.data, self.width, self.height, self.width * 4, QImage.Format.Format_RGBA8888))
+        self.coutour_filling_item = self.view.zoomable_graphics_view.scene.addPixmap(self.coutour_filling_pixmap)
+        self.coutour_filling_item.setZValue(1)
+        print("end apply_contour")
+
+    def find_closest_contour(self, position_x, position_y):
+        for contour in self.contours:
+            if cv2.pointPolygonTest(contour, (position_x, position_y), False) >= 0:
+                return contour
+        return None
+            
+    def fill_contour(self, position):
+        # Find the good contour
+        self.color = self.get_current_label_item().get_color()
+        position_x, position_y = int(position.x()), int(position.y()) 
+        closest_contour = self.find_closest_contour(position_x, position_y)
+        if closest_contour is None: return # We are not cliked inside of a contour
+
+        # Create a little QPixmap of this contour with cv2 
+        coutour_item = ContourItem(closest_contour.copy(), self.color)
+        
+        # Draw the contour QPixmap on the good labeling overlay 
+        coutour_item.paint_labeling_overlay(self.get_current_image_item().get_labeling_overlay().get_painter())
+        
+        # Update the labeling overlay
+        self.get_current_image_item().update_labeling_overlay()
+