public static Rectangle AdjustedToImageEdges(this Rectangle originRect, Rectangle imageRect)
{
var rect = new Rectangle(originRect.UpperLeft, originRect.LowerRight);
if (!imageRect.IsInside(rect.UpperLeft))
{
if (rect.UpperLeft.X < imageRect.UpperLeft.X)
{
rect.UpperLeft.X = imageRect.UpperLeft.X;
}
if (rect.UpperLeft.Y < imageRect.UpperLeft.Y)
{
rect.UpperLeft.Y = imageRect.UpperLeft.Y;
}
}
if (!imageRect.IsInside(rect.LowerRight))
{
if (rect.LowerRight.X > imageRect.LowerRight.X)
{
rect.LowerRight.X = imageRect.LowerRight.X;
}
if (rect.LowerRight.Y > imageRect.LowerRight.Y)
{
rect.LowerRight.Y = imageRect.LowerRight.Y;
}
}
return rect;
}
public void ConstructorOne()
{
var rectangle = new Rectangle(13, 14, 129, 132);
Assert.AreEqual(13, rectangle.X1);
Assert.AreEqual(14, rectangle.Y1);
Assert.AreEqual(129, rectangle.X2);
Assert.AreEqual(132, rectangle.Y2);
}
private Rectangle _rectangle; // mask bounds
#endregion Fields
#region Constructors
/// <summary>
/// Create a GSImage backed with an existing Drawable.
/// </summary>
/// <param name="drawable"></param>
public GSImage(Drawable drawable)
{
_image = drawable.Image;
_drawable = drawable;
_rectangle = _drawable.MaskBounds;
Tile.CacheDefault(_drawable);
Progress = new Progress("Halftone Laboratory");
}
public void Equals()
{
var rectangle1 = new Rectangle(13, 14, 129, 132);
var rectangle2 = new Rectangle(23, 24, 129, 132);
var rectangle3 = new Rectangle(13, 14, 129, 132);
Assert.IsFalse(rectangle1.Equals(rectangle2));
Assert.IsTrue(rectangle1.Equals(rectangle3));
}
public void ConstructorTwo()
{
var upperLeft = new Coordinate<int>(13, 14);
var lowerRight = new Coordinate<int>(129, 132);
var rectangle = new Rectangle(upperLeft, lowerRight);
Assert.AreEqual(13, rectangle.X1);
Assert.AreEqual(14, rectangle.Y1);
Assert.AreEqual(129, rectangle.X2);
Assert.AreEqual(132, rectangle.Y2);
}
/// <summary>
/// Create a GSImage backed with a new %Gimp# Image.
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
public GSImage(int width, int height)
{
_image = new Gimp.Image(width, height, ImageBaseType.Gray);
Layer layer = new Layer(_image, "default", width, height,
ImageType.Gray, 100, LayerModeEffects.Normal);
_image.AddLayer(layer, 0);
_drawable = _image.ActiveDrawable;
_rectangle = _drawable.MaskBounds;
Tile.CacheDefault(_drawable);
Progress = new Progress("Halftone Laboratory");
}
public void Operators()
{
var rectangle1 = new Rectangle(13, 14, 129, 132);
var rectangle2 = new Rectangle(23, 24, 129, 132);
var rectangle3 = new Rectangle(13, 14, 129, 132);
Assert.IsFalse(rectangle1 == rectangle2);
Assert.IsTrue(rectangle1 != rectangle2);
Assert.IsTrue(rectangle1 == rectangle3);
Assert.IsFalse(rectangle1 != rectangle3);
}
public void SetAreaToZero(Rectangle rect)
{
for (int i = rect.X1; i < rect.X1 + rect.Width; i++)
{
for (int j = rect.Y1; j < rect.Y1 + rect.Height; j++)
{
if (!_originBounds.IsInside(i, j) ||
!_mask[i - _originBounds.X1, j - _originBounds.Y1])
{
continue;
}
_mask[i - _originBounds.X1, j - _originBounds.Y1] = false;
_area--;
}
}
}
public Rectangle MinDistanceRegion(Rectangle sourceRect, ImgGradient gradient, Pixel[,] layerPixels, SelectionMask selectionMask)
{
Debug.Assert(sourceRect.Width == sourceRect.Height);
var windowSize = sourceRect.Width;
var windowDelta = windowSize/2;
var layerWidth = layerPixels.GetLength(0);
var layerHeight = layerPixels.GetLength(1);
Rectangle minRegionRect = null;
var minDistance = 0.0;
var adjustedSourceRect = sourceRect.AdjustedToImageEdges(new Rectangle(new IntCoordinate(0, 0),
layerWidth, layerHeight));
var currentCoordinate = new IntCoordinate(0, 0);
var orthoGradient = new Coordinate<double>(-gradient.YMagnitude*windowDelta,
gradient.XMagnitude*windowDelta);
for (int i = windowDelta; i < layerWidth - windowDelta; i++)
{
for (int j = windowDelta; j < layerHeight - 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(adjustedSourceRect, currentRgnRect, layerPixels, selectionMask);
if (dist == null)
{
continue;
}
if (dist == 0)
{
return currentRgnRect;
}
if ((minDistance > dist || minRegionRect == null))
{
minDistance = (double) dist;
minRegionRect = currentRgnRect;
}
}
}
return minRegionRect;
}
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 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 Draw(Rectangle rectangle, ImageType type, byte[] buf,
int rowstride)
{
Draw(rectangle.X1, rectangle.Y1, rectangle.Width, rectangle.Height,
type, buf, rowstride);
}
public CoordinateGenerator(Rectangle rectangle, Action<int> update = null)
{
_rectangle = rectangle;
_update = update;
}
public void Width()
{
var rectangle = new Rectangle(13, 14, 129, 132);
Assert.AreEqual(129 - 13, rectangle.Width);
}
public void Area()
{
var rectangle = new Rectangle(13, 14, 129, 132);
Assert.AreEqual((129 - 13) * (132 - 14), rectangle.Area);
}
/// <summary>
/// Scale the image with a given factor and interpolation.
/// </summary>
/// <remarks>
/// If there is an buffer, it gets flushed before scaling.
/// </remarks>
/// <param name="factor">Resize factor (< 1.0 = downscale, >1.0 =
/// upscale)</param>
/// <param name="interpolation">Interpolation type</param>
/// <param name="direction">Scale direction (forward = scale by factor,
/// backward = scale by 1/factor)</param>
public void scale(double factor, InterpolationType interpolation,
TransformDirection direction)
{
bool restoreBuffer = _imageBuffer != null;
if (restoreBuffer) {
flushBuffer();
}
double newHeight = Height * factor;
double newWidth = Width * factor;
Image.UndoGroupStart();
Drawable.TransformScale(0, 0, newWidth, newHeight,
direction, interpolation, false, 1, false);
Image.ResizeToLayers();
Image.UndoGroupEnd();
_drawable = Image.ActiveDrawable;
_rectangle = Drawable.MaskBounds;
if (restoreBuffer) {
initBuffer();
}
}
public PixelRgn(Drawable drawable, Rectangle rectangle, bool dirty,
bool shadow)
: this(drawable, rectangle.X1, rectangle.Y1, rectangle.Width,
rectangle.Height, dirty, shadow)
{
}
public void UpperLeftLowerRight()
{
var upperLeft = new Coordinate<int>(13, 14);
var lowerRight = new Coordinate<int>(129, 132);
var rectangle = new Rectangle(upperLeft, lowerRight);
Assert.IsTrue(rectangle.UpperLeft == upperLeft);
Assert.IsTrue(rectangle.LowerRight == lowerRight);
}
public byte[] GetRect(Rectangle rectangle)
{
return GetRect(rectangle.X1, rectangle.Y1, rectangle.Width,
rectangle.Height);
}
public void Update(Rectangle rectangle)
{
Update(rectangle.X1, rectangle.Y1, rectangle.Width, rectangle.Height);
}
public Pixel[,] GetThumbnailData(Rectangle rectangle,
Dimensions dimensions)
{
int width = dimensions.Width;
int height = dimensions.Height;
int bpp;
IntPtr src = gimp_drawable_get_sub_thumbnail_data(ID, rectangle.X1,
rectangle.Y1,
rectangle.Width,
rectangle.Height,
ref width, ref height,
out bpp);
var thumbnail =
Pixel.ConvertToPixelArray(src, new Dimensions(width, height), bpp);
Marshaller.Free(src);
return thumbnail;
}
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 CropThree()
{
var rectangle = new Rectangle(10, 10, 20, 20);
_image.Crop(rectangle);
Assert.AreEqual(rectangle.Width, _image.Width);
Assert.AreEqual(rectangle.Height, _image.Height);
}
public double? RegionDistance(Rectangle sourceRect, Rectangle rgnRect, Pixel[,] layerPixels,
SelectionMask selectionMask)
{
var sum = 0.0;
var sourceWidth = sourceRect.Width;
var sourceHeight = sourceRect.Height;
for (int y1 = sourceRect.Y1, y2 = rgnRect.Y1;
y1 < sourceRect.Y1 + sourceHeight;
y1++, y2++)
{
for (int x1 = sourceRect.X1, x2 = rgnRect.X1;
x1 < sourceRect.X1 + sourceWidth;
x1++, x2++)
{
//if there's selection pixel inside of examined region mark region as useless
if (selectionMask[x2, y2])
{
return null;
}
//if it's pixel from target region don't examine it
if (selectionMask[x1, y1])
{
continue;
}
sum += DistanceSqr(layerPixels[x1, y1], layerPixels[x2, y2]);
}
}
return sum;
}
public void SetRect(byte[] buf, Rectangle rectangle)
{
SetRect(buf, rectangle.X1, rectangle.Y1, rectangle.Width,
rectangle.Height);
}
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 Height()
{
var rectangle = new Rectangle(13, 14, 129, 132);
Assert.AreEqual(132 - 14, rectangle.Height);
}
public RgnIterator(Drawable drawable, RunMode runmode)
{
_drawable = drawable;
_runmode = runmode;
_rectangle = drawable.MaskBounds;
}
/// <summary>
/// Calculate new confidance value of pixel at given coordinate
/// </summary>
/// <param name="coordinate"></param>
/// <param name="pxConfidenceTerm"></param>
/// <param name="windowSize"></param>
private static double NewConfidanceValue(IntCoordinate coordinate, double[,] pxConfidenceTerm,
int windowSize)
{
var imageRect = new Rectangle(new IntCoordinate(0, 0), pxConfidenceTerm.GetLength(0),
pxConfidenceTerm.GetLength(1));
//TODO: handle boundary regions properly
return RegionHelper.Grid(coordinate.PointCenteredRectangle(windowSize))
.Select(coordPrim => imageRect.IsInside(coordPrim)
? pxConfidenceTerm[coordPrim.X, coordPrim.Y]
: 0)
.Sum()/(windowSize*windowSize);
}
