private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
return((byte)(b >= Threshold ? 255 : 0));
}, PixelFilter);
}
private void ProcessPlane(ImagePlane plane, Func <int, byte, byte> calculationFunc, ProcessingBounds bounds)
{
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
return(calculationFunc(ValueProvider.Provide(), b));
}, PixelFilter);
}
/// <summary>
/// Scales the image using bilinear interpolation.
/// </summary>
/// <param name="inputImage">Image to scale.</param>
/// <param name="newSize">Size to resize to.</param>
/// <returns>Scaled image.</returns>
private Image ProcessBiliniar(Image inputImage, Size2D newSize)
{
var newImage = new Image(newSize, inputImage.Planes.Count);
double scaleX = (double)(inputImage.Width - 1) / newSize.Width;
double scaleY = (double)(inputImage.Height - 1) / newSize.Height;
for (int i = 0; i < inputImage.Planes.Count; i++)
{
byte[,] inputBytes = inputImage.Planes[i].GetPixelsAs2DArray();
ProcessingHelper.ProcessMono(newImage.Planes[i], (b, y, x) =>
{
var pY = (int)(scaleY * y);
double yDiff = (scaleY * y) - pY;
var pX = (int)(scaleX * x);
double xDiff = (scaleX * x) - pX;
return((byte)(inputBytes[pY, pX] * (1 - xDiff) * (1 - yDiff) +
inputBytes[pY, pX + 1] * (1 - yDiff) * xDiff +
inputBytes[pY + 1, pX] * yDiff * (1 - xDiff) +
inputBytes[pY + 1, pX + 1] * yDiff * xDiff));
});
}
return(newImage);
}
private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
return(ValueProvider.Provide());
}, PixelFilter);
}
private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
var valueDic = BuildValueDictionary(Mode, plane, bounds);
ProcessingHelper.ProcessMono(plane, bounds, (b, y, x) =>
{
return((Mode == SmearMode.VerticalFromTop || Mode == SmearMode.VerticalFromBottom) ? valueDic[x] : valueDic[y]);
}, PixelFilter);
}
/// <summary>
/// Scales the image using nearest neighbor interpolation.
/// </summary>
/// <param name="inputImage">Image to scale.</param>
/// <param name="newSize">Size to resize to.</param>
/// <returns>Scaled image.</returns>
private static Image ProcessNearestNeighbor(Image inputImage, Size2D newSize)
{
var newImage = new Image(newSize, inputImage.Planes.Count);
double scaleX = newSize.Width / (double)inputImage.Width;
double scaleY = newSize.Height / (double)inputImage.Height;
for (int i = 0; i < inputImage.Planes.Count; i++)
{
byte[,] inputBytes = inputImage.Planes[i].GetPixelsAs2DArray();
ProcessingHelper.ProcessMono(newImage.Planes[i], (b, y, x) =>
{
var yUnscaled = (int)(y / scaleY);
var xUnscaled = (int)(x / scaleX);
return(inputBytes[yUnscaled, xUnscaled]);
});
}
return(newImage);
}
/// <summary>
/// Applies the gain value
/// to the given <paramref name="inputImage"/>.
/// </summary>
/// <param name="inputImage">Image to apply gain to.</param>
/// <returns>Processed image.</returns>
public Image Process(Image inputImage)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
ProcessingHelper.ProcessRGB(inputImage, (rgb) =>
{
byte r = WrapAroundR ? (byte)ProcessingHelper.ClampPixelValue((rgb.R * FactorRR) + (rgb.G * FactorRG) + (rgb.B * FactorRB))
: (byte)((rgb.R * FactorRR) + (rgb.G * FactorRG) + (rgb.B * FactorRB));
byte g = WrapAroundG ? (byte)ProcessingHelper.ClampPixelValue((rgb.R * FactorGR) + (rgb.G * FactorGG) + (rgb.B * FactorGB))
: (byte)((rgb.R * FactorGR) + (rgb.G * FactorGG) + (rgb.B * FactorGB));
byte b = WrapAroundB ? (byte)ProcessingHelper.ClampPixelValue((rgb.R * FactorBR) + (rgb.G * FactorBG) + (rgb.B * FactorBB))
: (byte)((rgb.R * FactorBR) + (rgb.G * FactorBG) + (rgb.B * FactorBB));
return(new RGBPixel(r, g, b));
}, this.GetProcessingBounds(inputImage), PixelFilter);
return(inputImage);
}
private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
if (ShiftDirection == BitShiftDirection.Left)
{
int pixelValue = b << ValueProvider.Provide();
if (WrapAround && pixelValue > 255)
{
return(255);
}
else
{
return((byte)pixelValue);
}
}
else
{
return((byte)(b >> ValueProvider.Provide()));
}
}, PixelFilter);
}
private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
int byteCounter = 0;
byte[] sortedBytes;
unsafe
{
if (UseAOI)
{
if (Mode == SortMode.Ascending)
{
sortedBytes = plane.GetAllPixelsIn(AOI).Select(p => *(byte *)p).OrderBy(i => i).ToArray();
}
else
{
sortedBytes = plane.GetAllPixelsIn(AOI).Select(p => *(byte *)p).OrderByDescending(i => i).ToArray();
}
}
else
{
if (Mode == SortMode.Ascending)
{
sortedBytes = plane.AllPixels.Select(p => *(byte *)p).OrderBy(i => i).ToArray();
}
else
{
sortedBytes = plane.AllPixels.Select(p => *(byte *)p).OrderByDescending(i => i).ToArray();
}
}
}
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
return(sortedBytes[byteCounter++]);
}, PixelFilter);
}
private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
var rnd = new Random(DateTime.Now.Ticks.GetHashCode());
int byteCounter = 0;
byte[] shuffledBytes;
unsafe
{
if (UseAOI)
{
shuffledBytes = plane.GetAllPixelsIn(AOI).Select(p => *(byte *)p).OrderBy(i => rnd.Next()).ToArray();
}
else
{
shuffledBytes = plane.AllPixels.Select(p => *(byte *)p).OrderBy(i => rnd.Next()).ToArray();
}
}
ProcessingHelper.ProcessMono(plane, bounds, (b) =>
{
return(shuffledBytes[byteCounter++]);
}, PixelFilter);
}
