public void Blur(GaussianBlur blur, BlurEdgeMode edgeMode, bool horz, bool vert)
{
if (!horz && !vert)
{
return;
}
if (horz && vert)
{
Blur(blur, edgeMode);
return;
}
var temp = ToBitmapRam();
using (temp.UseWrite())
using (UseWrite())
{
temp.PreMultiply();
if (horz)
{
blur.Horizontal(temp, this, edgeMode);
}
else
{
blur.Vertical(temp, this, edgeMode);
}
UnPreMultiply();
}
}
internal unsafe void Vertical(BitmapBase src, BitmapBase dest, BlurEdgeMode edgeMode)
{
for (int x = 0; x < src.Width; x++)
{
byte *colSource = src.Data + x * 4;
byte *colResult = dest.Data + x * 4;
for (int y = 0; y < src.Height; y++)
{
int rSum = 0, gSum = 0, bSum = 0, aSum = 0;
for (int k = 0, ySrc = y - _kernel.Length / 2; k < _kernel.Length; k++, ySrc++)
{
int yRead = ySrc;
if (yRead < 0 || yRead >= src.Height)
{
switch (edgeMode)
{
case BlurEdgeMode.Transparent:
continue;
case BlurEdgeMode.Same:
yRead = yRead < 0 ? 0 : src.Height - 1;
break;
case BlurEdgeMode.Wrap:
yRead = Ut.ModPositive(yRead, src.Height);
break;
case BlurEdgeMode.Mirror:
if (yRead < 0)
{
yRead = -yRead - 1;
}
yRead = yRead % (2 * src.Height);
if (yRead >= src.Height)
{
yRead = 2 * src.Height - yRead - 1;
}
break;
}
}
yRead *= src.Stride;
bSum += _kernel[k] * colSource[yRead + 0];
gSum += _kernel[k] * colSource[yRead + 1];
rSum += _kernel[k] * colSource[yRead + 2];
aSum += _kernel[k] * colSource[yRead + 3];
}
int yWrite = y * dest.Stride;
colResult[yWrite + 0] = (byte)(bSum / _kernelSum);
colResult[yWrite + 1] = (byte)(gSum / _kernelSum);
colResult[yWrite + 2] = (byte)(rSum / _kernelSum);
colResult[yWrite + 3] = (byte)(aSum / _kernelSum);
}
}
}
internal unsafe void Horizontal(BitmapBase src, BitmapBase dest, BlurEdgeMode edgeMode)
{
for (int y = 0; y < src.Height; y++)
{
byte *rowSource = src.Data + y * src.Stride;
byte *rowResult = dest.Data + y * dest.Stride;
for (int x = 0; x < src.Width; x++)
{
int rSum = 0, gSum = 0, bSum = 0, aSum = 0;
for (int k = 0, xSrc = x - _kernel.Length / 2; k < _kernel.Length; k++, xSrc++)
{
int xRead = xSrc;
if (xRead < 0 || xRead >= src.Width)
{
switch (edgeMode)
{
case BlurEdgeMode.Transparent:
continue;
case BlurEdgeMode.Same:
xRead = xRead < 0 ? 0 : src.Width - 1;
break;
case BlurEdgeMode.Wrap:
xRead = Ut.ModPositive(xRead, src.Width);
break;
case BlurEdgeMode.Mirror:
if (xRead < 0)
{
xRead = -xRead - 1;
}
xRead = xRead % (2 * src.Width);
if (xRead >= src.Width)
{
xRead = 2 * src.Width - xRead - 1;
}
break;
}
}
xRead <<= 2; // * 4
bSum += _kernel[k] * rowSource[xRead + 0];
gSum += _kernel[k] * rowSource[xRead + 1];
rSum += _kernel[k] * rowSource[xRead + 2];
aSum += _kernel[k] * rowSource[xRead + 3];
}
int xWrite = x << 2; // * 4
rowResult[xWrite + 0] = (byte)(bSum / _kernelSum);
rowResult[xWrite + 1] = (byte)(gSum / _kernelSum);
rowResult[xWrite + 2] = (byte)(rSum / _kernelSum);
rowResult[xWrite + 3] = (byte)(aSum / _kernelSum);
}
}
}
public void Blur(GaussianBlur blur, BlurEdgeMode edgeMode)
{
var temp = new BitmapRam(Width, Height);
using (UseWrite())
using (temp.UseWrite())
{
PreMultiply();
blur.Horizontal(this, temp, edgeMode);
blur.Vertical(temp, this, edgeMode);
UnPreMultiply();
}
}
public void Blur(GaussianBlur blur, BlurEdgeMode edgeMode)
{
var temp = new BitmapRam(Width, Height);
using (UseWrite())
using (temp.UseWrite())
{
PreMultiply();
blur.Horizontal(this, temp, edgeMode);
blur.Vertical(temp, this, edgeMode);
UnPreMultiply();
}
}
public void Blur(GaussianBlur blur, BlurEdgeMode edgeMode, bool horz, bool vert)
{
if (!horz && !vert)
return;
if (horz && vert)
{
Blur(blur, edgeMode);
return;
}
var temp = ToBitmapRam();
using (temp.UseWrite())
using (UseWrite())
{
temp.PreMultiply();
if (horz)
blur.Horizontal(temp, this, edgeMode);
else
blur.Vertical(temp, this, edgeMode);
UnPreMultiply();
}
}
internal unsafe void Vertical(BitmapBase src, BitmapBase dest, BlurEdgeMode edgeMode)
{
for (int x = 0; x < src.Width; x++)
{
byte* colSource = src.Data + x * 4;
byte* colResult = dest.Data + x * 4;
for (int y = 0; y < src.Height; y++)
{
int rSum = 0, gSum = 0, bSum = 0, aSum = 0;
for (int k = 0, ySrc = y - _kernel.Length / 2; k < _kernel.Length; k++, ySrc++)
{
int yRead = ySrc;
if (yRead < 0 || yRead >= src.Height)
switch (edgeMode)
{
case BlurEdgeMode.Transparent:
continue;
case BlurEdgeMode.Same:
yRead = yRead < 0 ? 0 : src.Height - 1;
break;
case BlurEdgeMode.Wrap:
yRead = Ut.ModPositive(yRead, src.Height);
break;
case BlurEdgeMode.Mirror:
if (yRead < 0)
yRead = -yRead - 1;
yRead = yRead % (2 * src.Height);
if (yRead >= src.Height)
yRead = 2 * src.Height - yRead - 1;
break;
}
yRead *= src.Stride;
bSum += _kernel[k] * colSource[yRead + 0];
gSum += _kernel[k] * colSource[yRead + 1];
rSum += _kernel[k] * colSource[yRead + 2];
aSum += _kernel[k] * colSource[yRead + 3];
}
int yWrite = y * dest.Stride;
colResult[yWrite + 0] = (byte) (bSum / _kernelSum);
colResult[yWrite + 1] = (byte) (gSum / _kernelSum);
colResult[yWrite + 2] = (byte) (rSum / _kernelSum);
colResult[yWrite + 3] = (byte) (aSum / _kernelSum);
}
}
}
internal unsafe void Horizontal(BitmapBase src, BitmapBase dest, BlurEdgeMode edgeMode)
{
for (int y = 0; y < src.Height; y++)
{
byte* rowSource = src.Data + y * src.Stride;
byte* rowResult = dest.Data + y * dest.Stride;
for (int x = 0; x < src.Width; x++)
{
int rSum = 0, gSum = 0, bSum = 0, aSum = 0;
for (int k = 0, xSrc = x - _kernel.Length / 2; k < _kernel.Length; k++, xSrc++)
{
int xRead = xSrc;
if (xRead < 0 || xRead >= src.Width)
switch (edgeMode)
{
case BlurEdgeMode.Transparent:
continue;
case BlurEdgeMode.Same:
xRead = xRead < 0 ? 0 : src.Width - 1;
break;
case BlurEdgeMode.Wrap:
xRead = Ut.ModPositive(xRead, src.Width);
break;
case BlurEdgeMode.Mirror:
if (xRead < 0)
xRead = -xRead - 1;
xRead = xRead % (2 * src.Width);
if (xRead >= src.Width)
xRead = 2 * src.Width - xRead - 1;
break;
}
xRead <<= 2; // * 4
bSum += _kernel[k] * rowSource[xRead + 0];
gSum += _kernel[k] * rowSource[xRead + 1];
rSum += _kernel[k] * rowSource[xRead + 2];
aSum += _kernel[k] * rowSource[xRead + 3];
}
int xWrite = x << 2; // * 4
rowResult[xWrite + 0] = (byte) (bSum / _kernelSum);
rowResult[xWrite + 1] = (byte) (gSum / _kernelSum);
rowResult[xWrite + 2] = (byte) (rSum / _kernelSum);
rowResult[xWrite + 3] = (byte) (aSum / _kernelSum);
}
}
}
public GaussianBlurEffect()
{
Edge = BlurEdgeMode.Same;
}
