Added Filters, edited Hough Ellipse

Added Two types of filters (Min, Max)

Author: cln-Kafka

App/Classes/Effects/Filter.py

@@ -79,10 +79,16 @@ def update_attributes(self):
     def calculate_filter(self):
         if self.type == "Mean":
             return self.mean_filter()
-        elif self.type == "Median":
-            return self.median_filter()
+        elif self.type == "Weighed Average":
+            return self.weighed_average_filter()
         elif self.type == "Gaussian":
             return self.gaussian_filter()
+        elif self.type == "Median":
+            return self.median_filter()
+        elif self.type == "Max":
+            return self.max_filter()
+        elif self.type == "Min":
+            return self.min_filter()
         else:
             raise ValueError("Unexpected filter type: " + self.type)
 
@@ -158,15 +164,8 @@ def mean_filter(self):
         """
         return self._apply_filter(np.mean)
 
-    def median_filter(self):
-        """
-        Description:
-            -   Applies a median filter to an image.
-
-        Returns:
-            -   [numpy ndarray]: A filtered image using a median filter.
-        """
-        return self._apply_filter(np.median)
+    def weighed_average_filter(self):
+        pass
 
     def gaussian_filter(self):
         """
@@ -192,3 +191,33 @@ def gaussian_filter(self):
                 gaussian_filtered_image[i, j] = np.sum(window * kernel)
 
         return gaussian_filtered_image
+
+    def median_filter(self):
+        """
+        Description:
+            -   Applies a median filter to an image.
+
+        Returns:
+            -   [numpy ndarray]: A filtered image using a median filter.
+        """
+        return self._apply_filter(np.median)
+
+    def max_filter(self):
+        """
+        Description:
+            - Applies a max filter to an image.
+
+        Returns:
+            - A numpy array representing the filtered image.
+        """
+        return self._apply_filter(np.max)
+
+    def min_filter(self):
+        """
+        Description:
+            - Applies a min filter to an image.
+
+        Returns:
+            - A numpy array representing the filtered image.
+        """
+        return self._apply_filter(np.min)

App/Classes/Effects/HoughTransform.py

@@ -7,7 +7,7 @@
 from Classes.EffectsWidgets.HoughTransformGroupBox import HoughTransformGroupBox
 from Classes.ExtendedWidgets.DoubleClickPushButton import QDoubleClickPushButton
 from PyQt5.QtCore import pyqtSignal
-from skimage import color, img_as_ubyte
+from skimage import color, data, img_as_ubyte
 from skimage.draw import ellipse_perimeter
 from skimage.feature import canny
 from skimage.transform import hough_ellipse
@@ -307,10 +307,15 @@ def hough_circle(self):
         return superimposed_circles_image
 
     def hough_ellipse_using_scikit_image(self):
-        image_gray = color.rgb2gray(self.original_image)
+        image_rgb = data.coffee()[0:220, 160:420]
+        image_gray = color.rgb2gray(image_rgb)
         edges = canny(image_gray, sigma=2.0, low_threshold=0.55, high_threshold=0.8)
+        # result = hough_ellipse(
+        #     edges, accuracy=20, threshold=250, min_size=100, max_size=120
+        # )
+
         result = hough_ellipse(
-            edges, accuracy=20, threshold=250, min_size=100, max_size=120
+            self.edged_image, accuracy=20, threshold=250, min_size=100, max_size=120
         )
         result.sort(order="accumulator")
 
@@ -387,22 +392,19 @@ def hough_ellipse_from_scratch(self, img, min2a=10, min_votes=10):
                         parameters = [x0, y0, a, si, alpha]
                         return parameters
 
-        print("No ellipses detected!")
         return None
 
     def ellipse_output_image_from_scratch(self):
 
