/// <summary>
///
/// </summary>
/// <param name="layer"></param>
/// <param name="indirectFilter"></param>
public void Apply(string name, int border, ImageIndirectFilter filter)
{
int width;
BitmapData bdCurrent, bdOriginal;
Bitmap original;
IndirectFilterGetDelegate getDelegateParent;
PixelGet getDelegate;
original = new Bitmap(this.image);
bdOriginal = Lock(ref original, ImageLockMode.ReadWrite, out width);
bdCurrent = Lock(ref this.image, ImageLockMode.ReadWrite, out width);
getDelegateParent = new IndirectFilterGetDelegate(width, original, bdOriginal);
int min_i = Math.Max(border, this.activeRegion.Left);
int max_i = Math.Min(this.activeRegion.Right, this.activeRegion.Right - border);
int min_j = Math.Max(border, this.activeRegion.Top);
int max_j = Math.Min(this.activeRegion.Bottom, this.activeRegion.Bottom - border);
unsafe
{
PixelData *pPixel;
getDelegate = new PixelGet(getDelegateParent.GetPixel);
for (int j = min_j; j < max_j; j++)
{
pPixel = (PixelData *)(((byte *)bdCurrent.Scan0.ToPointer()) + j * width + this.activeRegion.Left * sizeof(PixelData));
for (int i = min_i; i < max_i; i++, pPixel++)
{
filter(i, j, getDelegate, pPixel, this.activeRegion.Left, this.activeRegion.Top, this.activeRegion.Right - 1, this.activeRegion.Bottom - 1);
}
}
}
this.image.UnlockBits(bdCurrent);
original.UnlockBits(bdOriginal);
OnChanged(new ImageChangedEventArgs(name, original));
}
public void Init()
{
bool fastPath = bmp.PixelFormat == PixelFormat.Format32bppRgb ||
bmp.PixelFormat == PixelFormat.Format32bppArgb ||
bmp.PixelFormat == PixelFormat.Format24bppRgb;
if (!fastPath)
{
Get = GetGenericPixel; return;
}
// We can only use the fast path for 24bpp or 32bpp bitmaps
Rectangle r = new Rectangle(0, 0, bmp.Width, bmp.Height);
data = bmp.LockBits(r, ImageLockMode.ReadOnly, bmp.PixelFormat);
scan0 = (byte *)data.Scan0;
stride = data.Stride;
if (bmp.PixelFormat == PixelFormat.Format24bppRgb)
{
Get = Get24BppPixel;
}
else
{
Get = Get32BppPixel;
}
}
protected unsafe void applyConvolution3x3(int x, int y, PixelGet getPixel, PixelData *pPixel)
{
var pPixelClone1 = getPixel(x - 1, y + 1);
var pPixelClone2 = getPixel(x, y + 1);
var pPixelClone3 = getPixel(x + 1, y + 1);
var pPixelClone4 = getPixel(x - 1, y);
var pPixelClone5 = getPixel(x, y);
var pPixelClone6 = getPixel(x + 1, y);
var pPixelClone7 = getPixel(x - 1, y - 1);
var pPixelClone8 = getPixel(x, y - 1);
var pPixelClone9 = getPixel(x + 1, y - 1);
int tmp = Offset + (_matrix[0] * pPixelClone1->red + _matrix[1] * pPixelClone2->red + _matrix[2] * pPixelClone3->red
+ _matrix[3] * pPixelClone4->red + _matrix[4] * pPixelClone5->red + _matrix[5] * pPixelClone6->red
+ _matrix[6] * pPixelClone7->red + _matrix[7] * pPixelClone8->red + _matrix[8] * pPixelClone9->red) / Weight;
pPixel->red = (byte)((tmp >= 0) ? ((tmp <= 255) ? tmp : 255) : 0);
tmp = Offset + (_matrix[0] * pPixelClone1->green + _matrix[1] * pPixelClone2->green + _matrix[2] * pPixelClone3->green
+ _matrix[3] * pPixelClone4->green + _matrix[4] * pPixelClone5->green + _matrix[5] * pPixelClone6->green
+ _matrix[6] * pPixelClone7->green + _matrix[7] * pPixelClone8->green + _matrix[8] * pPixelClone9->green) / Weight;
pPixel->green = (byte)((tmp >= 0) ? ((tmp <= 255) ? tmp : 255) : 0);
tmp = Offset + (_matrix[0] * pPixelClone1->blue + _matrix[1] * pPixelClone2->blue + _matrix[2] * pPixelClone3->blue
+ _matrix[3] * pPixelClone4->blue + _matrix[4] * pPixelClone5->blue + _matrix[5] * pPixelClone6->blue
+ _matrix[6] * pPixelClone7->blue + _matrix[7] * pPixelClone8->blue + _matrix[8] * pPixelClone9->blue) / Weight;
pPixel->blue = (byte)((tmp >= 0) ? ((tmp <= 255) ? tmp : 255) : 0);
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
var ratio = this.Threshold / 100.0;
var grayscaled = 0.299 * pPixel->red + 0.587 * pPixel->green + 0.114 * pPixel->blue;
var max_diff = 0.0;
var max_temp = 0.0;
var pPixels = new[]
{
getPixel(x - 1, y + 1),
getPixel(x, y + 1),
getPixel(x + 1, y + 1),
getPixel(x - 1, y),
getPixel(x + 1, y),
getPixel(x - 1, y - 1),
getPixel(x, y - 1),
getPixel(x + 1, y - 1)
};
foreach (PixelData *pCurrent in pPixels)
{
max_temp = Math.Abs((0.299 * pCurrent->red + 0.587 * pCurrent->green + 0.114 * pCurrent->blue) - grayscaled);
if (max_temp > max_diff)
{
max_diff = max_temp;
}
}
var mask = 1.0 / (max_diff / Math.Sqrt(grayscaled + 1.0) / 3.0 + 1.0);
pPixel->red = pPixel->green = pPixel->blue = (byte)(grayscaled + ratio * ((255 - grayscaled) * mask - max_diff * grayscaled / 100.0));
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
PixelData *localPixel = pPixel;
PixelData *localPixel1 = getPixel(x + 1, y);
PixelData *localPixel2 = getPixel(x, y + 1);
if (((localPixel->red - localPixel1->red) * (localPixel->red - localPixel1->red)) +
((localPixel->green - localPixel1->green) * (localPixel->green - localPixel1->green)) +
((localPixel->blue - localPixel1->blue) * (localPixel->blue - localPixel1->blue)) >= (this.Threshold * this.Threshold)
||
((localPixel->red - localPixel2->red) * (localPixel->red - localPixel2->red)) +
((localPixel->green - localPixel2->green) * (localPixel->green - localPixel2->green)) +
((localPixel->blue - localPixel2->blue) * (localPixel->blue - localPixel2->blue)) >= (this.Threshold * this.Threshold))
{
pPixel->red = (byte)0;
pPixel->green = (byte)0;
pPixel->blue = (byte)0;
}
else
{
pPixel->red = (byte)255;
pPixel->green = (byte)255;
pPixel->blue = (byte)255;
}
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
double mask;
int max_diff, max_temp;
var ratio = this.Threshold / 100.0;
var pPixels = new[]
{
getPixel(x - 1, y + 1),
getPixel(x, y + 1),
getPixel(x + 1, y + 1),
getPixel(x - 1, y),
getPixel(x + 1, y),
getPixel(x - 1, y - 1),
getPixel(x, y - 1),
getPixel(x + 1, y - 1)
};
///Red
max_diff = 0;
foreach (var pCurrent in pPixels)
{
max_temp = Math.Abs(pCurrent->red - pPixel->red);
if (max_temp > max_diff)
{
max_diff = max_temp;
}
}
mask = 1.0 / (max_diff / Math.Sqrt(pPixel->red + 1.0) / 3.0 + 1.0);
pPixel->red += (byte)(ratio * ((255 - pPixel->red) * mask - max_diff * pPixel->red / 100.0));
///Green
max_diff = 0;
foreach (var pCurrent in pPixels)
{
max_temp = Math.Abs(pCurrent->green - pPixel->green);
if (max_temp > max_diff)
{
max_diff = max_temp;
}
}
mask = 1.0 / (max_diff / Math.Sqrt(pPixel->green + 1.0) / 3.0 + 1.0);
pPixel->green += (byte)(ratio * ((255 - pPixel->green) * mask - max_diff * pPixel->green / 100.0));
///Blue
max_diff = 0;
foreach (var pCurrent in pPixels)
{
max_temp = Math.Abs(pCurrent->blue - pPixel->blue);
if (max_temp > max_diff)
{
max_diff = max_temp;
}
}
mask = 1.0 / (max_diff / Math.Sqrt(pPixel->blue + 1.0) / 3.0 + 1.0);
pPixel->blue += (byte)(ratio * ((255 - pPixel->blue) * mask - max_diff * pPixel->blue / 100.0));
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
var pPixel1 = getPixel(x, y + 1);
var pPixel2 = getPixel(x - 1, y);
var pPixel3 = getPixel(x + 1, y);
var pPixel4 = getPixel(x, y - 1);
pPixel->red = (byte)MathEx.Clamp((pPixel1->red + pPixel2->red + pPixel3->red + pPixel4->red + pPixel->red) / 5.0, 0, 255);
pPixel->green = (byte)MathEx.Clamp((pPixel1->green + pPixel2->green + pPixel3->green + pPixel4->green + pPixel->green) / 5.0, 0, 255);
pPixel->blue = (byte)MathEx.Clamp((pPixel1->blue + pPixel2->blue + pPixel3->blue + pPixel4->blue + pPixel->blue) / 5.0, 0, 255);
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
int rand_x = Math.Min(Math.Max(x0, x + _rand.Next(-this.Threshold, this.Threshold)), x1);
int rand_y = Math.Min(Math.Max(y0, y + _rand.Next(-this.Threshold, this.Threshold)), y1);
PixelData *pRandPixel = getPixel(rand_x, rand_y);
pPixel->red = pRandPixel->red;
pPixel->green = pRandPixel->green;
pPixel->blue = pRandPixel->blue;
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
PixelData pixel1 = new PixelData();
PixelData pixel2 = new PixelData();
this.Matrix = mat1;
this.applyConvolution3x3(x, y, getPixel, &pixel1);
this.Matrix = mat2;
this.applyConvolution3x3(x, y, getPixel, &pixel2);
pPixel->red = (byte)Math.Sqrt(pixel1.red * pixel1.red + pixel2.red * pixel2.red);
pPixel->green = (byte)Math.Sqrt(pixel1.green * pixel1.green + pixel2.green * pixel2.green);
pPixel->blue = (byte)Math.Sqrt(pixel1.blue * pixel1.blue + pixel2.blue * pixel2.blue);
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
int rot_x = (int)((x - _center.X) * Math.Cos(_angle) - (y - _center.Y) * Math.Sin(_angle) + _center.X);
int rot_y = (int)((x - _center.X) * Math.Sin(_angle) + (y - _center.Y) * Math.Cos(_angle) + _center.Y);
if (rot_x >= x0 && rot_x <= x1 && rot_y >= y0 && rot_y <= y1)
{
PixelData *pRotPixel = getPixel(rot_x, rot_y);
pPixel->red = pRotPixel->red;
pPixel->green = pRotPixel->green;
pPixel->blue = pRotPixel->blue;
}
else
{
pPixel->red = this.FillColor.R;
pPixel->green = this.FillColor.G;
pPixel->blue = this.FillColor.B;
}
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
var pixels = new PixelData *[this.Threshold * this.Threshold];
int f1 = (int)(0.5 * (this.Threshold - 1));
for (int i = 0; i < this.Threshold; i++)
{
for (int j = 0; j < this.Threshold; j++)
{
int xi = x - f1 + i;
int yi = y - f1 + j;
pixels[i * this.Threshold + j] = getPixel((xi < 0) ? 0 : ((xi > x1) ? x1 : xi),
(yi < 0) ? 0 : ((yi > y1) ? y1 : yi));
}
}
int index = MostFrequent(pixels);
pPixel->red = pixels[index]->red;
pPixel->green = pixels[index]->green;
pPixel->blue = pixels[index]->blue;
}
/// <summary>
/// Buffered filter
/// </summary>
public unsafe virtual void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
throw new NotImplementedException();
}
public unsafe override void Filter(int x, int y, PixelGet getPixel, PixelData *pPixel, int x0, int y0, int x1, int y1)
{
this.applyConvolution3x3(x, y, getPixel, pPixel);
}
