public override unsafe ColorBgra Apply (ColorBgra color, int area, int* hb, int* hg, int* hr, int* ha)
{
ColorBgra normalized = GetPercentileOfColor (color, area, hb, hg, hr, ha);
double lerp = strength * (1 - 0.75 * color.GetIntensity ());
return ColorBgra.Lerp (color, normalized, lerp);
}
public unsafe override ColorBgra ApplyWithAlpha(ColorBgra src, int area, int sum, int* hb, int* hg, int* hr)
{
//each slot of the histgram can contain up to area * 255. This will overflow an int when area > 32k
if (area < 32768) {
int b = 0;
int g = 0;
int r = 0;
for (int i = 1; i < 256; ++i) {
b += i * hb[i];
g += i * hg[i];
r += i * hr[i];
}
int alpha = sum / area;
int div = area * 255;
return ColorBgra.FromBgraClamped (b / div, g / div, r / div, alpha);
} else { //use a long if an int will overflow.
long b = 0;
long g = 0;
long r = 0;
for (long i = 1; i < 256; ++i) {
b += i * hb[i];
g += i * hg[i];
r += i * hr[i];
}
int alpha = sum / area;
int div = area * 255;
return ColorBgra.FromBgraClamped (b / div, g / div, r / div, alpha);
}
}
// This isn't really an extension method, since it doesn't use
// the passed in argument, but it's nice to have the same calling
// convention as the uncached version. If you can use this one
// over the other, it is much faster in tight loops (like effects).
public static unsafe ColorBgra GetPointUnchecked(this ImageSurface surf, ColorBgra* surfDataPtr, int surfWidth, int x, int y)
{
ColorBgra* dstPtr = surfDataPtr;
dstPtr += (x) + (y * surfWidth);
return *dstPtr;
}
public unsafe override void Apply(ColorBgra *dst, ColorBgra *src, int length)
{
for (int i = 0; i < length; i++) {
*dst = *src;
dst++;
src++;
}
}
public unsafe override void Apply(ColorBgra* dst, ColorBgra* src, int length)
{
while (length > 0)
{
*dst = setColor;
++dst;
--length;
}
}
public HistogramRgb()
: base(3, 256)
{
visualColors = new ColorBgra[]{
ColorBgra.Blue,
ColorBgra.Green,
ColorBgra.Red
};
}
public unsafe void Render(Cairo.ImageSurface dst, Gdk.Point offset)
{
if (cr.ScaleFactor > new ScaleFactor (1, 2))
return;
int[] d2SLookupX = cr.Dst2SrcLookupX;
int[] d2SLookupY = cr.Dst2SrcLookupY;
int[] s2DLookupX = cr.Src2DstLookupX;
int[] s2DLookupY = cr.Src2DstLookupY;
ColorBgra[] blackAndWhite = new ColorBgra[2] { ColorBgra.White, ColorBgra.Black };
// draw horizontal lines
int dstHeight = dst.Height;
int dstWidth = dst.Width;
int dstStride = dst.Stride;
int sTop = d2SLookupY[offset.Y];
int sBottom = d2SLookupY[offset.Y + dstHeight];
for (int srcY = sTop; srcY <= sBottom; ++srcY) {
int dstY = s2DLookupY[srcY];
int dstRow = dstY - offset.Y;
if (dstRow >= 0 && dstRow < dstHeight) {
ColorBgra* dstRowPtr = dst.GetRowAddressUnchecked (dstRow);
ColorBgra* dstRowEndPtr = dstRowPtr + dstWidth;
dstRowPtr += offset.X & 1;
while (dstRowPtr < dstRowEndPtr) {
*dstRowPtr = ColorBgra.Black;
dstRowPtr += 2;
}
}
}
// draw vertical lines
int sLeft = d2SLookupX[offset.X];
int sRight = d2SLookupX[offset.X + dstWidth];
for (int srcX = sLeft; srcX <= sRight; ++srcX) {
int dstX = s2DLookupX[srcX];
int dstCol = dstX - offset.X;
if (dstCol >= 0 && dstCol < dstWidth) {
byte* dstColPtr = (byte*)dst.GetPointAddress (dstCol, 0);
byte* dstColEndPtr = dstColPtr + dstStride * dstHeight;
dstColPtr += (offset.Y & 1) * dstStride;
while (dstColPtr < dstColEndPtr) {
*((ColorBgra*)dstColPtr) = ColorBgra.Black;
dstColPtr += 2 * dstStride;
}
}
}
}
public unsafe override void Apply(ColorBgra* ptr, int length)
{
while (length > 0)
{
*ptr = setColor;
++ptr;
--length;
}
}
public unsafe virtual void Apply(ColorBgra* ptr, int length)
{
unsafe {
while (length > 0) {
*ptr = Apply (*ptr);
++ptr;
--length;
}
}
}
public unsafe override void Apply(ColorBgra* dst, ColorBgra* src, int length)
{
unsafe {
while (length > 0) {
*dst = Apply (*src);
++dst;
++src;
--length;
}
}
}
public override ColorBgra Apply(ColorBgra color)
{
int a = blendColor.A;
int invA = 255 - a;
int r = ((color.R * invA) + (blendColor.R * a)) / 256;
int g = ((color.G * invA) + (blendColor.G * a)) / 256;
int b = ((color.B * invA) + (blendColor.B * a)) / 256;
byte a2 = ComputeAlpha(color.A, blendColor.A);
return ColorBgra.FromBgra((byte)b, (byte)g, (byte)r, a2);
}
public unsafe virtual void Apply (ColorBgra* dst, ColorBgra* lhs, ColorBgra* rhs, int length)
{
unsafe {
while (length > 0) {
*dst = Apply (*lhs, *rhs);
++dst;
++lhs;
++rhs;
--length;
}
}
}
public unsafe override ColorBgra Apply(ColorBgra src, int area, int* hb, int* hg, int* hr, int* ha)
{
int resultB = BlurChannel (src.B, hb);
int resultG = BlurChannel (src.G, hg);
int resultR = BlurChannel (src.R, hr);
// there is no way we can deal with pre-multiplied alphas; the correlation
// between channels no longer exists by this point in the algorithm...
// so, just use the alpha from the source pixel.
ColorBgra result = ColorBgra.FromBgra ((byte)resultB, (byte)resultG, (byte)resultR, src.A);
return result;
}
public ColorBgra Apply (ColorBgra color, int checkerX, int checkerY)
{
int b = color.B;
int g = color.G;
int r = color.R;
int a = ApplyOpacity (color.A);
int v = ((checkerX ^ checkerY) & 8) * 8 + 191;
a = a + (a >> 7);
int vmia = v * (256 - a);
r = ((r * a) + vmia) >> 8;
g = ((g * a) + vmia) >> 8;
b = ((b * a) + vmia) >> 8;
return ColorBgra.FromUInt32 ((uint)b + ((uint)g << 8) + ((uint)r << 16) + 0xff000000);
}
public static unsafe void FillStencilByColor(ImageSurface surface, IBitVector2D stencil, ColorBgra cmp, int tolerance, out Rectangle boundingBox)
{
int top = int.MaxValue;
int bottom = int.MinValue;
int left = int.MaxValue;
int right = int.MinValue;
stencil.Clear (false);
for (int y = 0; y < surface.Height; ++y) {
bool foundPixelInRow = false;
ColorBgra* ptr = surface.GetRowAddressUnchecked (y);
for (int x = 0; x < surface.Width; ++x) {
if (CheckColor (cmp, *ptr, tolerance)) {
stencil.SetUnchecked (x, y, true);
if (x < left) {
left = x;
}
if (x > right) {
right = x;
}
foundPixelInRow = true;
}
++ptr;
}
if (foundPixelInRow) {
if (y < top) {
top = y;
}
if (y >= bottom) {
bottom = y;
}
}
}
boundingBox = new Rectangle (left, top, right + 1, bottom + 1);
}
private static unsafe ColorBgra GetPercentileOfColor (ColorBgra color, int area, int* hb, int* hg, int* hr, int* ha)
{
int rc = 0;
int gc = 0;
int bc = 0;
for (int i = 0; i < color.R; ++i)
rc += hr[i];
for (int i = 0; i < color.G; ++i)
gc += hg[i];
for (int i = 0; i < color.B; ++i)
bc += hb[i];
rc = (rc * 255) / area;
gc = (gc * 255) / area;
bc = (bc * 255) / area;
return ColorBgra.FromBgr ((byte)bc, (byte)gc, (byte)rc);
}
/// <summary>
/// Smoothly blends between two colors.
/// </summary>
public static ColorBgra Blend(ColorBgra ca, ColorBgra cb, byte cbAlpha)
{
uint caA = (uint)Utility.FastScaleByteByByte((byte)(255 - cbAlpha), ca.A);
uint cbA = (uint)Utility.FastScaleByteByByte(cbAlpha, cb.A);
uint cbAT = caA + cbA;
uint r;
uint g;
uint b;
if (cbAT == 0) {
r = 0;
g = 0;
b = 0;
} else {
r = ((ca.R * caA) + (cb.R * cbA)) / cbAT;
g = ((ca.G * caA) + (cb.G * cbA)) / cbAT;
b = ((ca.B * caA) + (cb.B * cbA)) / cbAT;
}
return ColorBgra.FromBgra((byte)b, (byte)g, (byte)r, (byte)cbAT);
}
/// <summary>
/// Performs the actual work of rendering an effect. This overload represent a single pixel of the image.
/// </summary>
/// <param name="color">The color of the source surface pixel.</param>
/// <returns>The color to be used for the destination pixel.</returns>
protected virtual ColorBgra Render(ColorBgra color)
{
return(color);
}
public abstract ColorBgra Apply(ColorBgra color);
private void DrawChannel(Context g, ColorBgra color, int channel, long max, float mean)
{
Rectangle rect = Allocation.ToCairoRectangle ();
Histogram histogram = Histogram;
int l = (int)rect.X;
int t = (int)rect.Y;
int r = (int)(rect.X + rect.Width);
int b = (int)(rect.Y + rect.Height);
int entries = histogram.Entries;
long[] hist = histogram.HistogramValues [channel];
++max;
if (FlipHorizontal) {
Utility.Swap(ref l, ref r);
}
if (!FlipVertical) {
Utility.Swap(ref t, ref b);
}
PointD[] points = new PointD[entries + 2];
points[entries] = new PointD (Utility.Lerp (l, r, -1), Utility.Lerp (t, b, 20));
points[entries + 1] = new PointD (Utility.Lerp (l, r, -1), Utility.Lerp (b, t, 20));
for (int i = 0; i < entries; i += entries - 1) {
points[i] = new PointD (
Utility.Lerp (l, r, (float)hist[i] / (float)max),
Utility.Lerp (t, b, (float)i / (float)entries));
CheckPoint (rect, points [i]);
}
long sum3 = hist[0] + hist[1];
for (int i = 1; i < entries - 1; ++i) {
sum3 += hist[i + 1];
points[i] = new PointD(
Utility.Lerp(l, r, (float)(sum3) / (float)(max * 3.1f)),
Utility.Lerp(t, b, (float)i / (float)entries));
CheckPoint (rect, points [i]);
sum3 -= hist[i - 1];
}
byte intensity = selected[channel] ? (byte)96 : (byte)32;
ColorBgra pen_color = ColorBgra.Blend (ColorBgra.Black, color, intensity);
ColorBgra brush_color = color;
brush_color.A = intensity;
g.LineWidth = 1;
g.Rectangle (rect);
g.Clip ();
g.DrawPolygonal (points, pen_color.ToCairoColor ());
g.FillPolygonal (points, brush_color.ToCairoColor ());
}
private static void ComputeAlphaOnlyValuesFromColors(ColorBgra startColor, ColorBgra endColor, out byte startAlpha, out byte endAlpha)
{
startAlpha = startColor.A;
endAlpha = (byte)(255 - endColor.A);
}
public unsafe static void SetColorBgra(this Cairo.ImageSurface surf, ColorBgra *surfDataPtr, int surfWidth, ColorBgra color, int x, int y)
{
ColorBgra *dstPtr = surfDataPtr;
dstPtr += (x) + (y * surfWidth);
*dstPtr = color;
}
public static int ColorDifference (ColorBgra a, ColorBgra b)
{
return (int)Math.Ceiling (Math.Sqrt (ColorDifferenceSquared (a, b)));
}
public unsafe override ColorBgra Apply(ColorBgra src, int area, int* hb, int* hg, int* hr, int* ha)
{
int minCount1 = area * (100 - this.intensity) / 200;
int minCount2 = area * (100 + this.intensity) / 200;
int bCount = 0;
int b1 = 0;
while (b1 < 255 && hb[b1] == 0)
++b1;
while (b1 < 255 && bCount < minCount1) {
bCount += hb[b1];
++b1;
}
int b2 = b1;
while (b2 < 255 && bCount < minCount2) {
bCount += hb[b2];
++b2;
}
int gCount = 0;
int g1 = 0;
while (g1 < 255 && hg[g1] == 0)
++g1;
while (g1 < 255 && gCount < minCount1) {
gCount += hg[g1];
++g1;
}
int g2 = g1;
while (g2 < 255 && gCount < minCount2) {
gCount += hg[g2];
++g2;
}
int rCount = 0;
int r1 = 0;
while (r1 < 255 && hr[r1] == 0)
++r1;
while (r1 < 255 && rCount < minCount1) {
rCount += hr[r1];
++r1;
}
int r2 = r1;
while (r2 < 255 && rCount < minCount2) {
rCount += hr[r2];
++r2;
}
int aCount = 0;
int a1 = 0;
while (a1 < 255 && hb[a1] == 0)
++a1;
while (a1 < 255 && aCount < minCount1) {
aCount += ha[a1];
++a1;
}
int a2 = a1;
while (a2 < 255 && aCount < minCount2) {
aCount += ha[a2];
++a2;
}
return ColorBgra.FromBgra (
(byte)(255 - (b2 - b1)),
(byte)(255 - (g2 - g1)),
(byte)(255 - (r2 - r1)),
(byte)(a2));
}
public static unsafe void FillStencilByColor(ImageSurface surface, IBitVector2D stencil, ColorBgra cmp, int tolerance,
out Rectangle boundingBox, Gdk.Region limitRegion, bool limitToSelection)
{
int top = int.MaxValue;
int bottom = int.MinValue;
int left = int.MaxValue;
int right = int.MinValue;
Gdk.Rectangle[] scans;
stencil.Clear (false);
if (limitToSelection) {
using (Gdk.Region excluded = Gdk.Region.Rectangle (new Gdk.Rectangle (0, 0, stencil.Width, stencil.Height))) {
excluded.Xor (limitRegion);
scans = excluded.GetRectangles ();
}
} else {
scans = new Gdk.Rectangle[0];
}
foreach (Gdk.Rectangle rect in scans)
stencil.Set (rect, true);
for (int y = 0; y < surface.Height; ++y) {
bool foundPixelInRow = false;
ColorBgra* ptr = surface.GetRowAddressUnchecked (y);
for (int x = 0; x < surface.Width; ++x) {
if (CheckColor (cmp, *ptr, tolerance)) {
stencil.SetUnchecked (x, y, true);
if (x < left) {
left = x;
}
if (x > right) {
right = x;
}
foundPixelInRow = true;
}
++ptr;
}
if (foundPixelInRow) {
if (y < top) {
top = y;
}
if (y >= bottom) {
bottom = y;
}
}
}
foreach (Gdk.Rectangle rect in scans)
stencil.Set (rect, false);
boundingBox = new Rectangle (left, top, right - left + 1, bottom - top + 1);
}
/// <summary>
/// Returns a new ColorBgra with the same color values but with a new alpha component value.
/// </summary>
public ColorBgra NewAlpha(byte newA)
{
return(ColorBgra.FromBgra(B, G, R, newA));
}
private static void ComputeAlphaOnlyValuesFromColors(ColorBgra startColor, ColorBgra endColor, out byte startAlpha, out byte endAlpha)
{
startAlpha = startColor.A;
endAlpha = (byte)(255 - endColor.A);
}
public static unsafe ColorBgra GetBilinearSampleClamped(this ImageSurface src, ColorBgra *srcDataPtr, int srcWidth, int srcHeight, float x, float y)
{
if (!Utility.IsNumber(x) || !Utility.IsNumber(y))
{
return(ColorBgra.Transparent);
}
float u = x;
float v = y;
if (u < 0)
{
u = 0;
}
else if (u > srcWidth - 1)
{
u = srcWidth - 1;
}
if (v < 0)
{
v = 0;
}
else if (v > srcHeight - 1)
{
v = srcHeight - 1;
}
unchecked {
int iu = (int)Math.Floor(u);
uint sxfrac = (uint)(256 * (u - (float)iu));
uint sxfracinv = 256 - sxfrac;
int iv = (int)Math.Floor(v);
uint syfrac = (uint)(256 * (v - (float)iv));
uint syfracinv = 256 - syfrac;
uint wul = (uint)(sxfracinv * syfracinv);
uint wur = (uint)(sxfrac * syfracinv);
uint wll = (uint)(sxfracinv * syfrac);
uint wlr = (uint)(sxfrac * syfrac);
int sx = iu;
int sy = iv;
int sleft = sx;
int sright;
if (sleft == (srcWidth - 1))
{
sright = sleft;
}
else
{
sright = sleft + 1;
}
int stop = sy;
int sbottom;
if (stop == (srcHeight - 1))
{
sbottom = stop;
}
else
{
sbottom = stop + 1;
}
ColorBgra *cul = src.GetPointAddressUnchecked(srcDataPtr, srcWidth, sleft, stop);
ColorBgra *cur = cul + (sright - sleft);
ColorBgra *cll = src.GetPointAddressUnchecked(srcDataPtr, srcWidth, sleft, sbottom);
ColorBgra *clr = cll + (sright - sleft);
ColorBgra c = ColorBgra.BlendColors4W16IP(*cul, wul, *cur, wur, *cll, wll, *clr, wlr);
return(c);
}
}
public static unsafe ColorBgra GetBilinearSampleWrapped(this ImageSurface src, ColorBgra *srcDataPtr, int srcWidth, int srcHeight, float x, float y)
{
if (!Utility.IsNumber(x) || !Utility.IsNumber(y))
{
return(ColorBgra.Transparent);
}
float u = x;
float v = y;
unchecked {
int iu = (int)Math.Floor(u);
uint sxfrac = (uint)(256 * (u - (float)iu));
uint sxfracinv = 256 - sxfrac;
int iv = (int)Math.Floor(v);
uint syfrac = (uint)(256 * (v - (float)iv));
uint syfracinv = 256 - syfrac;
uint wul = (uint)(sxfracinv * syfracinv);
uint wur = (uint)(sxfrac * syfracinv);
uint wll = (uint)(sxfracinv * syfrac);
uint wlr = (uint)(sxfrac * syfrac);
int sx = iu;
if (sx < 0)
{
sx = (srcWidth - 1) + ((sx + 1) % srcWidth);
}
else if (sx > (srcWidth - 1))
{
sx = sx % srcWidth;
}
int sy = iv;
if (sy < 0)
{
sy = (srcHeight - 1) + ((sy + 1) % srcHeight);
}
else if (sy > (srcHeight - 1))
{
sy = sy % srcHeight;
}
int sleft = sx;
int sright;
if (sleft == (srcWidth - 1))
{
sright = 0;
}
else
{
sright = sleft + 1;
}
int stop = sy;
int sbottom;
if (stop == (srcHeight - 1))
{
sbottom = 0;
}
else
{
sbottom = stop + 1;
}
ColorBgra cul = src.GetPointUnchecked(srcDataPtr, srcWidth, sleft, stop);
ColorBgra cur = src.GetPointUnchecked(srcDataPtr, srcWidth, sright, stop);
ColorBgra cll = src.GetPointUnchecked(srcDataPtr, srcWidth, sleft, sbottom);
ColorBgra clr = src.GetPointUnchecked(srcDataPtr, srcWidth, sright, sbottom);
ColorBgra c = ColorBgra.BlendColors4W16IP(cul, wul, cur, wur, cll, wll, clr, wlr);
return(c);
}
}
public static ColorBgra ToBgraColor(this Gdk.Color color)
{
return(ColorBgra.FromBgr((byte)(color.Blue * 255 / ushort.MaxValue), (byte)(color.Green * 255 / ushort.MaxValue), (byte)(color.Red * 255 / ushort.MaxValue)));
}
public static ColorBgra ParseHexString(string hexString)
{
uint value = Convert.ToUInt32(hexString, 16);
return(ColorBgra.FromUInt32(value));
}
private int MaskAvg(ColorBgra before)
{
int count = 0, total = 0;
for (int c = 0; c < 3; c++) {
if (mask [c]) {
total += before [c];
count++;
}
}
if (count > 0) {
return total / count;
}
else {
return 0;
}
}
/// <summary>
/// Blends four colors together based on the given weight values.
/// </summary>
/// <returns>The blended color.</returns>
/// <remarks>
/// The weights should be 16-bit fixed point numbers that add up to 65536 ("1.0").
/// 4W16IP means "4 colors, weights, 16-bit integer precision"
/// </remarks>
public static ColorBgra BlendColors4W16IP(ColorBgra c1, uint w1, ColorBgra c2, uint w2, ColorBgra c3, uint w3, ColorBgra c4, uint w4)
{
#if DEBUG
if ((w1 + w2 + w3 + w4) != 65536)
{
throw new ArgumentOutOfRangeException("w1 + w2 + w3 + w4 must equal 65536!");
}
#endif
const uint ww = 32768;
uint af = (c1.A * w1) + (c2.A * w2) + (c3.A * w3) + (c4.A * w4);
uint a = (af + ww) >> 16;
uint b;
uint g;
uint r;
if (a == 0)
{
b = 0;
g = 0;
r = 0;
}
else
{
b = (uint)((((long)c1.A * c1.B * w1) + ((long)c2.A * c2.B * w2) + ((long)c3.A * c3.B * w3) + ((long)c4.A * c4.B * w4)) / af);
g = (uint)((((long)c1.A * c1.G * w1) + ((long)c2.A * c2.G * w2) + ((long)c3.A * c3.G * w3) + ((long)c4.A * c4.G * w4)) / af);
r = (uint)((((long)c1.A * c1.R * w1) + ((long)c2.A * c2.R * w2) + ((long)c3.A * c3.R * w3) + ((long)c4.A * c4.R * w4)) / af);
}
return(ColorBgra.FromBgra((byte)b, (byte)g, (byte)r, (byte)a));
}
public static Gdk.Color ToGdkColor(this ColorBgra color)
{
Gdk.Color c = new Gdk.Color(color.R, color.G, color.B);
return(c);
}
// These methods are ported from PDN.
private static bool CheckColor(ColorBgra a, ColorBgra b, int tolerance)
{
int sum = 0;
int diff;
diff = a.R - b.R;
sum += (1 + diff * diff) * a.A / 256;
diff = a.G - b.G;
sum += (1 + diff * diff) * a.A / 256;
diff = a.B - b.B;
sum += (1 + diff * diff) * a.A / 256;
diff = a.A - b.A;
sum += diff * diff;
return (sum <= tolerance * tolerance * 4);
}
public static unsafe SurfaceDiff Create(ImageSurface original, ImageSurface updated_surf, bool force = false)
{
if (original.Width != updated_surf.Width || original.Height != updated_surf.Height)
{
// If the surface changed size, only throw an error if the user forced the use of a diff.
if (force)
{
throw new InvalidOperationException("SurfaceDiff requires surfaces to be same size.");
}
else
{
return(null);
}
}
// Cache some pinvokes
var orig_width = original.Width;
var orig_height = original.Height;
#if DEBUG_DIFF
Console.WriteLine("Original surface size: {0}x{1}", orig_width, orig_height);
System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
timer.Start();
#endif
// STEP 1 - Find the bounds of the changed pixels.
var orig_ptr = (int *)original.DataPtr;
var updated_ptr = (int *)updated_surf.DataPtr;
DiffBounds diff_bounds = new DiffBounds(orig_width, orig_height);
object diff_bounds_lock = new Object();
// Split up the work among several threads, each of which processes one row at a time
// and updates the bounds of the changed pixels it has seen so far. At the end, the
// results from each thread are merged together to find the overall bounds of the changed
// pixels.
Parallel.For <DiffBounds>(0, orig_height, () => new DiffBounds(orig_width, orig_height),
(row, loop, my_bounds) => {
var offset = row * orig_width;
var orig = orig_ptr + offset;
var updated = updated_ptr + offset;
bool change_in_row = false;
for (int i = 0; i < orig_width; ++i)
{
if (*(orig++) != *(updated++))
{
change_in_row = true;
my_bounds.left = System.Math.Min(my_bounds.left, i);
my_bounds.right = System.Math.Max(my_bounds.right, i);
}
}
if (change_in_row)
{
my_bounds.top = System.Math.Min(my_bounds.top, row);
my_bounds.bottom = System.Math.Max(my_bounds.bottom, row);
}
return(my_bounds);
}, (my_bounds) => {
lock (diff_bounds_lock) {
diff_bounds.Merge(my_bounds);
}
return;
});
var bounds = new Gdk.Rectangle(diff_bounds.left, diff_bounds.top,
diff_bounds.right - diff_bounds.left + 1,
diff_bounds.bottom - diff_bounds.top + 1);
#if DEBUG_DIFF
Console.WriteLine("Truncated surface size: {0}x{1}", bounds.Width, bounds.Height);
#endif
// STEP 2 - Create a bitarray of whether each pixel in the bounds has changed, and count
// how many changed pixels we need to store.
var bitmask = new BitArray(bounds.Width * bounds.Height);
int index = 0;
int num_changed = 0;
int bottom = bounds.GetBottom();
int right = bounds.GetRight();
int bounds_x = bounds.X;
int bounds_y = bounds.Y;
for (int y = bounds_y; y <= bottom; ++y)
{
var offset = y * orig_width;
var updated = updated_ptr + offset + bounds_x;
var orig = orig_ptr + offset + bounds_x;
for (int x = bounds_x; x <= right; ++x)
{
bool changed = *(orig++) != *(updated++);
bitmask[index++] = changed;
if (changed)
{
num_changed++;
}
}
}
var savings = 100 - (float)num_changed / (float)(orig_width * orig_height) * 100;
#if DEBUG_DIFF
Console.WriteLine("Compressed bitmask: {0}/{1} = {2}%", num_changed, orig_height * orig_width, 100 - savings);
#endif
if (!force && savings < MINIMUM_SAVINGS_PERCENT)
{
#if DEBUG_DIFF
Console.WriteLine("Savings too small, returning null");
#endif
return(null);
}
// Store the old pixels.
var pixels = new ColorBgra[num_changed];
var new_ptr = (ColorBgra *)original.DataPtr;
int mask_index = 0;
fixed(ColorBgra *fixed_ptr = pixels)
{
var pixel_ptr = fixed_ptr;
for (int y = bounds_y; y <= bottom; ++y)
{
var new_pixel_ptr = new_ptr + bounds_x + y * orig_width;
for (int x = bounds_x; x <= right; ++x)
{
if (bitmask[mask_index++])
{
*pixel_ptr++ = *new_pixel_ptr;
}
new_pixel_ptr++;
}
}
}
#if DEBUG_DIFF
timer.Stop();
System.Console.WriteLine("SurfaceDiff time: " + timer.ElapsedMilliseconds);
#endif
return(new SurfaceDiff(bitmask, bounds, pixels));
}
public unsafe override ColorBgra Apply (ColorBgra src, int area, int* hb, int* hg, int* hr, int* ha)
{
ColorBgra c = GetPercentile (this.percentile, area, hb, hg, hr, ha);
return c;
}
private ColorBgra AdjustColorDifference(ColorBgra oldColor, ColorBgra newColor, ColorBgra basisColor)
{
ColorBgra returnColor;
// eliminate testing for the "equal to" case
returnColor = basisColor;
returnColor.B = AdjustColorByte (oldColor.B, newColor.B, basisColor.B);
returnColor.G = AdjustColorByte (oldColor.G, newColor.G, basisColor.G);
returnColor.R = AdjustColorByte (oldColor.R, newColor.R, basisColor.R);
return returnColor;
}
private ColorBgra UpdateByMask(ColorBgra before, byte val)
{
ColorBgra after = before;
int average = -1, oldaverage = -1;
if (!(mask [0] || mask [1] || mask [2])) {
return before;
}
do {
float factor;
oldaverage = average;
average = MaskAvg (after);
if (average == 0) {
break;
}
factor = (float)val / average;
for (int c = 0; c < 3; c++) {
if (mask [c]) {
after [c] = (byte)Utility.ClampToByte (after [c] * factor);
}
}
} while (average != val && oldaverage != average);
while (average != val) {
average = MaskAvg (after);
int diff = val - average;
for (int c = 0; c < 3; c++) {
if (mask [c]) {
after [c] = (byte)Utility.ClampToByte(after [c] + diff);
}
}
}
after.A = 255;
return after;
}
private bool IsColorInTolerance(ColorBgra colorA, ColorBgra colorB)
{
return Utility.ColorDifference (colorA, colorB) <= myTolerance;
}
public static int ColorDifferenceSquared (ColorBgra a, ColorBgra b)
{
int diffSq = 0, tmp;
tmp = a.R - b.R;
diffSq += tmp * tmp;
tmp = a.G - b.G;
diffSq += tmp * tmp;
tmp = a.B - b.B;
diffSq += tmp * tmp;
return diffSq / 3;
}
public abstract ColorBgra Apply(ColorBgra color);