-        img = cv2.Canny(self.original_image, 100, 200)
-
-        parameters = self.hough_ellipse_from_scratch(img)
+        parameters = self.hough_ellipse_from_scratch(self.edged_image)
         # Define the parameters of the ellipse
         center = (
             int(parameters[0]),
             int(parameters[1]),
         )  # Convert center coordinates to integers
         axes = (
-            int(parameters[2]) * 2,
-            parameters[3] * 2,
+            int(parameters[2]),
+            parameters[3],
         )  # Convert major axis length to integer
         angle = np.degrees(parameters[4])  # Convert angle from radians to degrees
 
@@ -411,8 +413,10 @@ def ellipse_output_image_from_scratch(self):
 
         # Draw the ellipse on the image
         self.output_image = cv2.ellipse(
-            image, center, axes, 255 - angle, 0, 360, (0, 255, 0), 2
+            image, center, axes, angle, 0, 360, (0, 255, 0), 2
         )
+
+        self.output_image[int(parameters[1]), int(parameters[0])] = 255
         return self.output_image
 
     # Line Transform Helper Functions

App/Classes/Effects/__pycache__/EdgeDetector.cpython-311.pyc

@@ -24,7 +24,9 @@ def initUI(self):
         filter_type_layout = QHBoxLayout()
         self.filter_type_label = QLabel("Filter Type")
         self.filter_type_comb = QComboBox()
-        self.filter_type_comb.addItems(["Mean", "Median", "Gaussian"])
+        self.filter_type_comb.addItems(
+            ["Mean", "Weighted Average", "Gaussian", "Median", "Max", "Min"]
+        )
         self.filter_type_comb.currentIndexChanged.connect(self.update_filter_options)
         filter_type_layout.addWidget(self.filter_type_label)
         filter_type_layout.addWidget(self.filter_type_comb)
@@ -55,8 +57,8 @@ def initUI(self):
 
     def update_filter_options(self, index):
         if index == 2:  # Gaussian
-            self.sigma_spinbox.setVisible(True)
             self.sigma_label.setVisible(True)
+            self.sigma_spinbox.setVisible(True)
         else:  # Mean or Median
-            self.sigma_spinbox.setVisible(False)
             self.sigma_label.setVisible(False)
+            self.sigma_spinbox.setVisible(False)

App/Classes/Effects/__pycache__/Equalizer.cpython-311.pyc

@@ -134,7 +134,7 @@ def initUI(self):
         self.ellipse_detector_type_label = QLabel("Detector Type")
         self.ellipse_detector_type_combobox = QComboBox()
         self.ellipse_detector_type_combobox.addItems(["From Scratch", "Scikit-image"])
-        self.ellipse_detector_type_combobox.setCurrentIndex(1)
+        self.ellipse_detector_type_combobox.setCurrentIndex(0)
         self.ellipse_attributes_hbox.addWidget(self.ellipse_detector_type_label)
         self.ellipse_attributes_hbox.addWidget(self.ellipse_detector_type_combobox)
 

App/Classes/Effects/__pycache__/Filter.cpython-311.pyc

@@ -46,10 +46,14 @@ def __init__(self, file_path):
         self.img_data = None
         self.grayscale_img = None
 
-        self.output_img = None
-        self.cumulative_output = None
+        self.output_img = None  # The output image of the last appied effect
+        self.cumulative_output = (
+            None  # The output image of appliying all the effects as "chain"
+        )
 
-        self.applied_effects = {}  # Dictionary to store the applied effects.
+        self.applied_effects = (
+            {}
+        )  # Dictionary to store the applied effects and its parameters.
         # They will be shown in the tree and the table widgets.
         Image.all_images.append(self)
         # To facilitate the access to the images, we will store them in a list
@@ -83,6 +87,8 @@ def add_applied_effect(self, effect_name, effect_attributes):
         Args:
             - effect_name [String]: Name of the effect, the key in the dictionary.
             - effect_attributes [Dictionary]: Attributes of the effect (e.g., type, value1, value2).
