public void Rowstride()
{
var rgn = new PixelRgn(_drawable, false, false);
PixelRgn.Register(rgn);
Assert.AreEqual(_drawable.Bpp * Gimp.TileWidth, rgn.Rowstride);
}
public void IterateDest(Func<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();
}
}
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 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 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 Draw(Drawable drawable)
{
var rgn = new PixelRgn(drawable, false, false);
var rectangle = drawable.Bounds;
var buf = rgn.GetRect(rectangle);
Draw(rectangle, drawable.Type, buf, rectangle.Width * drawable.Bpp);
}
public void TestCount()
{
var srcPR = new PixelRgn(_drawable, false, false);
var iterator = new RegionIterator(srcPR);
int count = 0;
iterator.ForEach(src => {count++;});
Assert.AreEqual(_width * _height, count);
}
public void Draw(Drawable drawable)
{
var rgn = new PixelRgn(drawable, false, false);
var rectangle = drawable.Bounds;
var buf = rgn.GetRect(rectangle);
Draw(rectangle, drawable.Type, buf, rectangle.Width * drawable.Bpp);
}
public void TestCount()
{
var srcPR = new PixelRgn(_drawable, false, false);
var iterator = new RegionIterator(srcPR);
int count = 0;
iterator.ForEach(src => { count++; });
Assert.AreEqual(_width * _height, count);
}
public void GetSetPixel()
{
var rgn = new PixelRgn(_drawable, false, false);
var pixel = new byte[] { 13, 24, 35 };
rgn.SetPixel(pixel, 13, 14);
var result = new byte[_drawable.Bpp];
rgn.GetPixel(result, 13, 14);
Assert.AreEqual(pixel, result);
}
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();
}
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 void GetSetRect()
{
var rgn = new PixelRgn(_drawable, true, false);
var rect = new byte[_drawable.Bpp * _width * _height];
for (int i = 0; i < _drawable.Bpp * _width * _height; i++)
{
rect[i] = 13;
}
rgn.SetRect(rect, 0, 0, _width, _height);
var result = rgn.GetRect(0, 0, _width, _height);
Assert.AreEqual(rect, result);
}
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]);
}
}
}
}
// 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]);
}
}
}
}
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 CopyRgb2Rgb()
{
// 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.Rgb), 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++)
{
destRgn[y, x] = srcRgn[y, x];
}
}
}
// Check results
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(pixel.Color, destRgn[y, x].Color);
Assert.AreEqual(srcRgn[y, x].Color, destRgn[y, x].Color);
}
}
}
image.Delete();
}
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 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 Rectangle MinDistanceRegion(Rectangle sourceRect, Drawable drawable, SelectionMask selectionMask)
{
Debug.Assert(sourceRect.Width == sourceRect.Height);
var windowSize = sourceRect.Width;
var windowDelta = windowSize/2;
Rectangle minRegionRect = null;
var minDistance = 0.0;
var sourceRgn = new PixelRgn(drawable, sourceRect.AdjustedToImageEdges(drawable.Bounds), false, false);
var sourceArray = sourceRgn.ToArrayWithoutSelection(selectionMask);
var currentCoordinate = new IntCoordinate(0, 0);
for (int i = windowDelta; i < drawable.Width - windowDelta; i++)
{
for (int j = windowDelta; j < drawable.Height - windowDelta; j++)
{
if (j == sourceRect.Y1 + windowDelta && i == sourceRect.X1 + windowDelta)
{
continue;
}
currentCoordinate.X = i;
currentCoordinate.Y = j;
var currentRgnRect = currentCoordinate.PointCenteredRectangle(windowSize);
var dist = RegionDistance(sourceArray, currentRgnRect, drawable, selectionMask);
if (dist == null)
{
continue;
}
if (dist == 0)
{
return currentRgnRect;
}
if ((minDistance > dist || minRegionRect == null))
{
minDistance = (double) dist;
minRegionRect = currentRgnRect;
}
}
}
return minRegionRect;
}
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 GetSetRow()
{
var rgn = new PixelRgn(_drawable, false, false);
var row = new Pixel[_width];
for (int i = 0; i < _width; i++)
{
row[i] = new Pixel(13, 13, 13);
}
rgn.SetRow(row, 0, 13);
var result = rgn.GetRow(0, 13, _width);
for (int i = 0; i < _width; i++)
{
Assert.IsTrue(row[i].IsSameColor(result[i]));
}
}
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);
}
}
}
}
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 new void Update(Func<Pixel, Pixel> func)
{
var rectangle = Bounds;
int rowStride = rectangle.Width * _bpp;
byte[] buffer = new byte[rectangle.Area * _bpp];
var srcPR = new PixelRgn(Drawable, rectangle, false, false);
var iterator = new RegionIterator(srcPR);
iterator.ForEach(src =>
{
int x = src.X;
int y = src.Y;
var pixel = func(src);
int index =
(y - rectangle.Y1) * rowStride + (x - rectangle.X1) * _bpp;
pixel.CopyTo(buffer, index);
});
DrawBuffer(buffer, rowStride);
}
public new void Update(Func <Pixel, Pixel> func)
{
var rectangle = Bounds;
int rowStride = rectangle.Width * _bpp;
byte[] buffer = new byte[rectangle.Area * _bpp];
var srcPR = new PixelRgn(Drawable, rectangle, false, false);
var iterator = new RegionIterator(srcPR);
iterator.ForEach(src =>
{
int x = src.X;
int y = src.Y;
var pixel = func(src);
int index = (y - rectangle.Y1) * rowStride + (x - rectangle.X1) * _bpp;
pixel.CopyTo(buffer, index);
});
DrawBuffer(buffer, rowStride);
}
public SelectionMask(Selection selection)
{
bool selectionNonEmpty;
_originBounds = selection.Bounds(out selectionNonEmpty);
if (!selectionNonEmpty)
{
_mask = null;
return;
}
_mask = new bool[_originBounds.Width,_originBounds.Height];
var selRgn = new PixelRgn(selection, _originBounds, false, false);
var iterator = new RegionIterator(selRgn);
iterator.ForEach(pixel =>
{
if (pixel.Red > 128)
{
_area++;
_mask[pixel.X - _originBounds.X1, pixel.Y - _originBounds.Y1] = true;
}
});
}
public void GetSetRect()
{
var rgn = new PixelRgn(_drawable, true, false);
var rect = new byte[_drawable.Bpp * _width * _height];
for (int i = 0; i < _drawable.Bpp * _width * _height; i++)
{
rect[i] = 13;
}
rgn.SetRect(rect, 0, 0, _width, _height);
var result = rgn.GetRect(0, 0, _width, _height);
Assert.AreEqual(rect, result);
}
public static IntPtr Register(PixelRgn rgn) => gimp_pixel_rgns_register(1, ref *rgn.pr);
public override void flushBuffer()
{
if (_imageBuffer != null) {
PixelRgn destPR = new PixelRgn(_drawable, true, true);
destPR.SetRect(_imageBuffer, _rectangle.X1, _rectangle.Y1,
_rectangle.Width, _rectangle.Height);
_drawable.Flush();
_drawable.MergeShadow(true);
_drawable.Update(_rectangle);
}
_imageBuffer = null;
}
internal Pixel(PixelRgn rgn, byte[] rgb)
: this(rgb)
{
_rgn = rgn;
}
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 static IntPtr Register(PixelRgn rgn)
{
return gimp_pixel_rgns_register(1, ref *rgn.pr);
}
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);
}
}
}
}
public void GetSetRow()
{
var rgn = new PixelRgn(_drawable, false, false);
var row = new Pixel[_width];
for (int i = 0; i < _width; i++)
{
row[i] = new Pixel(13, 13, 13);
}
rgn.SetRow(row, 0, 13);
var result = rgn.GetRow(0, 13, _width);
for (int i = 0; i < _width; i++)
{
Assert.IsTrue(row[i].IsSameColor(result[i]));
}
}
internal Pixel(PixelRgn rgn, byte[] rgb) : this(rgb)
{
_rgn = rgn;
}
public void SetBuffer(byte[] buffer)
{
var rgn = new PixelRgn(this, true, false);
rgn.SetRect(buffer, Bounds);
}
public void Rowstride()
{
var rgn = new PixelRgn(_drawable, false, false);
PixelRgn.Register(rgn);
Assert.AreEqual(_drawable.Bpp * Gimp.TileWidth, rgn.Rowstride);
}
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 double? RegionDistance(Pixel[,] source, Rectangle rgnRect, Drawable drawable, SelectionMask selectionMask)
{
var sum = 0.0;
var sourceWidth = source.GetLength(0);
var sourceHeight = source.GetLength(1);
var rgn = new PixelRgn(drawable, rgnRect, false, false);
for (IntPtr pr = PixelRgn.Register(rgn);
pr != IntPtr.Zero;
pr = PixelRgn.Process(pr))
{
for (int y1 = rgn.Y - rgnRect.UpperLeft.Y, y2 = rgn.Y;
y2 < rgn.Y + rgn.H;
y1++, y2++)
{
for (int x1 = rgn.X - rgnRect.UpperLeft.X, x2 = rgn.X;
x2 < rgn.X + rgn.W;
x1++, x2++)
{
if (selectionMask[x2, y2])
{
return null;
}
if (x1 >= sourceWidth ||
x2 >= sourceHeight ||
source[x1, y1] == null)
{
continue;
}
sum += DistanceSqr(source[x1, y1], rgn[y2, x2]);
}
}
}
return sum;
}
public void DrawRegion(PixelRgn region)
{
var pr = region.PR;
gimp_drawable_preview_draw_region(Handle, ref pr);
}
public void Render(Image image, Drawable drawable)
{
if (image.Selection.Empty)
{
return;
}
image.UndoGroupStart();
Tile.CacheDefault(drawable);
var temp = image.Duplicate();
var imageRect = image.Bounds;
var layerPixels = LayerToArray(imageRect, drawable);
//temp.Selection.Border(1);
bool selectionNonEmpty;
var selectionBounds = temp.Selection.Bounds(out selectionNonEmpty);
var selectionMask = new SelectionMask(temp.Selection);
//var progress = new Progress(_("Filling the region..."));
var initArea = selectionMask.Area;
//init confidance term
//TODO throw out rgniterator from here
var pxConfidenceTerm = RegionHelper.FilledMatrix(image.Width, image.Height, 1.0);
var iter = new RgnIterator(image.Selection, RunMode.Noninteractive);
iter.IterateSrc(pixel => pxConfidenceTerm[pixel.X, pixel.Y] = selectionMask[pixel.X, pixel.Y] ? 0 : 1);
int iteration = 0;
while (!selectionMask.Empty && iteration < _iterations)
{
// initial selection border / target region
var selectionBorder =
RegionHelper.TraceBorder(selectionBounds,
coord => selectionMask[coord.X, coord.Y])
.ToList();
var borderConfidanceValues = NewConfidanceValue(selectionBorder, pxConfidenceTerm, _windowSize);
var borderGradientValues = GradientValues(selectionBorder, layerPixels, selectionMask, _windowSize).ToList();
var borderNormals = NormalVectors.CalculateNormals(selectionBorder);
var borderDataTerms = borderGradientValues.Zip(borderNormals, ComputeDataTerm);
var borderPriorities = borderConfidanceValues.Zip(borderDataTerms, (c, d) => c * d)
.ToArray();
var currentIndex = borderPriorities.MaxIndex();
var currentPoint = selectionBorder[currentIndex];
var currentRect = currentPoint.PointCenteredRectangle(_windowSize);
var currentRegion = new PixelRgn(drawable, currentRect, true, true);
var minRgnRect = _pixelDistanceCalc.MinDistanceRegion(currentRect, borderGradientValues[currentIndex], layerPixels,
selectionMask);
var minRgn = new PixelRgn(drawable, minRgnRect, false, false);
var iterator = new RegionIterator(currentRegion, minRgn);
iterator.ForEach((targetPixel, srcPixel) =>
{
if (!selectionMask[targetPixel.X, targetPixel.Y])
{
return;
}
layerPixels[targetPixel.X, targetPixel.Y] = srcPixel;
targetPixel.Set(srcPixel);
});
drawable.Flush();
drawable.MergeShadow(true);
drawable.Update(temp.Selection.MaskBounds);
//update confidance values
var currentCoords =
RegionHelper.Grid(currentRect).Where(coord => selectionMask[coord.X, coord.Y]).ToArray();
var newConfidanceValues = NewConfidanceValue(currentCoords, pxConfidenceTerm, _windowSize).ToArray();
foreach (var point in
currentCoords.Zip(newConfidanceValues,
(coordinate, confidance) =>
new {Coordinate = coordinate, Confidance = confidance}))
{
pxConfidenceTerm[point.Coordinate.X, point.Coordinate.Y] = point.Confidance;
}
// exclude current region pixels from selection
selectionMask.SetAreaToZero(currentRect);
//progress.Update((initArea - selectionMask.Area)/(double) initArea);
iteration++;
if (iteration == _iterations)
{
selectionBorder =
RegionHelper.TraceBorder(selectionBounds,
coord => selectionMask[coord.X, coord.Y])
.ToList();
var rgn = new PixelRgn(drawable, selectionBounds, true, true);
for (int i = 0; i < selectionBorder.Count; i++)
{
var coord = selectionBorder[i];
rgn.SetPixel(new byte[] { (byte)(255), 0, 0, 255 }, coord.X, coord.Y);
}
drawable.Flush();
drawable.MergeShadow(false);
drawable.Update(temp.Selection.MaskBounds);
}
}
temp.Delete();
image.UndoGroupEnd();
}
public static IntPtr Register(PixelRgn rgn1, PixelRgn rgn2,
PixelRgn rgn3)
{
return gimp_pixel_rgns_register(3, ref *rgn1.pr, ref *rgn2.pr,
ref *rgn3.pr);
}
public void GetSetPixel()
{
var rgn = new PixelRgn(_drawable, false, false);
var pixel = new byte[]{13, 24, 35};
rgn.SetPixel(pixel, 13, 14);
var result = new byte[_drawable.Bpp];
rgn.GetPixel(result, 13, 14);
Assert.AreEqual(pixel, result);
}
public override void initBuffer()
{
PixelRgn rgn = new PixelRgn(_drawable, false, false);
_imageBuffer = rgn.GetRect(_rectangle.X1, _rectangle.Y1,
_rectangle.Width, _rectangle.Height);
}
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 static IntPtr Register(PixelRgn rgn1, PixelRgn rgn2)
{
return(gimp_pixel_rgns_register(2, ref *rgn1.pr, ref *rgn2.pr));
}
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 static IntPtr Register(PixelRgn rgn1, PixelRgn rgn2,
PixelRgn rgn3) =>
gimp_pixel_rgns_register(3, ref *rgn1.pr, ref *rgn2.pr, ref *rgn3.pr);
public void DrawRegion(PixelRgn region)
{
var pr = region.PR;
gimp_drawable_preview_draw_region(Handle, ref pr);
}
public static IntPtr Register(PixelRgn rgn)
{
return(gimp_pixel_rgns_register(1, ref *rgn.pr));
}
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;
}
}
}
}
private Pixel[,] LayerToArray(Rectangle imageRect, Drawable drawable)
{
var pixels = new Pixel[imageRect.Width, imageRect.Height];
var rgn = new PixelRgn(drawable, imageRect, false, false);
var iterator = new RegionIterator(rgn);
iterator.ForEach(pixel =>
pixels[pixel.X, pixel.Y] = pixel);
return pixels;
}
public void SetBuffer(byte[] buffer)
{
var rgn = new PixelRgn(this, true, false);
rgn.SetRect(buffer, Bounds);
}
