public static unsafe void FindMinimum(this IReadOnlyImageFloat <MonoImageType> @this, Box2i box, out Vector2i location, out float value)
{
value = float.PositiveInfinity;
location = new Vector2i();
var step = @this.Step;
using (var pin = @this.Open())
{
var ptr = pin.Ptr + box.MinCorner * step;
for (var j = box.MinY; j <= box.MaxY; j++)
{
var pixelPtr = ptr;
for (var i = box.MinX; i <= box.MaxX; i++)
{
if (*pixelPtr < value)
{
location = new Vector2i(i, j);
value = *pixelPtr;
}
pixelPtr += step.X;
}
ptr += step.Y;
}
}
}
public static IImageFloat <TType> SobelY <TType>(this IReadOnlyImageFloat <TType> @this, int kernelSize)
where TType : IImageType, new()
{
return(@this.
VerticalConvolution(CollinearSobelKernel(kernelSize)).
HorizontalConvolution(TransverseSobelKernel(kernelSize)));
}
public static unsafe IImageFloat <TType> VerticalConvolution <TType>(this IReadOnlyImageFloat <TType> @this, float[] kernel, int topOffset)
where TType : IImageType, new()
{
using (var pinKernel = new PinnedFloatBuffer(kernel))
{
return(VerticalConvolution(@this, pinKernel.Ptr, topOffset, bottomOffset: kernel.Length - topOffset - 1));
}
}
public static unsafe IImageFloat <TType> HorizontalConvolution <TType>(this IReadOnlyImageFloat <TType> @this, float[] kernel, int leftOffset)
where TType : IImageType, new()
{
using (var pinKernel = new PinnedFloatBuffer(kernel))
{
return(HorizontalConvolution(@this, pinKernel.Ptr, leftOffset, rightOffset: kernel.Length - leftOffset - 1));
}
}
public static IImageFloat <TType> GaussianBlur <TType>(this IReadOnlyImageFloat <TType> @this, Vector2 stdev, Vector2i kernelSize)
where TType : IImageType, new()
{
var xGaussian = ComputeGaussian(stdev.X, kernelSize.X);
var yGaussian = ComputeGaussian(stdev.Y, kernelSize.Y);
return(@this.HorizontalConvolution(xGaussian).VerticalConvolution(yGaussian));
}
public static float Min(this IReadOnlyImageFloat <MonoImageType> @this, Box2i box)
{
Vector2i minLocation;
float answer;
@this.FindMinimum(box, out minLocation, out answer);
return(answer);
}
public static Vector2i ArgMin(this IReadOnlyImageFloat <MonoImageType> @this, Box2i box)
{
Vector2i answer;
float minValue;
@this.FindMinimum(box, out answer, out minValue);
return(answer);
}
public static void ComputeSecondDerivatives <TType>
(this IReadOnlyImageFloat <TType> @this,
out IImageFloat <TType> dXX, out IImageFloat <TType> dXY, out IImageFloat <TType> dYY,
int sobelKernelSize)
where TType : IImageType, new()
{
var dX = @this.SobelX(sobelKernelSize);
var dY = @this.SobelY(sobelKernelSize);
dXX = dX.SobelX(sobelKernelSize);
dXY = dX.SobelY(sobelKernelSize);
dYY = dY.SobelY(sobelKernelSize);
}
public static unsafe IImageFloat <TType> Divide <TType>(this IReadOnlyImageFloat <TType> @this, float x)
where TType : IImageType, new()
{
var answer = new ImageFloat <TType>(@this.Dimensions);
var inStep = @this.Step;
var outStep = answer.Step;
var dimensions = @this.Dimensions;
var channelsCount = Singleton <TType> .Instance.ChannelsCount;
using (var pinInput = @this.Open())
{
using (var pinOutput = answer.Open())
{
var inPtr = pinInput.Ptr;
var outPtr = pinOutput.Ptr;
for (var j = 0; j < dimensions.Y; j++)
{
var inPixelPtr = inPtr;
var outPixelPtr = outPtr;
for (var i = 0; i < dimensions.X; i++)
{
for (var c = 0; c < channelsCount; c++)
{
outPixelPtr[c] = inPixelPtr[c] / x;
}
inPixelPtr += inStep.X;
outPixelPtr += outStep.X;
}
inPtr += inStep.Y;
outPtr += outStep.Y;
}
}
}
return(answer);
}
public static unsafe IImageFloat <TType> VerticalConvolution <TType>(this IReadOnlyImageFloat <TType> @this, float *kernel, int radius)
where TType : IImageType, new()
{
return(VerticalConvolution(@this, kernel, topOffset: radius, bottomOffset: radius));
}
public static unsafe IImageFloat <TType> HorizontalConvolution <TType>(this IReadOnlyImageFloat <TType> @this, float *kernel, int radius)
where TType : IImageType, new()
{
return(HorizontalConvolution(@this, kernel, leftOffset: radius, rightOffset: radius));
}
public static IImageFloat <MonoImageType> NormalizeMaximum(this IReadOnlyImageFloat <MonoImageType> @this)
{
return(@this.Divide(@this.Max()));
}
public static float Min(this IReadOnlyImageFloat <MonoImageType> @this)
{
return(@this.Min(@this.Box()));
}
public static void FindMinimum(this IReadOnlyImageFloat <MonoImageType> @this, out Vector2i location, out float value)
{
@this.FindMinimum(@this.Box(), out location, out value);
}
public ReadOnlyImageFloatView(IReadOnlyImageFloat <UType> image, Box2i roi, int channel = 0)
: base(image, roi, channel)
{
_image = image;
}
public ReadOnlyImageFloatView(IReadOnlyImageFloat <UType> image, Vector2i topLeft, Vector2i step, Vector2i dimensions, int channel = 0)
: base(image, topLeft, step, dimensions, channel)
{
_image = image;
}
public unsafe static IImageFloat <TType> HorizontalConvolution <TType>
(this IReadOnlyImageFloat <TType> @this, float *kernel, int leftOffset, int rightOffset)
where TType : IImageType, new()
{
ArgAssert.AtLeast(leftOffset, "leftOffset", 0);
ArgAssert.AtLeast(rightOffset, "rightOffset", 0);
var answer = new ImageFloat <TType>(@this.Dimensions);
var channelsCount = Singleton <TType> .Instance.ChannelsCount;
using (var pinInput = @this.Open())
{
var inPtr = pinInput.Ptr;
using (var pinOutput = answer.Open())
{
var outPtr = pinOutput.Ptr;
for (var j = 0; j < @this.Dimensions.Y; j++)
{
var inPixelPtr = inPtr;
var outPixelPtr = outPtr;
for (var i = 0; i < @this.Dimensions.X; i++)
{
int k = -leftOffset;
var kernelPtr = kernel;
for (; k < -i; k++)
{
for (var c = 0; c < channelsCount; c++)
{
outPixelPtr[c] += *kernelPtr * inPtr[c];
}
kernelPtr++;
}
var rightBound = Math.Min(@this.Dimensions.X - i - 1, rightOffset);
var windowPtr = inPixelPtr + @this.Step.X * k;
for (; k < rightBound; k++)
{
for (var c = 0; c < channelsCount; c++)
{
outPixelPtr[c] += *kernelPtr * windowPtr[c];
}
kernelPtr++;
windowPtr += @this.Step.X;
}
for (; k <= rightOffset; k++)
{
for (var c = 0; c < channelsCount; c++)
{
outPixelPtr[c] += *kernelPtr * windowPtr[c];
}
kernelPtr++;
}
inPixelPtr += @this.Step.X;
outPixelPtr += answer.Step.X;
}
inPtr += @this.Step.Y;
outPtr += answer.Step.Y;
}
}
}
return(answer);
}
public static Vector2i ArgMin(this IReadOnlyImageFloat <MonoImageType> @this)
{
return(@this.ArgMin(@this.Box()));
}