+
+        Note that these are formed inside each effect class and we are just passing it to the class to set/store it.
         """
         self.applied_effects[effect_name] = effect_attributes
 
@@ -184,6 +190,9 @@ def __init__(self, ui):
         ]
         ###  End  Effects Library ###
 
+        ## === Cumulative Boolean === ##
+        self.is_cumulative = False
+
         self.init_ui_connections()
 
     def init_ui_connections(self):
@@ -1103,7 +1112,9 @@ def update_edged_image(new_edged_image):
             nonlocal edged_image
             edged_image = new_edged_image
             # Update the Hough Transform with the new edged image
-            hough_effect.update_images(self.current_image_data, self.grayscale_image, edged_image)
+            hough_effect.update_images(
+                self.current_image_data, self.grayscale_image, edged_image
+            )
             # Update the displayed image
             self.current_image.set_output_image(self.output_image)
             self.display_image(self.current_image_data, self.output_image)
@@ -1264,7 +1275,7 @@ def cumulative_pipeline(self):
         Description:
             - Toggles the cumulative pipeline of the applied effects.
         """
-        pass
+        self.is_cumulative = not self.is_cumulative
 
     # Added Effects table widget functionalities #
     # ========================================== #

App/Classes/Effects/__pycache__/FreqFilters.cpython-311.pyc

@@ -48,6 +48,12 @@ def setupUi(self, ImgAlchemy):
         self.app_grid_layout.setSpacing(0)
         self.app_grid_layout.setObjectName("gridLayout")
 
+        # # Create the splitter to make the app resizable
+        # self.splitter = QtWidgets.QSplitter(self.centralwidget)
+        # self.splitter.setOrientation(QtCore.Qt.Horizontal)
+        # self.splitter.setObjectName("splitter")
+        # self.app_grid_layout.addWidget(self.splitter, 0, 0, 1, 1)
+
         # Side Bar: Left Sidebar -> Closed by default #
         # =========================================== #
 
@@ -78,6 +84,18 @@ def setupUi(self, ImgAlchemy):
         self.left_bar_expanded = QtWidgets.QWidget(self.centralwidget)
         self.left_bar_expanded.setObjectName("left_bar_expanded")
         self.left_bar_expanded_VLayout = QtWidgets.QVBoxLayout(self.left_bar_expanded)
+        # # To add the feature of manual resizing
+        # self.left_bar_full = QtWidgets.QWidget()
+        # self.left_bar_full.setObjectName("left_bar_full")
+        # self.left_bar_full_VLayout = QtWidgets.QVBoxLayout(self.left_bar_full)
+        # self.left_bar_full_VLayout.setContentsMargins(0, 0, 0, 0)
+        # self.left_bar_full_VLayout.addWidget(self.left_bar_header)
+        # ## Make a horizontal layout that holds the views of the left bar and place it into the left bar full layout
+        # self.left_bar_views_HLayout = QtWidgets.QHBoxLayout()
+        # self.left_bar_views_HLayout.setContentsMargins(0, 0, 0, 0)
+        # self.left_bar_views_HLayout.addWidget(self.left_bar_collapsed)
+        # self.left_bar_views_HLayout.addWidget(self.left_bar_expanded)
+        # self.left_bar_full_VLayout.addLayout(self.left_bar_views_HLayout)
 
         # Viewport: Image Workspace #
         # ========================= #
@@ -156,6 +174,19 @@ def setupUi(self, ImgAlchemy):
         self.effect_menu_expanded_VLayout.setContentsMargins(0, 0, 0, 0)
         self.effect_menu_expanded.setMinimumWidth(200)
 
+        # # To add the feature of manual resizing
+        # self.effect_menu_full = QtWidgets.QWidget()
+        # self.effect_menu_full.setObjectName("effect_menu_full")
+        # self.effect_menu_full_VLayout = QtWidgets.QVBoxLayout(self.effect_menu_full)
+        # self.effect_menu_full_VLayout.addWidget(self.effect_menu_header)
+        # self.effect_menu_full_VLayout.setContentsMargins(0, 0, 0, 0)
+        # ## Make a horizontal layout that holds the views of the effect menu and place it into the effect menu full layout
+        # self.effect_menu_full_HLayout = QtWidgets.QHBoxLayout()
+        # self.effect_menu_full_HLayout.setContentsMargins(0, 0, 0, 0)
+        # self.effect_menu_full_HLayout.addWidget(self.effect_menu_collapsed)
+        # self.effect_menu_full_HLayout.addWidget(self.effect_menu_expanded)
+        # self.effect_menu_full_VLayout.addLayout(self.effect_menu_full_HLayout)
+
         # Effect Menu: Expanded View Content #
         # ================================== #
         # Create a scroll area
