Neuron®
The Neuron® is the basis for the creation of open and secure federated networks for smart societies.
Loading...
Searching...
No Matches
Convolute.cs
1using IdApp.Cv.Arithmetics;
2using IdApp.Cv.Basic;
3using IdApp.Cv.ColorModels;
4using IdApp.Cv.Statistics;
5using System;
6
7namespace IdApp.Cv.Transformations.Convolutions
8{
12 public static partial class ConvolutionOperations
13 {
20 public static Matrix<float> Convolute(this Matrix<float> M, Matrix<float> Kernel)
21 {
22 float Sum = Kernel.Sum();
23
24 if (Sum != 1 && Sum != 0)
25 {
26 Kernel = Kernel.Copy();
27 Kernel.ScalarDivision(Sum);
28 }
29
30 int KernelY, KernelHeight = Kernel.Height;
31 int KernelX, KernelWidth = Kernel.Width;
32 int KernelOffset = Kernel.Start;
33 int KernelSkip = Kernel.Skip;
34 float[] KernelData = Kernel.Data;
35 int ResultWidth = M.Width - KernelWidth + 1;
36 int ResultHeight = M.Height - KernelHeight + 1;
37 Matrix<float> Result = new(ResultWidth, ResultHeight);
38 float Scalar;
39
40 for (KernelY = 0; KernelY < KernelHeight; KernelY++, KernelOffset += KernelSkip)
41 {
42 for (KernelX = 0; KernelX < KernelWidth; KernelX++)
43 {
44 Scalar = KernelData[KernelOffset++];
45
46 if (Scalar != 0)
47 Result.WeightedAddition(M.Region(KernelX, KernelY, ResultWidth, ResultHeight), Scalar);
48 }
49 }
50
51 return Result;
52 }
53
60 public static Matrix<float> Convolute(this Matrix<float> M, Matrix<int> Kernel)
61 {
62 float Sum = Kernel.Sum();
63
64 if (Sum != 1 && Sum != 0)
65 {
66 Matrix<float> KernelF = Kernel.GrayScale();
67 return M.Convolute(KernelF);
68 }
69
70 int KernelY, KernelHeight = Kernel.Height;
71 int KernelX, KernelWidth = Kernel.Width;
72 int KernelOffset = Kernel.Start;
73 int KernelSkip = Kernel.Skip;
74 int[] KernelData = Kernel.Data;
75 int ResultWidth = M.Width - KernelWidth + 1;
76 int ResultHeight = M.Height - KernelHeight + 1;
77 Matrix<float> Result = new(ResultWidth, ResultHeight);
78 float Scalar;
79
80 for (KernelY = 0; KernelY < KernelHeight; KernelY++, KernelOffset += KernelSkip)
81 {
82 for (KernelX = 0; KernelX < KernelWidth; KernelX++)
83 {
84 Scalar = KernelData[KernelOffset++];
85
86 if (Scalar != 0)
87 Result.WeightedAddition(M.Region(KernelX, KernelY, ResultWidth, ResultHeight), Scalar);
88 }
89 }
90
91 return Result;
92 }
93
100 public static Matrix<int> Convolute(this Matrix<int> M, Matrix<int> Kernel)
101 {
102 long Sum = Kernel.Sum();
103 if (Sum > int.MaxValue)
104 throw new ArgumentException("Sum of kernel too big.", nameof(Kernel));
105
106 int KernelY, KernelHeight = Kernel.Height;
107 int KernelX, KernelWidth = Kernel.Width;
108 int KernelOffset = Kernel.Start;
109 int KernelSkip = Kernel.Skip;
110 int[] KernelData = Kernel.Data;
111 int ResultWidth = M.Width - KernelWidth + 1;
112 int ResultHeight = M.Height - KernelHeight + 1;
113 Matrix<int> Result = new(ResultWidth, ResultHeight);
114 int Scalar;
115
116 for (KernelY = 0; KernelY < KernelHeight; KernelY++, KernelOffset += KernelSkip)
117 {
118 for (KernelX = 0; KernelX < KernelWidth; KernelX++)
119 {
120 Scalar = KernelData[KernelOffset++];
121
122 if (Scalar != 0)
123 Result.WeightedAddition(M.Region(KernelX, KernelY, ResultWidth, ResultHeight), Scalar);
124 }
125 }
126
127 if (Sum != 0 && Sum != 1)
128 Result.ScalarDivision((int)Sum);
129
130 return Result;
131 }
132
139 public static Matrix<int> Convolute(this Matrix<int> M, Matrix<float> Kernel)
140 {
141 float Sum = Kernel.Sum();
142
143 if (Sum != 1 && Sum != 0)
144 {
145 Kernel = Kernel.Copy();
146 Kernel.ScalarDivision(Sum);
147 }
148
149 int KernelY, KernelHeight = Kernel.Height;
150 int KernelX, KernelWidth = Kernel.Width;
151 int KernelOffset = Kernel.Start;
152 int KernelSkip = Kernel.Skip;
153 float[] KernelData = Kernel.Data;
154 int ResultWidth = M.Width - KernelWidth + 1;
155 int ResultHeight = M.Height - KernelHeight + 1;
156 Matrix<float> Result = new(ResultWidth, ResultHeight);
157 float Scalar;
158
159 for (KernelY = 0; KernelY < KernelHeight; KernelY++, KernelOffset += KernelSkip)
160 {
161 for (KernelX = 0; KernelX < KernelWidth; KernelX++)
162 {
163 Scalar = KernelData[KernelOffset++];
164
165 if (Scalar != 0)
166 Result.WeightedAddition(M.Region(KernelX, KernelY, ResultWidth, ResultHeight), Scalar);
167 }
168 }
169
170 float[] Data = Result.Data;
171 int i, c = Data.Length;
172 int[] DataFixed = new int[c];
173
174 for (i = 0; i < c; i++)
175 DataFixed[i] = (int)(Data[i] + 0.5f);
176
177 return new Matrix<int>(ResultWidth, ResultHeight, DataFixed);
178 }
179
186 public static Matrix<float> Convolute(this Matrix<float> M, IMatrix Kernel)
187 {
188 if (Kernel is Matrix<float> K2)
189 return M.Convolute(K2);
190 else if (Kernel is Matrix<int> K3)
191 return M.Convolute(K3);
192 else
193 throw new ArgumentException("Unsupported type: " + Kernel.GetType().FullName, nameof(Kernel));
194 }
195
202 public static Matrix<int> Convolute(this Matrix<int> M, IMatrix Kernel)
203 {
204 if (Kernel is Matrix<int> K2)
205 return M.Convolute(K2);
206 else if (Kernel is Matrix<float> K3)
207 return M.Convolute(K3);
208 else
209 throw new ArgumentException("Unsupported type: " + Kernel.GetType().FullName, nameof(Kernel));
210 }
211
218 public static IMatrix Convolute(this IMatrix M, IMatrix Kernel)
219 {
220 if (M is Matrix<float> M2)
221 return Convolute(M2, Kernel);
222 else if (M is Matrix<int> M3)
223 return Convolute(M3, Kernel);
224 else
225 throw new ArgumentException("Unsupported type: " + M.GetType().FullName, nameof(M));
226 }
227
228 }
229}
IdApp.Cv.Matrix
Implements a Matrix, basic component for computations in Image Processing and Computer Vision.
Definition: Matrix.cs:12
IdApp.Cv.Matrix.Height
int Height
Height of matrix (number of rows)
Definition: Matrix.cs:136
IdApp.Cv.Matrix.Data
T[] Data
Underlying data on which the matrix is defined.
Definition: Matrix.cs:114
IdApp.Cv.Matrix.Width
int Width
Width of matrix (number of columns)
Definition: Matrix.cs:120
IdApp.Cv.Matrix.Region
Matrix< T > Region(int Left, int Top, int Width, int Height)
Returns a region of the matrix, as a new matrix.
Definition: Matrix.cs:314
IdApp.Cv.Matrix.Skip
int Skip
Number of elements to skip from the right edge in the underlying data to the left edge of the new row...
Definition: Matrix.cs:233
IdApp.Cv.Matrix.Start
int Start
Start offset of matrix in underlying data.
Definition: Matrix.cs:228
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< int > Convolute(this Matrix< int > M, Matrix< float > Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:139
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< int > Convolute(this Matrix< int > M, IMatrix Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:202
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< int > Convolute(this Matrix< int > M, Matrix< int > Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:100
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< float > Convolute(this Matrix< float > M, IMatrix Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:186
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< float > Convolute(this Matrix< float > M, Matrix< float > Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:20
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static Matrix< float > Convolute(this Matrix< float > M, Matrix< int > Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:60
IdApp.Cv.Transformations.Convolutions.ConvolutionOperations.Convolute
static IMatrix Convolute(this IMatrix M, IMatrix Kernel)
Performs an image convolution on a matrix.
Definition: Convolute.cs:218
IdApp.Cv.IMatrix
Interface for matrices.
Definition: IMatrix.cs:9