Merge branch 'changes'

src/ImageFiltering.py

@@ -2,12 +2,43 @@ 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, kSize):
+def applyMedianFilter(img: ndarray, kSize: int):
     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
 
 
@@ -25,6 +56,30 @@ 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
 
 
@@ -42,6 +97,28 @@ 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 = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.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 = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.image = img
 
     def apply_moving_avg_filter_integral(self, kernel_size):
         img = IF.applyMovingAverageFilterWithIntegralImage(
             self._model.input_image, kernel_size
         )
-        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.image = img
 
     def apply_median_filter(self, kernel_size):
         img = IF.applyMedianFilter(self._model.input_image, kernel_size)
-        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.image = img
 
     def apply_filter_sobelX(self):
         kernel = IF.createSobelXKernel()
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.image = img
 
     def apply_filter_sobelY(self):
         kernel = IF.createSobelYKernel()
         img = IF.applyKernelInSpatialDomain(self._model.input_image, kernel)
-        self._model.image = Utilities.ensure_three_channel_grayscale_image(img)
+        self._model.image = img
 
     def run_runtime_evaluation(self):
         IF.run_runtime_evaluation(self._model.input_image)

src/models.py

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