public static float Accumulate(this Kernel2D <short> kernel,
Image <float> image, int centerPixelIndex)
{
var kernelIndex = 0;
var sum = 0f;
var pixelBuffer = image.Buffer;
var negativeBound = kernel.Bounds.negative;
var positiveBound = kernel.Bounds.positive;
for (var y = negativeBound.y; y <= positiveBound.y; y++)
{
var rowOffset = y * image.Width;
var rowIndex = centerPixelIndex + rowOffset;
for (var x = negativeBound.x; x <= positiveBound.x; x++)
{
var pixelIndex = rowIndex + x;
var inputPixelValue = pixelBuffer[pixelIndex];
var kernelMultiplier = kernel.Weights[kernelIndex];
sum += inputPixelValue * kernelMultiplier;
kernelIndex++;
}
}
return((short)sum);
}
public override void Apply(Image image)
{
Kernel kernel = new Kernel2D(1.0f / 9.0f);
//kernel.SetKernelValues(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
kernel.SetKernelValues(1, 1, 1, 1, 1, 1, 1, 1, 1);
ApplyKernel(image, kernel);
}
public void ConvolutionWithIdentityKernel_OutputEqualsInput_3x3()
{
var kernel = new Kernel2D <short>(Kernels.Short.Identity3x3);
var convolution = new Convolution2D <short>(kernel, 1, 1);
convolution.Convolve(m_InputImage, m_IntermediateImage);
// TODO - iterate through, check padding ?
convolution.Dispose();
}
public void ConvolutionWithIdentityKernel_OutputEqualsInput_1x1()
{
var kernel = new Kernel2D <short>(Kernels.Short.Identity1x1);
var convolution = new Convolution2D <short>(kernel, 1, 0);
convolution.Convolve(m_InputImage, m_IntermediateImage);
m_InputImage.Buffer.AssertDeepEqual(m_IntermediateImage.Buffer);
convolution.Dispose();
}
public void GetRow()
{
var kernel = new Kernel2D <short>(Kernels.Short.Sobel.X, Allocator.Temp);
var row = kernel.GetRow(1);
Assert.AreEqual(row[0], Kernels.Short.Sobel.X[1, 0]);
Assert.AreEqual(row[1], Kernels.Short.Sobel.X[1, 1]);
Assert.AreEqual(row[2], Kernels.Short.Sobel.X[1, 2]);
kernel.Dispose();
}
public void BracketAccessorsWork()
{
var kernel = new Kernel2D <short>(3, 3, Allocator.Temp);
kernel[0, 0] = 10;
kernel[0, 2] = 20;
Assert.AreEqual(10, kernel[0, 0]);
Assert.AreEqual(20, kernel[0, 2]);
kernel.Dispose();
}
public void ConstructBlankFromDimensions(short x, short y)
{
var kernel = new Kernel2D <short>(x, y, Allocator.Temp);
Assert.IsTrue(kernel.Weights.IsCreated);
Assert.AreEqual(x, kernel.Width);
Assert.AreEqual(y, kernel.Height);
Assert.AreEqual(x * y, kernel.Weights.Length);
kernel.Dispose();
}
public void SeparatedResultIsTheSame()
{
var kX = new Kernel2D <short>(Kernels.Short.Sobel.xHorizontal);
var kY = new Kernel2D <short>(Kernels.Short.Sobel.xVertical);
KernelOperations.RunHorizontal1D(m_GrayTextureData8, m_SobelTextureDataX, kX,
m_GrayScaleTexture8.width, m_GrayScaleTexture8.height);
KernelOperations.RunVertical1D(m_SobelTextureDataX, m_SobelTextureDataCombined, kY,
m_GrayScaleTexture8.width, m_GrayScaleTexture8.height);
}
public void GetColumn()
{
var sobel = Kernels.Short.Sobel.X;
var kernel = new Kernel2D <short>(sobel, Allocator.Temp);
var column = kernel.GetColumn(1);
Assert.AreEqual(column[0], sobel[0, 1]);
Assert.AreEqual(column[1], sobel[1, 1]);
Assert.AreEqual(column[2], sobel[2, 1]);
kernel.Dispose();
}
public void ContructFrom1dInput_Vertical()
{
var kernelLength = Kernels.Short.Sobel.yHorizontal.Length;
var sY = new Kernel2D <short>(Kernels.Short.Sobel.yVertical, false, Allocator.Temp);
sY.Print();
Assert.AreEqual(1, sY.Width);
Assert.AreEqual(kernelLength, sY.Height);
Assert.AreEqual(kernelLength, sY.Weights.Length);
sY.Dispose();
}
public void VerifyGetBounds_SquareKernels(int size, Vector2Int nBound, Vector2Int pBound)
{
var count = size * size;
var kernel = new Kernel2D <short>(size, size, Allocator.Temp);
Assert.AreEqual(count, kernel.Weights.Length);
Debug.Log(kernel.Bounds);
Assert.AreEqual(nBound, kernel.Bounds.negative);
Assert.AreEqual(pBound, kernel.Bounds.positive);
kernel.Dispose();
}
public void ContructFrom2dInput()
{
var sY = new Kernel2D <short>(Kernels.Short.Sobel.X, Allocator.Temp);
sY.Print();
AssertFlatRepresentationValid(Kernels.Short.Sobel.X, sY.Weights);
sY.Dispose();
var sX = new Kernel2D <short>(Kernels.Short.Sobel.Y, Allocator.Temp);
sX.Print();
AssertFlatRepresentationValid(Kernels.Short.Sobel.Y, sX.Weights);
sX.Dispose();
}
public static void Print <T>(this Kernel2D <T> kernel)
where T : struct
{
s_String.Length = 0;
var matrix = kernel.Weights;
for (int y = 0; y < kernel.Height; y++)
{
var rowIndex = y * kernel.Width;
for (int x = 0; x < kernel.Width - 1; x++)
{
s_String.AppendFormat("{0}, ", matrix[rowIndex + x]);
}
s_String.AppendLine(matrix[rowIndex + kernel.Width - 1].ToString()); // end of row, no comma
}
Debug.Log(s_String);
}
public void ConvolutionWith_1x1Stride_1x1Pad(int width, int height,
float[,] kernelInput, float[] input, float[] expectedInput)
{
var kernel = new Kernel2D <float>(kernelInput, Allocator.Temp);
var convolution = new Convolution2D <float>(kernel, 1, 1);
var image = new Image <float>(input, width, height, Allocator.Temp);
var outWidth = width - convolution.Padding.x * 2;
var outHeight = height - convolution.Padding.y * 2;
var expected = new Image <float>(expectedInput, width, height, Allocator.Temp);
var output = new Image <float>(outWidth, outHeight, Allocator.Temp);
convolution.Convolve(image, output);
output.Print();
expected.AssertEqualWithin(output);
convolution.Dispose();
image.Dispose();
output.Dispose();
expected.Dispose();
}
public override void Apply(Image image)
{
//TODO: keep start image in value
Image temp_img = image;
Kernel kernel = new Kernel2D(1.0f);
