src/ImageFiltering.py

@@ -2,43 +2,12 @@ import numpy as np
 import matplotlib.pyplot as plt
 import datetime as dt
 import cv2
-from numpy._core.numeric import ndarray
 import Utilities
-import math
 
-def _getChannelMedian(values: list[list[int]], channel: int) -> int:
-    channelValues = list(map(lambda rgb: rgb[channel], values))
-    channelValues.sort()
-    return channelValues[int(len(channelValues)/2)]
 
 # apply median filter
-def applyMedianFilter(img: ndarray, kSize: int):
+def applyMedianFilter(img, kSize):
     filtered_img = img.copy()
-
-    for x in range(0, img.shape[0]):
-        for y in range(0, img.shape[1]):
-
-            values = []
-
-            for u in range(int(-kSize/2), int(kSize/2)+1):
-                s = x + u
-                if s < 0 or s >= img.shape[0]:
-                    continue
-
-                for v in range(int(-kSize/2), int(kSize/2)+1):
-                    t = y + v
-                    if t < 0 or t >= img.shape[1]:
-                        continue
-
-                    values.append(img[s][t])
-
-            if len(values) > 0:
-                filtered_img[x][y] = [
-                    _getChannelMedian(values, 0),
-                    _getChannelMedian(values, 1),
-                    _getChannelMedian(values, 2)
-                ]
-
     return filtered_img
 
 
@@ -56,30 +25,6 @@ def gaussian(x, y, sigmaX, sigmaY, meanX, meanY):
 # create a gaussian kernel of arbitrary size
 def createGaussianKernel(kSize, sigma=None):
     kernel = np.zeros((kSize, kSize))
-
-    stdev = math.floor(kSize/2)
-    stdev2 = stdev * stdev
-    factor = 1.0/(stdev2*2*math.pi)
-
-    sum = 0.0
-
-    for x in range(kSize):
-        xm = x - kSize/2
-        xsum = xm * xm / stdev2
-
-        for y in range(kSize):
-            ym = y - kSize/2
-            ysum = ym * ym / stdev2
-
-            kernel[x][y] = math.exp((xsum + ysum) * -0.5) * factor
-            sum += kernel[x][y]
-
-    # Normalize gaussian kernel in order not minimize power loss:
-    # https://stackoverflow.com/a/61355383
-    for x in range(kSize):
-        for y in range(kSize):
-            kernel[x][y] /= sum
-
     return kernel
 
 
@@ -97,28 +42,6 @@ def createSobelYKernel():
 
 def applyKernelInSpatialDomain(img, kernel):
     filtered_img = img.copy()
-
-    width, height = kernel.shape
-
-    for x in range(0, img.shape[0]):
-        for y in range(0, img.shape[1]):
-
-            filtered_img[x][y] = np.zeros([3])
-
-            for u in range(0, width):
-                s = x + u - int(width/2)
-
-                for v in range(0, height):
-                    t = y + v - int(height/2)
-
-                    color = np.zeros([3])
-                    if t >= 0 and t < img.shape[1] and s >= 0 and s < img.shape[0]:
-                        color = img[s][t]
-
-                    filtered_img[x][y][0] += kernel[u][v] * color[0]
-                    filtered_img[x][y][1] += kernel[u][v] * color[1]
-                    filtered_img[x][y][2] += kernel[u][v] * color[2]
-
     return filtered_img
 
 

src/controllers.py

@@ -117,32 +117,32 @@ class MainController:
     def apply_gaussian_filter(self, kernel_size):
         kernel = IF.createGaussianKernel(kernel_size)
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def apply_moving_avg_filter(self, kernel_size):
         kernel = IF.createMovingAverageKernel(kernel_size)
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def apply_moving_avg_filter_integral(self, kernel_size):
         img = IF.applyMovingAverageFilterWithIntegralImage(
             self._model.input_image, kernel_size
         )
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def apply_median_filter(self, kernel_size):
         img = IF.applyMedianFilter(self._model.input_image, kernel_size)
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def apply_filter_sobelX(self):
         kernel = IF.createSobelXKernel()
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def apply_filter_sobelY(self):
         kernel = IF.createSobelYKernel()
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = img
+        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
 
     def run_runtime_evaluation(self):
         IF.run_runtime_evaluation(self._model.input_image)

src/models.py

@@ -57,4 +57,5 @@ class ImageModel(QObject):
 
     def load_rgb_image(self, path):
         image = cv2.imread(path, 1)
+        # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
         self.image = image