@@ -222,6 +253,18 @@ def setupUi(self, ImgAlchemy):
             self.control_panel_expanded
         )
         self.control_panel_expanded_VLayout.setContentsMargins(0, 0, 0, 0)
+        # # To add the feature of manual resizing
+        # self.control_panel_full = QtWidgets.QWidget()
+        # self.control_panel_full.setObjectName("control_panel_full")
+        # self.control_panel_full_VLayout = QtWidgets.QVBoxLayout(self.control_panel_full)
+        # self.control_panel_full_VLayout.addWidget(self.control_panel_header)
+        # self.control_panel_full_VLayout.setContentsMargins(0, 0, 0, 0)
+        # ## Make a horizontal layout that holds the views of the control panel and place it into the control panel full layout
+        # self.control_panel_full_HLayout = QtWidgets.QHBoxLayout()
+        # self.control_panel_full_HLayout.setContentsMargins(0, 0, 0, 0)
+        # self.control_panel_full_HLayout.addWidget(self.control_panel_collapsed)
+        # self.control_panel_full_HLayout.addWidget(self.control_panel_expanded)
+        # self.control_panel_full_VLayout.addLayout(self.control_panel_full_HLayout)
 
         # Control Panel Collapsed Content #
         # =============================== #
@@ -514,6 +557,8 @@ def setupUi(self, ImgAlchemy):
 
         # Manage of the app main layout #
         # ============================= #
+
+        # Before adding the resizability feature
         self.app_grid_layout.addWidget(self.left_bar_header, 0, 0, 1, 2)
         self.app_grid_layout.addWidget(self.left_bar_collapsed, 1, 0, 1, 1)
         self.app_grid_layout.addWidget(self.left_bar_expanded, 1, 1, 1, 1)
@@ -528,6 +573,15 @@ def setupUi(self, ImgAlchemy):
         self.app_grid_layout.addWidget(self.control_panel_collapsed, 1, 5, 1, 1)
         self.app_grid_layout.addWidget(self.control_panel_expanded, 1, 6, 1, 1)
 
+        # # Add widgets to splitter
+        # self.splitter.addWidget(self.left_bar_full)
+        # self.splitter.addWidget(self.image_workspace)
+        # self.splitter.addWidget(self.effect_menu_full)
+        # self.splitter.addWidget(self.control_panel_full)
+
+        # # Set sizes for the sections
+        # self.splitter.setSizes([200, 400, 200, 300])
+
         self.init_bars_signals_and_slots()
         self.retranslateUi(ImgAlchemy)
         self.image_workspace.setCurrentIndex(0)

App/Classes/Effects/__pycache__/HoughTransform.cpython-311.pyc

@@ -18,6 +18,7 @@ The app UI meant to be similar to Photoshop UI. It has different sections, each
 - When you expand or collapse the control panel, the expanded or the collapsed view of the effects menu appears for a second.
 - Themes Feature.
 - Make it responsive.
+- The error message due to invalid types.
 
 ### Digital Image Processing Functions (DIPFs):
 _That means "Is this effect was integrated in the app or not?"._
@@ -49,6 +50,7 @@ _That means "Is this effect was integrated in the app or not?"._
     - Openning multiple histogram tabs for the same image 
     - Defining to which image does the tab belong to in its title probably
 - In the groupboxes of the effects, the parameters controllers (e.g. sliders and spinboxes) are not actually set to the default values defined in the effect class
+- When I used SNAKE, it saved the result. In the same run, I opened buildings image to see the Hough line algorithm. It updated the SNAKE gif with the buildings input and output image.
 
 ## Done: