Фильтр Собеля (нужно реализовать данное условие)

 var gx = -g[x - 1, y - 1] - 2 * g[x, y - 1] - g[x + 1, y - 1] + g[x - 1, y + 1] + 2 * g[x, y + 1] + g[x + 1, y + 1];
                    var gy = -g[x - 1, y - 1] - 2 * g[x - 1, y] - g[x - 1, y + 1] + g[x + 1, y - 1] + 2 * g[x + 1, y] + g[x + 1, y + 1];
                    result[x, y] = Math.Sqrt(gx * gx + gy * gy);
 
[size="1"][color="grey"][I]Добавлено через 18 минут[/I][/color][/size]
using System;
 
namespace Recognizer
{
    internal static class SobelFilterTask
    {
        /* 
        Разберитесь, как работает нижеследующий код (называемый фильтрацией Собеля), 
        и какое отношение к нему имеют эти матрицы:
        
             | -1 -2 -1 |           | -1  0  1 |
        Sx = |  0  0  0 |      Sy = | -2  0  2 |
             |  1  2  1 |           | -1  0  1 |
        
        [url]https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80_%D0%A1%D0%BE%D0%B1%D0%B5%D0%BB%D1%8F[/url]
        
        Попробуйте заменить фильтр Собеля 3x3 на фильтр Собеля 5x5 или другой аналогичный фильтр и сравните результаты. 
        Матрицу для фильтра Собеля 5x5 и другие матрицы можно посмотреть в статье SobelScharrGradients5x5.pdf в архиве с проектом.
        Там Sx и Sy названы соответственно β и γ.
 
        Обобщите код применения фильтра так, чтобы можно было передавать ему любые матрицы, любого нечетного размера.
        Фильтры Собеля размеров 3 и 5 должны быть частным случаем. 
        После такого обобщения менять фильтр Собеля одного размера на другой должно быть легко.
        */
 
        public static double[,] SobelFilter(double[,] g, double[,] sx)
        {
            var width = g.GetLength(0);
            var height = g.GetLength(1);
            var result = new double[width, height];
            for (int x = 1; x < width - 1; x++)
                for (int y = 1; y < height - 1; y++)
                {
                    // Вместо этого кода должно быть поэлементное умножение матриц sx и полученной из неё sy на окрестность точки (x, y)
                    // Такая операция ещё называется свёрткой (Сonvolution)
                    var gx = -g[x - 1, y - 1] - 2 * g[x, y - 1] - g[x + 1, y - 1] + g[x - 1, y + 1] + 2 * g[x, y + 1] + g[x + 1, y + 1];
                    var gy = -g[x - 1, y - 1] - 2 * g[x - 1, y] - g[x - 1, y + 1] + g[x + 1, y - 1] + 2 * g[x + 1, y] + g[x + 1, y + 1];
                    result[x, y] = Math.Sqrt(gx * gx + gy * gy);
                }
            return result;
        }
    }
}

    public class Sobel
    {
        //Транспонирует матрицу
        public static double[,] Transpose(double[,] matr)
        {
            var n = matr.GetUpperBound(0) + 1;
            var m = matr.GetUpperBound(1) + 1;
            var result = new double[m, n];
            for (var i = 0; i < n; i++)
            {
                for (var j = 0; j < m; j++)
                {
                    result[j, i] = matr[i, j];
                }
            }
            return result;
        }
 
        //Матрица окрестности точки x,y
        public static double[,] GetNeighbourhood(double[,] g, int x, int y, int size)
        {
            var result = new double[size, size];
            var delta = size / 2;
            for (var i = x - delta; x <= y + delta; x++)
                for (var j = y - delta; y <= y + delta; y++)
                {
                    result[i - (x - delta), j - (y - delta)] = g[i, j];
                }
            return result;
        }
 
        //Произведение матриц.
        public static double Mult(double[,] sxy, double[,] neighbourhood)
        {
            var sum = 0d;
            for (var i = 0; i < neighbourhood.GetUpperBound(0) + 1; i++)
            {
 
                for (var j = 0; j < neighbourhood.GetUpperBound(0) + 1; j++)
                {
                    sum += sxy[i, j] * neighbourhood[i, j];
                }
 
            }
            return sum;
        }
 
 
        public static double[,] SobelFilter(double[,] g, double[,] sx)
        {
            var width = g.GetLength(0) + 1;
            var height = g.GetLength(1) + 1;
            var sizeX = sx.GetUpperBound(0) + 1;
            var sizeY = sx.GetUpperBound(1) + 1;
 
            if (sizeX != sizeY)
            {
                throw new ArgumentException("Матрица Sx должна быть квадратной");
            }
            if (sizeX % 2 == 0)
            {
                throw new ArgumentException("Матрица Sx должна иметь нечетную размерность");
            }
 
            var result = new double[width, height];
 
            var deltaX = sizeX / 2;
            var deltaY = sizeY / 2;
            var sy = Transpose(sx);
 
            for (int x = deltaX; x < width - deltaX; x++)
            {
                for (int y = deltaY; y < height - deltaY; y++)
                {
                    var neighbourhood = GetNeighbourhood(g, x, y, sizeX);
                    var gx = Mult(sx, neighbourhood);
                    var gy = Mult(sy, neighbourhood);
                    result[x, y] = Math.Sqrt(gx * gx + gy * gy);
                }
            }
            return result;
        }
}

using System;
 
namespace Recognizer
{
    internal static class SobelFilterTask
    { //Транспонирует матрицу
        public static double[,] Transpose(double[,] matr)
        {
            var n = matr.GetUpperBound(0) + 1;
            var m = matr.GetUpperBound(1) + 1;
            var result = new double[m, n];
            for (var i = 0; i < n; i++)
                for (var j = 0; j < m; j++)
                    result[j, i] = matr[i, j];
            return result;
        }
        //Матрица окрестности точки x,y
        public static double[,] GetNeighbourhood(double[,] g, int x, int y, int size)
        {
            var result = new double[size, size];
            result.Initialize();
            var delta = size / 2;
            for (var i = x - delta; i <= x + delta; i++)
                for (var j = y - delta; j <= y + delta; j++)
                    result[i - (x - delta), j - (y - delta)] = g[i, j];
            return result;
        }
        //Произведение матриц.
        public static double MultiplyMatrix(double[,] sxy, double[,] neighbourhood)
        {
            var sum = 0d;
            for (var i = 0; i < neighbourhood.GetUpperBound(0) + 1; i++)
                for (var j = 0; j < neighbourhood.GetUpperBound(0) + 1; j++)
                    sum += sxy[i, j] * neighbourhood[i, j];
            return sum;
        }
 
        public static double[,] SobelFilter(double[,] g, double[,] sx)
        {
            var width = g.GetLength(0);
            var height = g.GetLength(1);
            var result = new double[width, height];
            var sizeX = sx.GetUpperBound(0) + 1;
            var sizeY = sx.GetUpperBound(1) + 1;
            var deltaX = sizeX / 2;
            var deltaY = sizeY / 2;
            var sy = Transpose(sx);
 
            for (int x = deltaX; x < width - deltaX; x++)
            {
                for (int y = deltaY; y < height - deltaY; y++)
                {
                    var neighbourhood = GetNeighbourhood(g, x, y, sizeX);
                    var gx = MultiplyMatrix(sx, neighbourhood);
                    var gy = MultiplyMatrix(sy, neighbourhood);
                    result[x, y] = Math.Sqrt(gx * gx + gy * gy);
                }
            }
            return result;
        }
    }
}