private void ProcessPlane(ImagePlane plane, ProcessingBounds bounds)
{
if (plane.TryGetLinearAccess(out LinearAccessData data))
{
int startY = bounds.StartY;
int startX = bounds.StartX;
int boundsY = startY + bounds.Height;
int boundsX = startX + bounds.Width;
int imageHeight = plane.Parent.Height;
int imageWidth = plane.Parent.Width;
var yInc = (int)data.YInc;
var xInc = (int)data.XInc;
unsafe
{
var pBase = (byte *)data.BasePtr;
for (int yy = bounds.StartY; yy < boundsY; yy += PixelateSize)
{
int offsetY = PixelateSize / 2;
int yyPixelateSize = yy + PixelateSize;
for (int xx = bounds.StartX; xx < boundsX; xx += PixelateSize)
{
int offsetX = PixelateSize / 2;
int xxPixelateSize = xx + PixelateSize;
while (xx + offsetX >= imageWidth)
{
offsetX--;
}
while (yy + offsetY >= imageHeight)
{
offsetY--;
}
byte *pPixelatedPixel = pBase + ((yy + offsetY) * yInc) + ((xx + offsetX) * xInc);
for (int y = yy; y < yyPixelateSize && y < imageHeight; y++)
{
byte *pLine = pBase + yInc * y;
for (int x = xx; x < xxPixelateSize && x < imageWidth; x++)
{
byte *pPixel = pLine + xInc * x;
if (PixelFilter.Check(*pPixel, y * boundsY + x))
{
*pPixel = *pPixelatedPixel;
}
}
}
}
}
}
}
else
{
throw new ArgumentException("Plane could not be accessed linearly", nameof(plane));
}
}
private void ProcessPlane(ImagePlane inputPlane, ImagePlane newPlane, ProcessingBounds bounds)
{
if (inputPlane.TryGetLinearAccess(out LinearAccessData inputData))
{
if (newPlane.TryGetLinearAccess(out LinearAccessData newData))
{
var inputYInc = (int)inputData.YInc;
var inputXInc = (int)inputData.XInc;
var newYInc = (int)newData.YInc;
var newXInc = (int)newData.XInc;
int boundsY = bounds.StartY + bounds.Height;
int boundsX = bounds.StartX + bounds.Width;
unsafe
{
var inputPBase = (byte *)inputData.BasePtr;
var newPBase = (byte *)newData.BasePtr;
for (int y = bounds.StartY; y < boundsY; y++)
{
byte *inputPLine = inputPBase + inputYInc * y;
byte *newPLine;
int newY = y + ShiftY;
if (newY < boundsY)
{
newPLine = newPBase + newYInc * newY;
}
else if (Wrap)
{
newPLine = newPBase + newYInc * (newY - boundsY);
}
else
{
continue;
}
for (int x = bounds.StartX; x < boundsX; x++)
{
byte *inputPPixel = inputPLine + inputXInc * x;
byte *newPPixel;
int newX = x + ShiftX;
if (newX < boundsX)
{
newPPixel = newPLine + newXInc * newX;
}
else if (Wrap)
{
newPPixel = newPLine + newXInc * (newX - boundsX);
}
else
{
continue;
}
if (PixelFilter.Check(*inputPPixel, y * boundsY + x))
{
*newPPixel = *inputPPixel;
}
}
}
}
}
else
{
throw new ArgumentException("New plane could not be accessed linear");
}
}
else
{
throw new ArgumentException("Input plane could not be accessed linear");
}
}
/// <summary>
/// Processes the <paramref name="inputImage"/>.
/// </summary>
/// <param name="inputImage">Image to process.</param>
/// <returns>Processed image.</returns>
public Image Process(Image inputImage)
{
if (inputImage == null)
{
throw new ArgumentNullException(nameof(inputImage));
}
if (inputImage.Planes[PlaneIndex].TryGetLinearAccess(out LinearAccessData inputData))
{
double midPointY = inputImage.Height / 2;
double midPointX = inputImage.Width / 2;
int height = inputImage.Height;
int width = inputImage.Width;
double cos = System.Math.Cos(Angle.Rad);
double sin = System.Math.Sin(Angle.Rad);
Image rotatedImage;
if (FitImage)
{
var newHeight = System.Math.Abs(width * sin) + System.Math.Abs(height * cos);
var newWidth = System.Math.Abs(width * cos) + System.Math.Abs(height * sin);
rotatedImage = new Image((int)newWidth, (int)newHeight, inputImage.Planes.Count);
}
else
{
rotatedImage = new Image(inputImage.Size, inputImage.Planes.Count);
}
for (int i = 0; i < inputImage.Planes.Count; i++)
{
if (i != PlaneIndex)
{
inputImage.Planes[i].CopyTo(rotatedImage.Planes[i]);
}
else
{
rotatedImage.Planes[i].Initialize(FillValue);
}
}
int offsetX = (int)((rotatedImage.Width / 2) - midPointX);
int offsetY = (int)((rotatedImage.Height / 2) - midPointY);
var rotatedData = rotatedImage.Planes[PlaneIndex].GetLinearAccess();
int inputYInc = (int)inputData.YInc;
int inputXInc = (int)inputData.XInc;
int rotatedYInc = (int)rotatedData.YInc;
int rotatedXInc = (int)rotatedData.XInc;
var rotatedWidth = rotatedImage.Width;
var rotatedHeight = rotatedImage.Height;
unsafe
{
byte *pBaseIn = (byte *)inputData.BasePtr;
byte *pBaseRo = (byte *)rotatedData.BasePtr;
for (int y = 0; y < height; y++)
{
byte *inputPLine = pBaseIn + inputYInc * y;
for (int x = 0; x < width; x++)
{
byte *inputPPixel = inputPLine + inputXInc * x;
var newP = RotatePoint(x, y, midPointX, midPointY, cos, sin, offsetX, offsetY);
if (FitImage)
{
if (PixelFilter.Check(*inputPPixel, y * height + x) && newP.X < rotatedWidth && newP.Y < rotatedHeight)
{
byte *rotatedPPixel = pBaseRo + rotatedYInc * newP.Y + rotatedXInc * newP.X;
* rotatedPPixel = *inputPPixel;
}
}
else if (newP.X < width && newP.X >= 0 && newP.Y < height && newP.Y >= 0 && PixelFilter.Check(*inputPPixel, y * height + x))
{
byte *rotatedPPixel = pBaseRo + rotatedYInc * newP.Y + rotatedXInc * newP.X;
* rotatedPPixel = *inputPPixel;
}
}
}
}
return(rotatedImage);
}
else
{
throw new ArgumentException("Input image could not be accessed linearly", nameof(inputImage));
}
}