public void IterateDest(Func <int, int, Pixel> func)
{
int total_area = _rectangle.Area;
int area_so_far = 0;
var destPR = new PixelRgn(_drawable, _rectangle, true, true);
for (IntPtr pr = PixelRgn.Register(destPR); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = destPR.Y; y < destPR.Y + destPR.H; y++)
{
for (int x = destPR.X; x < destPR.X + destPR.W; x++)
{
destPR[y, x] = func(x, y);
}
}
if (_runmode != RunMode.Noninteractive)
{
area_so_far += destPR.W * destPR.H;
Progress.Update((double)area_so_far / (double)total_area);
}
}
_drawable.Flush();
_drawable.MergeShadow(true);
_drawable.Update(_rectangle);
}
public void Rowstride()
{
var rgn = new PixelRgn(_drawable, false, false);
PixelRgn.Register(rgn);
Assert.AreEqual(_drawable.Bpp * Gimp.TileWidth, rgn.Rowstride);
}
public void DirectAccessRgba()
{
var image = new Image(_width, _height, ImageBaseType.Rgb)
{
{ new Layer("test", ImageType.Rgba), 0 }
};
var drawable = image.ActiveDrawable;
var pixel = new Pixel(13, 24, 35, 128);
FillDrawable(drawable, pixel);
var rgn = new PixelRgn(drawable, false, false);
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = rgn.Y; y < rgn.Y + rgn.H; y++)
{
for (int x = rgn.X; x < rgn.X + rgn.W; x++)
{
Assert.AreEqual(pixel.Color, rgn[y, x].Color);
}
}
}
image.Delete();
}
public void CopyRgb2Rgba()
{
// Fill src region
var pixel = new Pixel(13, 24, 35);
FillDrawable(_drawable, pixel);
// Copy to dest region
var image = new Image(_width, _height, ImageBaseType.Rgb)
{
{ new Layer("test", ImageType.Rgba), 0 }
};
var drawable = image.ActiveDrawable;
var srcRgn = new PixelRgn(_drawable, false, false);
var destRgn = new PixelRgn(drawable, true, false);
for (IntPtr pr = PixelRgn.Register(srcRgn, destRgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = srcRgn.Y; y < srcRgn.Y + srcRgn.H; y++)
{
for (int x = srcRgn.X; x < srcRgn.X + srcRgn.W; x++)
{
var tmp = srcRgn[y, x];
destRgn[y, x] = new Pixel(tmp.Red, tmp.Green, tmp.Blue, 255);
}
}
}
// Check results
var pixel2 = new Pixel(13, 24, 35, 255);
srcRgn = new PixelRgn(_drawable, false, false);
destRgn = new PixelRgn(drawable, false, false);
for (IntPtr pr = PixelRgn.Register(srcRgn, destRgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = srcRgn.Y; y < srcRgn.Y + srcRgn.H; y++)
{
for (int x = srcRgn.X; x < srcRgn.X + srcRgn.W; x++)
{
Assert.AreEqual(pixel.Color, srcRgn[y, x].Color);
Assert.AreEqual(pixel2.Color, destRgn[y, x].Color);
}
}
}
image.Delete();
}
// Fix me: there could be some overhead in reading from PixelRgn's that
// are write-only! This could be solved by introducing Read/Write/ReadWrite
// regions
public void ForEach(Action <Pixel> func)
{
var rgn = _regions[0];
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = rgn.Y; y < rgn.Y + rgn.H; y++)
{
for (int x = rgn.X; x < rgn.X + rgn.W; x++)
{
func(rgn[y, x]);
}
}
}
}
void FillDrawable(Drawable drawable, Pixel pixel)
{
var rgn = new PixelRgn(drawable, true, false);
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = rgn.Y; y < rgn.Y + rgn.H; y++)
{
for (int x = rgn.X; x < rgn.X + rgn.W; x++)
{
rgn[y, x] = pixel;
}
}
}
}
public IEnumerator <Pixel> GetEnumerator()
{
var srcPR = new PixelRgn(_drawable, _drawable.MaskBounds, false, false);
for (IntPtr pr = PixelRgn.Register(srcPR); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = srcPR.Y; y < srcPR.Y + srcPR.H; y++)
{
for (int x = srcPR.X; x < srcPR.X + srcPR.W; x++)
{
yield return(srcPR[y, x]);
}
}
}
}
public void ForEach(Action <Pixel, Pixel> func)
{
var rgn1 = _regions[0];
var rgn2 = _regions[1];
for (IntPtr pr = PixelRgn.Register(rgn1, rgn2); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y1 = rgn1.Y, y2 = rgn2.Y; y1 < rgn1.Y + rgn1.H; y1++, y2++)
{
for (int x1 = rgn1.X, x2 = rgn2.X; x1 < rgn1.X + rgn1.W;
x1++, x2++)
{
func(rgn1[y1, x1], rgn2[y2, x2]);
}
}
}
}
public void CountTiles()
{
var rgn = new PixelRgn(_drawable, false, false);
int tw = (int)Gimp.TileWidth;
int th = (int)Gimp.TileHeight;
int htiles = (_width + tw - 1) / tw;
int vtiles = (_height + th - 1) / th;
int count = 0;
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
count++;
}
Assert.AreEqual(htiles * vtiles, count);
}
public void CountPixels()
{
var rgn = new PixelRgn(_drawable, false, false);
int count = 0;
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = rgn.Y; y < rgn.Y + rgn.H; y++)
{
for (int x = rgn.X; x < rgn.X + rgn.W; x++)
{
count++;
}
}
}
Assert.AreEqual(_width * _height, count);
}
public void IterateSrcDest(Func <Pixel, Pixel> func)
{
var srcPR = new PixelRgn(_drawable, _rectangle, false, false);
var destPR = new PixelRgn(_drawable, _rectangle, true, true);
for (IntPtr pr = PixelRgn.Register(srcPR, destPR); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = srcPR.Y; y < srcPR.Y + srcPR.H; y++)
{
for (int x = srcPR.X; x < srcPR.X + srcPR.W; x++)
{
destPR[y, x] = func(srcPR[y, x]);
}
}
}
_drawable.Flush();
_drawable.MergeShadow(true);
_drawable.Update(_rectangle);
}
public void DirectAccessRgb()
{
var rgn = new PixelRgn(_drawable, true, false);
var pixel = new Pixel(13, 24, 35);
FillDrawable(_drawable, pixel);
rgn = new PixelRgn(_drawable, false, false);
for (IntPtr pr = PixelRgn.Register(rgn); pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y = rgn.Y; y < rgn.Y + rgn.H; y++)
{
for (int x = rgn.X; x < rgn.X + rgn.W; x++)
{
Assert.AreEqual(pixel.Color, rgn[y, x].Color);
}
}
}
}
