matteo/matrix-kernel-filter-calculator
1
0
Fork 0
mirror of https://github.com/mschuepbach/matrix-kernel-filter-calculator.git synced 2026-01-15 21:12:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactoring

Browse Source
This commit is contained in:
mschuepbach
2022-02-01 10:08:19 +01:00
parent ab57b09af7
commit 35468129cc
1 changed files with 21 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/App.svelte
View File

@@ -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;
}