public static void ApplyConvolutionFilter(IDirectBitmap bitmap, Kernel ker)
{
using (var original = (IDirectBitmap)bitmap.Clone())
{
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
var rsum = 0.0;
var gsum = 0.0;
var bsum = 0.0;
for (var l = 0; l < ker.Width; l++)
{
for (var k = 0; k < ker.Height; k++)
{
var n = NormalizeBounds(x - (l - ker.Width / 2), 0, bitmap.Width);
var m = NormalizeBounds(y - (k - ker.Height / 2), 0, bitmap.Height);
var p = original.GetPixel(n, m);
rsum += ker.Get(k, l) * p.R;
gsum += ker.Get(k, l) * p.G;
bsum += ker.Get(k, l) * p.B;
}
}
var r = ColorRange((int)rsum);
var g = ColorRange((int)gsum);
var b = ColorRange((int)bsum);
bitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
}
});
}
}
public static Color BilinearInterpolaton(this IDirectBitmap bitmat, double x, double y)
{
var xFloor = (int)Math.Floor(x);
var yFloor = (int)Math.Floor(y);
var xCeil = (int)Math.Ceiling(x);
var yCeil = (int)Math.Ceiling(y);
var dx = x - xFloor;
var dy = y - yFloor;
var topLeft = bitmat.GetPixel(NormalizeBounds(xFloor, 0, bitmat.Width),
NormalizeBounds(yFloor, 0, bitmat.Height));
var topRight = bitmat.GetPixel(NormalizeBounds(xCeil, 0, bitmat.Width),
NormalizeBounds(yFloor, 0, bitmat.Height));
var bottomLeft = bitmat.GetPixel(NormalizeBounds(xFloor, 0, bitmat.Width),
NormalizeBounds(yCeil, 0, bitmat.Height));
var bottomRight = bitmat.GetPixel(NormalizeBounds(xCeil, 0, bitmat.Width),
NormalizeBounds(yCeil, 0, bitmat.Height));
var topRed = (1 - dx) * topLeft.R + dx * topRight.R;
var topGreen = (1 - dx) * topLeft.G + dx * topRight.G;
var topBlue = (1 - dx) * topLeft.B + dx * topRight.B;
var bottomRed = (1 - dx) * bottomLeft.R + dx * bottomRight.R;
var bottomGreen = (1 - dx) * bottomLeft.G + dx * bottomRight.G;
var bottomBlue = (1 - dx) * bottomLeft.B + dx * bottomRight.B;
var r = (1 - dy) * topRed + dy * bottomRed;
var g = (1 - dy) * topGreen + dy * bottomGreen;
var b = (1 - dy) * topBlue + dy * bottomBlue;
return(Color.FromArgb(ColorRange((int)r), ColorRange((int)g), ColorRange((int)b)));
}
public static void ProcessGrayWorld(this IDirectBitmap bitmap)
{
double rAvg = 0, gAvg = 0, bAvg = 0;
var bitCount = bitmap.Width * bitmap.Height;
for (var x = 0; x < bitmap.Width; x++)
for (var y = 0; y < bitmap.Height; y++)
{
rAvg += bitmap.GetPixel(x, y).R;
gAvg += bitmap.GetPixel(x, y).G;
bAvg += bitmap.GetPixel(x, y).B;
}
rAvg /= bitCount;
gAvg /= bitCount;
bAvg /= bitCount;
var avg = (rAvg + gAvg + bAvg) / 3;
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
var oldColor = bitmap.GetPixel(x, y);
var r = ColorRange((int)(oldColor.R * avg / rAvg));
var g = ColorRange((int)(oldColor.G * avg / gAvg));
var b = ColorRange((int)(oldColor.B * avg / bAvg));
bitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
}
});
}
public static void Process(this IDirectBitmap bitmap, int radius)
{
using (var original = (IDirectBitmap) bitmap.Clone())
{
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions {MaxDegreeOfParallelism = Environment.ProcessorCount}, y =>
{
var random = new Random(y);
for (var x = 0; x < bitmap.Width; x++)
{
int x1 =
DirectBitmapExtensionBase.NormalizeBounds(
(int) (x + (random.Next(1000) / 1000.0 - 0.5) * radius), 0,
bitmap.Width);
int y1 =
DirectBitmapExtensionBase.NormalizeBounds(
(int) (y + (random.Next(1000) / 1000.0 - 0.5) * radius), 0,
bitmap.Height);
var c = original.GetPixel(x, y);
bitmap.SetPixel(x1, y1, c);
}
});
}
}
public static void Process(this IDirectBitmap bitmap, double sigma)
{
var kerRow = Kernel.GaussRowKernel(sigma);
var kerCol = Kernel.GaussColumnKernel(sigma);
DirectBitmapExtensionBase.ApplyConvolutionFilter(bitmap, kerRow);
DirectBitmapExtensionBase.ApplyConvolutionFilter(bitmap, kerCol);
}
public static void Process(this IDirectBitmap bitmap)
{
for (var i = 0; i < bitmap.Width; i++)
for (var x = 0; x < bitmap.Height; x++)
{
var oc = bitmap.GetPixel(i, x);
var grayScale = (int) (oc.R * 0.3 + oc.G * 0.59 + oc.B * 0.11);
var nc = Color.FromArgb(oc.A, grayScale, grayScale, grayScale);
bitmap.SetPixel(i, x, nc);
}
}
public static void ApplyConvolutionFilter(IDirectBitmap bitmap, Kernel kerX, Kernel kerY)
{
using (var original = (IDirectBitmap)bitmap.Clone())
{
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
}, y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
double rx = 0.0, gx = 0.0, bx = 0.0;
double ry = 0.0, gy = 0.0, by = 0.0;
for (var l = 0; l < kerX.Width; l++)
{
for (var k = 0; k < kerX.Height; k++)
{
var n = NormalizeBounds(x - (l - kerX.Width / 2), 0, bitmap.Width);
var m = NormalizeBounds(y - (k - kerX.Height / 2), 0, bitmap.Height);
if (original != null)
{
var p = original.GetPixel(n, m);
rx += kerX.Get(k, l) * p.R;
bx += kerX.Get(k, l) * p.G;
gx += kerX.Get(k, l) * p.B;
ry += kerY.Get(k, l) * p.R;
@by += kerY.Get(k, l) * p.G;
gy += kerY.Get(k, l) * p.B;
}
}
}
var bsum = Math.Sqrt(bx * bx + @by * @by);
var gsum = Math.Sqrt(gx * gx + gy * gy);
var rsum = Math.Sqrt(rx * rx + ry * ry);
var r = ColorRange((int)rsum);
var g = ColorRange((int)gsum);
var b = ColorRange((int)bsum);
bitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
}
});
}
}
public static void ProcessRotation(this IDirectBitmap bitmap, double angle)
{
angle *= -Math.PI / 180.0;
var cos = Math.Cos(angle);
var sin = Math.Sin(angle);
var point1X = (-bitmap.Height * sin);
var point1Y = (bitmap.Height * cos);
var point2X = (bitmap.Width * cos - bitmap.Height * sin);
var point2Y = (bitmap.Height * cos + bitmap.Width * sin);
var point3X = (bitmap.Width * cos);
var point3Y = (bitmap.Width * sin);
var minx = Math.Min(0, Math.Min(point1X, Math.Min(point2X, point3X)));
var miny = Math.Min(0, Math.Min(point1Y, Math.Min(point2Y, point3Y)));
var maxx = Math.Max(0, Math.Max(point1X, Math.Max(point2X, point3X)));
var maxy = Math.Max(0, Math.Max(point1Y, Math.Max(point2Y, point3Y)));
var destBitmapWidth = (int)Math.Ceiling(Math.Abs(maxx) - minx + 1);
var destBitmapHeight = (int)Math.Ceiling(Math.Abs(maxy) - miny + 1);
using (var original = (IDirectBitmap)bitmap.Clone())
{
bitmap.Resize(destBitmapWidth, destBitmapHeight);
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
var oldX = ((x + minx) * cos + (y + miny) * sin);
var oldY = ((y + miny) * cos - (x + minx) * sin);
var checkRange = oldY >= 0 && oldY < original.Height && oldX >= 0 && oldX < original.Width;
var c = checkRange ? original.BilinearInterpolaton(oldX, oldY) : Color.FromArgb(0, 0, 0);
bitmap.SetPixel(x, y, c);
}
});
}
}
public static void AdjustBrightness(this IDirectBitmap bitmap)
{
byte minR = 255,
maxR = 0,
minG = 255,
maxG = 0,
minB = 255,
maxB = 0;
for (var x = 0; x < bitmap.Width; x++)
for (var y = 0; y < bitmap.Height; y++)
{
var c = bitmap.GetPixel(x, y);
minR = c.R < minR ? c.R : minR;
minG = c.G < minG ? c.G : minG;
minB = c.B < minB ? c.B : minB;
maxR = c.R > maxR ? c.R : maxR;
maxG = c.G > maxG ? c.G : maxG;
maxB = c.B > maxB ? c.B : maxB;
}
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
var oldColor = bitmap.GetPixel(x, y);
var newColor = Color.FromArgb(
(oldColor.R - minR) * 255 / (maxR - minR),
(oldColor.G - minG) * 255 / (maxG - minG),
(oldColor.B - minB) * 255 / (maxB - minB));
bitmap.SetPixel(x, y, newColor);
}
});
}
public static void ProcessScale(this IDirectBitmap bitmap, double scale)
{
using (var original = (IDirectBitmap)bitmap.Clone())
{
var newWidth = (int)(bitmap.Width * scale);
var newHeight = (int)(bitmap.Height * scale);
bitmap.Resize(newWidth, newHeight);
Parallel.For(0, bitmap.Height - 1,
new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
y =>
{
for (var x = 0; x < bitmap.Width; x++)
{
var oldX = x / scale;
var oldY = y / scale;
var c = original.BilinearInterpolaton(oldX, oldY);
bitmap.SetPixel(x, y, c);
}
});
}
}
public static void ProcessMedianFilter(this IDirectBitmap bitmap, int radius)
{
var d = 2 * radius + 1;
var r = d / 2;
using (var original = (IDirectBitmap)bitmap.Clone())
{
Parallel.ForEach(Enumerable.Range(0, bitmap.Height),
new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, y =>
{
var red = new byte[d * d];
var green = new byte[d * d];
var blue = new byte[d * d];
for (var x = 0; x < bitmap.Width; x++)
{
var p = 0;
for (var i = 0; i < d; i++)
{
for (var j = 0; j < d; j++)
{
var xc = NormalizeBounds(x + (i - r), 0, bitmap.Width);
var yc = NormalizeBounds(y + (j - r), 0, bitmap.Height);
var c = original.GetPixel(xc, yc);
red[p] = c.R;
green[p] = c.G;
blue[p] = c.B;
p++;
}
}
var rMed = red.OrderBy(e => e).ElementAt(p / 2);
var gMed = green.OrderBy(e => e).ElementAt(p / 2);
var bMed = blue.OrderBy(e => e).ElementAt(p / 2);
bitmap.SetPixel(x, y, Color.FromArgb(rMed, gMed, bMed));
}
});
}
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.ProcessScale(((ScaleParameter)parameter).Scale);
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.ProcessGrayWorld();
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
var radius = ((MedianFilterParameter)parameter).Radius;
bitmap.ProcessMedianFilter(radius);
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.Process(((GlassParameter)parameter).Radius);
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
DirectBitmapExtensionBase.ApplyConvolutionFilter(bitmap,
new Kernel(((CustomFilterParameter)parameter).Matrix));
bitmap.Process();
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.Process(((GaussianBlurParameter)parameter).Sigma);
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.AdjustBrightness();
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
DirectBitmapExtensionBase.ApplyConvolutionFilter(bitmap, Kernel.Sobel3Horizontal(),
Kernel.Sobel3Vertical());
}
public void Process(IDirectBitmap bitmap, AbstractParameter parameter)
{
bitmap.ProcessRotation(((RotationParameter)parameter).Angle);
}
