public AspectPreview(Drawable drawable, bool toggle = false)
: base(gimp_aspect_preview_new(drawable.Ptr, toggle))
{
_drawableWidth = drawable.Width;
_drawableHeight = drawable.Height;
_bpp = drawable.Bpp;
}
public void Init()
{
_image = new Image(_width, _height, ImageBaseType.Rgb) {
{new Layer(_image, "test", _width, _height, ImageType.Rgb, 100,
LayerModeEffects.Normal), 0}};
_drawable = _image.ActiveDrawable;
}
public void Attach(Drawable drawable)
{
if (!gimp_floating_sel_attach(_ID, drawable.ID))
{
throw new GimpSharpException();
}
}
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 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 Init()
{
_image = new Image(_width, _height, ImageBaseType.Rgb) {
{new Layer("test", ImageType.Rgb), 0}};
_drawable = _image.ActiveDrawable;
_selection = _image.Selection;
}
public PixelRgn(Drawable drawable, int x, int y, int width, int height,
bool dirty, bool shadow)
{
pr = (GimpPixelRgn*)g_malloc(sizeof(GimpPixelRgn));
gimp_pixel_rgn_init(ref *pr, drawable.Ptr, x, y, width, height, dirty,
shadow);
_bpp = (int) pr->bpp;
_dummy = new byte[pr->bpp];
_dirty = dirty;
_drawable = drawable;
}
/// <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 GimpDialogWithPreview(string title, Drawable drawable,
VariableSet variables,
Func<GimpPreview> factory)
: base(title, variables)
{
Drawable = drawable;
Vbox = new VBox(false, 0) {BorderWidth = 12};
VBox.PackStart(Vbox, true, true, 0);
Preview = factory();
Preview.Invalidated += delegate {UpdatePreview(Preview);};
Vbox.PackStart(Preview, true, true, 0);
variables.ValueChanged += delegate {InvalidatePreview();};
}
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 ZoomPreview(Drawable drawable, ZoomModel model)
: base(gimp_zoom_preview_new_with_model(drawable.Ptr, model.Ptr))
{
Drawable = drawable;
}
/// <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 static void CacheDefault(Drawable drawable)
{
CacheNtiles = (ulong) (2 * (drawable.Width / Gimp.TileWidth + 1));
}
public FuzzySelectTool(Drawable drawable)
{
_drawableID = drawable.ID;
}
public RgnIterator(Drawable drawable, String progressText)
: this(drawable, RunMode.Interactive)
{
Progress = new Progress(progressText);
}
// Used internally to save a single drawable
internal bool Save(Drawable drawable, string filename)
{
return gimp_file_save(RunMode.Noninteractive, ID, drawable.ID,
filename, filename);
}
internal virtual GimpPreview Instantiate(Drawable drawable)
{
return null;
}
public ReadPixelIterator(Drawable drawable,
RunMode runmode = RunMode.Noninteractive)
{
_drawable = drawable;
_runmode = runmode;
}
public DrawablePreview(Drawable drawable, bool toggle = false)
: base(gimp_drawable_preview_new(drawable.Ptr, toggle))
{
Drawable = drawable;
_bpp = drawable.Bpp;
}
public RgnIterator(Drawable drawable, RunMode runmode)
{
_drawable = drawable;
_runmode = runmode;
_rectangle = drawable.MaskBounds;
}
public ByColorSelectTool(Drawable drawable)
{
_drawableID = drawable.ID;
}
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 RGB PickColor(Drawable drawable, Coordinate<double> c,
bool sampleMerged, bool sampleAverage,
double averageRadius)
{
GimpRGB color;
if (!gimp_image_pick_color(ID, drawable.ID, c.X, c.Y,
sampleMerged, sampleAverage, averageRadius,
out color))
{
return null;
}
return new RGB(color);
}
public ZoomPreview(Drawable drawable)
: base(gimp_zoom_preview_new(drawable.Ptr))
{
Drawable = drawable;
}
public void Redraw(Drawable drawable)
{
var rectangle = Bounds;
int bpp = drawable.Bpp;
int rowStride = rectangle.Width * bpp;
var buffer = new byte[rectangle.Area * bpp];
foreach (var pixel in new ReadPixelIterator(drawable))
{
int index = pixel.Y * rowStride + pixel.X * bpp;
pixel.CopyTo(buffer, index);
}
DrawBuffer(buffer, rowStride);
}
public PixelRgn(Drawable drawable, Rectangle rectangle, bool dirty,
bool shadow)
: this(drawable, rectangle.X1, rectangle.Y1, rectangle.Width,
rectangle.Height, dirty, shadow)
{
}
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 PixelRgn(Drawable drawable, bool dirty, bool shadow)
: this(drawable, 0, 0, drawable.Width, drawable.Height, dirty, shadow)
{
}
public Layer Float(Drawable drawable, int offx, int offy)
{
return new Layer(gimp_selection_float(_imageID,
drawable.ID, offx, offy));
}
protected virtual bool Save(Image image, Drawable drawable,
string filename)
{
return false;
}
