From 35468129cc28781e5f1d2209213540cf638879ab Mon Sep 17 00:00:00 2001
From: mschuepbach <schuepbach.matteo@gmail.com>
Date: Tue, 1 Feb 2022 10:08:19 +0100
Subject: [PATCH] Refactoring

---
 src/App.svelte | 46 +++++++++++++++++++++-------------------------
 1 file changed, 21 insertions(+), 25 deletions(-)

diff --git a/src/App.svelte b/src/App.svelte
index 4e4b501..16b36f4 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -11,7 +11,7 @@
 
   $: matrix = initMatrix(matrixWidth, matrixHeight, 1);
   $: kernel = initMatrix(kernelWidth, kernelHeight, 1);
-  $: result = conv_2d(kernel, matrix, addPadding, padding);
+  $: result = applyKernelFilter(matrix, kernel, addPadding, padding);
 
   function initMatrix(width, height, value) {
     return width > 0 && height > 0
@@ -21,27 +21,23 @@
       : [[]];
   }
 
-  function conv_2d(kernel, array, addPadding, padding = 0) {
-    // source: https://stackoverflow.com/questions/64669531/2d-convolution-for-javascript-arrays
-    let kRows = kernel.length;
-    let kCols = kernel[0].length;
-    let rows = array.length;
-    let cols = array[0].length;
-    let result = initMatrix(cols, rows, 0);
-    // find center position of kernel (half of kernel size)
-    let kCenterX = Math.floor(kCols / 2);
-    let kCenterY = Math.floor(kRows / 2);
+  function applyKernelFilter(matrix, kernel, addPadding, padding = 0) {
+    let kernelHeight = kernel.length;
+    let kernelWidth = kernel[0].length;
+    let matrixHeight = matrix.length;
+    let matrixWidth = matrix[0].length;
+    let result = initMatrix(matrixWidth, matrixHeight, 0);
+    let kernelCenterX = Math.floor(kernelWidth / 2);
+    let kernelCenterY = Math.floor(kernelHeight / 2);
 
-    for (let i = 0; i < rows; ++i) {
-      for (let j = 0; j < cols; ++j) {
-        for (let m = 0; m < kRows; ++m) {
-          for (let n = 0; n < kCols; ++n) {
-            // index of input signal, used for checking boundary
-            let ii = i + (m - kCenterY);
-            let jj = j + (n - kCenterX);
-            // ignore input samples which are out of bound
-            if (ii >= 0 && ii < rows && jj >= 0 && jj < cols) {
-              result[i][j] += array[ii][jj] * kernel[m][n];
+    for (let i = 0; i < matrixHeight; i++) {
+      for (let j = 0; j < matrixWidth; j++) {
+        for (let m = 0; m < kernelHeight; m++) {
+          for (let n = 0; n < kernelWidth; n++) {
+            let ii = i + (m - kernelCenterY);
+            let jj = j + (n - kernelCenterX);
+            if (ii >= 0 && ii < matrixHeight && jj >= 0 && jj < matrixWidth) {
+              result[i][j] += matrix[ii][jj] * kernel[m][n];
             } else {
               result[i][j] += padding * kernel[m][n];
             }
@@ -50,13 +46,13 @@
       }
     }
 
-    if (!addPadding && kCenterX > 0 && kCenterY > 0)
+    if (!addPadding && kernelCenterX > 0 && kernelCenterY > 0)
       result =
-        kRows >= rows || kCols >= cols
+        kernelHeight >= matrixHeight || kernelWidth >= matrixWidth
           ? [[]]
           : result
-              .slice(kCenterY, -kCenterY)
-              .map((r) => r.slice(kCenterX, -kCenterX));
+              .slice(kernelCenterY, -kernelCenterY)
+              .map((r) => r.slice(kernelCenterX, -kernelCenterX));
 
     return result;
   }