/// <summary>
/// Processes the <paramref name="inputImage"/>.
/// </summary>
/// <param name="inputImage">Image to process.</param>
/// <returns>Processed image.</returns>
public override Image Process(Image inputImage)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
int[] factors = MakeBinominalFactors(KernelSize.GetKernelNumber());
int[] weights = MakeWeights(factors);
var bounds = this.GetProcessingBounds(inputImage);
int weightSum = weights.Sum();
if (ProcessAllPlanes)
{
foreach (var plane in inputImage.Planes)
{
ProcessPlane(plane, weights, bounds, weightSum);
}
}
else
{
ProcessPlane(inputImage.Planes[PlaneIndex], weights, bounds, weightSum);
}
return(inputImage);
}
protected override void EncodeParameterCore(ref string res)
{
res += OutScale.ToString() + " ";
res += KernelSize.ToString() + " ";
res += KernelExpand.ToString() + " ";
res += OptimizerType.ToString() + " ";
res += Rho.ToString() + " ";
}
public override void InitializeParameters()
{
//focusDistance
if ((m_fromSettings != null && m_fromSettings.active && m_fromSettings.focusDistance.overrideState) ||
(m_toSettings != null && m_toSettings.active && m_toSettings.focusDistance.overrideState))
{
m_tempSettings.focusDistance.overrideState = true;
}
else
{
m_tempSettings.focusDistance.overrideState = false;
}
focusDistance.x = m_fromSettings != null && m_fromSettings.active && m_fromSettings.focusDistance.overrideState ? m_fromSettings.focusDistance.value : m_tempSettings.focusDistance.value;
focusDistance.y = m_toSettings != null && m_toSettings.active && m_toSettings.focusDistance.overrideState ? m_toSettings.focusDistance.value : m_tempSettings.focusDistance.value;
//aperture
if ((m_fromSettings != null && m_fromSettings.active && m_fromSettings.aperture.overrideState) ||
(m_toSettings != null && m_toSettings.active && m_toSettings.aperture.overrideState))
{
m_tempSettings.aperture.overrideState = true;
}
else
{
m_tempSettings.aperture.overrideState = false;
}
aperture.x = m_fromSettings != null && m_fromSettings.active && m_fromSettings.aperture.overrideState ? m_fromSettings.aperture.value : m_tempSettings.aperture.value;
aperture.y = m_toSettings != null && m_toSettings.active && m_toSettings.aperture.overrideState ? m_toSettings.aperture.value : m_tempSettings.aperture.value;
//focalLength
if ((m_fromSettings != null && m_fromSettings.active && m_fromSettings.focalLength.overrideState) ||
(m_toSettings != null && m_toSettings.active && m_toSettings.focalLength.overrideState))
{
m_tempSettings.focalLength.overrideState = true;
}
else
{
m_tempSettings.focalLength.overrideState = false;
}
focalLength.x = m_fromSettings != null && m_fromSettings.active && m_fromSettings.focalLength.overrideState ? m_fromSettings.focalLength.value : m_tempSettings.focalLength.value;
focalLength.y = m_toSettings != null && m_toSettings.active && m_toSettings.focalLength.overrideState ? m_toSettings.focalLength.value : m_tempSettings.focalLength.value;
//kernelSize
if ((m_fromSettings != null && m_fromSettings.active && m_fromSettings.kernelSize.overrideState) ||
(m_toSettings != null && m_toSettings.active && m_toSettings.kernelSize.overrideState))
{
m_tempSettings.kernelSize.overrideState = true;
}
else
{
m_tempSettings.kernelSize.overrideState = false;
}
fromKernelSize = m_fromSettings != null && m_fromSettings.active && m_fromSettings.kernelSize.overrideState ? m_fromSettings.kernelSize.value : m_tempSettings.kernelSize.value;
toKernelSize = m_toSettings != null && m_toSettings.active && m_toSettings.kernelSize.overrideState ? m_toSettings.kernelSize.value : m_tempSettings.kernelSize.value;
}
/// <summary>
/// Calculate a laplace kernel for the given <paramref name="kernelSize"/>.
/// </summary>
/// <param name="kernelSize">Kernel size to calculate laplace kernel for.</param>
/// <returns>Calculated laplace kernel.</returns>
private static int[] CalculateKernel(KernelSize kernelSize)
{
int kernelNum = kernelSize.GetKernelNumber();
int fullKernelNum = kernelNum * kernelNum;
var kernel = new int[fullKernelNum];
for (int i = 0; i < kernel.Length; i++)
{
kernel[i] = 1;
}
kernel[(int)System.Math.Floor(fullKernelNum / 2.0)] = 1 - fullKernelNum;
return(kernel);
}
internal Kernel(KernelSize size)
{
Size = (uint)size;
ConvolutionMatrix = new double[Size, Size];
uint count = Size * Size;
for (uint x = 0; x < Size; x++)
{
for (uint y = 0; y < Size; y++)
{
ConvolutionMatrix[x, y] = 1.0 / count;
}
}
}
public override void Reset()
{
ActiveLayer = true;
ActiveEffect = true;
ObjectProfile = null;
FocusDistanceActive = true;
FocusDistance = 0f;
ApertureActive = true;
Aperture = 0f;
FocalActive = true;
FocalLength = 0;
MaxBlurActive = true;
MaxBlur = 0;
everyFrame = false;
}
public ImageBlur(KernelSize kernelSize, int blurAmount)
{
switch (kernelSize)
{
case KernelSize.Small:
this.kernelSize = 5; break;
case KernelSize.Medium:
this.kernelSize = 7; break;
case KernelSize.Large:
this.kernelSize = 11; break;
}
this.blurAmount = blurAmount;
}
public ImageBlur(Bitmap bitmap, KernelSize kernelSize, int blurAmount)
{
bmp = bitmap.Clone(new Rectangle(0, 0, bitmap.Width, bitmap.Height), bitmap.PixelFormat);
switch (kernelSize)
{
case KernelSize.Small:
this.kernelSize = 5; break;
case KernelSize.Medium:
this.kernelSize = 7; break;
case KernelSize.Large:
this.kernelSize = 11; break;
}
this.blurAmount = blurAmount;
}
public void SetKernelSize(KernelSize size)
{
if (this.Size != size)
{
if (size == KernelSize.Five)
{
this.Values = kernelValues5X5;
}
else
{
this.Values = kernelValues3X3;
}
this.Size = size;
}
}
/// <summary>
/// Gets the number representing the given <paramref name="kernel"/>.
/// </summary>
/// <param name="kernel">Size to get number representation for.</param>
/// <returns>Number representation for the given <paramref name="kernel"/>.</returns>
public static int GetKernelNumber(this KernelSize kernel)
{
switch (kernel)
{
case KernelSize.ThreeByThree:
return(3);
case KernelSize.FiveByFive:
return(5);
case KernelSize.SevenBySeven:
return(7);
default:
throw new ArgumentException("Unknown kernel size", nameof(kernel));
}
}
public KernelSizeValue(KernelSizeParameter parameter)
{
value = parameter.value;
overrideState = parameter.overrideState;
}
public KernelSizeValue(KernelSize value, bool overrideState)
{
this.value = value;
this.overrideState = overrideState;
}
public static ImagePlane ProcessMonoKernel(ImagePlane plane, Func <byte?[], byte> processingFunc, KernelSize kernel, ProcessingBounds bounds)
{
if (plane.TryGetLinearAccess(out LinearAccessData data))
{
var newImage = Image.FromPlanes(MappingOption.CopyPixels, plane);
var newData = newImage.Planes[0].GetLinearAccess();
var yInc = (int)data.YInc;
var xInc = (int)data.XInc;
var newYInc = (int)newData.YInc;
var newXInc = (int)newData.XInc;
int boundHeight = plane.Parent.Height - 1;
int boundWidth = plane.Parent.Width - 1;
int startY = bounds.StartY;
int startX = bounds.StartX;
int boundsY = startY + bounds.Height;
int boundsX = startX + bounds.Width;
int kernelSize = kernel.GetKernelNumber();
int kernelArrSize = kernelSize * kernelSize;
var kernelFac = (int)System.Math.Floor(kernelSize / 2.0);
unsafe
{
var pBase = (byte *)data.BasePtr;
var pBaseNew = (byte *)newData.BasePtr;
Parallel.For(startY, boundsY, (y) =>
{
var kernelValues = new byte?[kernelArrSize];
var pLine = pBase + y * yInc;
int newLineInc = newYInc * y;
for (int x = startX; x < boundsX; x++)
{
int kernelCounter = -1;
var pMiddle = pLine + xInc * x;
for (int kRow = -kernelFac; kRow <= kernelFac; kRow++)
{
byte *pKLine = pMiddle + kRow * yInc;
int yKRow = y + kRow;
for (int kColumn = -kernelFac; kColumn <= kernelFac; kColumn++)
{
kernelCounter++;
int xKColumn = x + kColumn;
if (yKRow < 0 || yKRow > boundHeight || xKColumn < 0 || xKColumn > boundWidth)
{
continue;
}
byte *pPixel = pKLine + kColumn * xInc;
kernelValues[kernelCounter] = *pPixel;
}
}
if (kernelValues.Any(b => b.HasValue))
{
var pTargetLine = pBaseNew + newLineInc;
var pTargetPixel = pTargetLine + newXInc * x; // current "middle pixel" in the target image
*pTargetPixel = processingFunc.Invoke(kernelValues);
}
}
});
}
return(newImage.Planes[0]);
}
else
{
throw new ArgumentException("Plane could not be accessed linear", nameof(plane));
}
}
public static ImagePlane ProcessMonoKernel(ImagePlane plane, Func <byte?[], byte> processingFunc, KernelSize kernel)
{
return(ProcessMonoKernel(plane, processingFunc, kernel, new ProcessingBounds(plane.Parent.Bounds)));
}
public static ImagePlane ProcessMonoKernel(ImagePlane plane, Func <byte?[], byte> processingFunc, KernelSize kernel, PixelFilterChain filterChain)
{
if (filterChain == null || !filterChain.HasActiveFilter)
{
return(ProcessMonoKernel(plane, processingFunc, kernel));
}
else
{
return(ProcessMonoKernel(plane, processingFunc, kernel, new ProcessingBounds(plane.Parent.Bounds), filterChain));
}
}
static KernelSize Field(string label, KernelSize val, bool draw = true)
{
return((KernelSize)Field(label, (int)val, 0, 3, val.ToString(), draw));
}
public static Kernel Neighborhood(KernelSize size = KernelSize.SIZE_3x3)
{
return(new Kernel(size));
}
