public override void Apply(Aurigma.GraphicsMill.Bitmap bitmap)
{
base.Apply(bitmap);
_redEyeRemoval.Progress += new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
_redEyeRemoval.ApplyTransform(bitmap);
_redEyeRemoval.Progress -= new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
}
public override void Apply(Aurigma.GraphicsMill.Bitmap bitmap)
{
base.Apply(bitmap);
bitmap.Progress += new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
bitmap.Transforms.RotateAndFlip(_rotateFlipType);
bitmap.Progress -= new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
}
public virtual void AddImage(Aurigma.GraphicsMill.Bitmap image, object key)
{
if (!_imageList.HandleCreated)
{
throw new Aurigma.GraphicsMill.UnexpectedException("Handle has not been created.");
}
if (key == null)
{
throw new System.ArgumentNullException("key");
}
lock (this)
{
if (_imageList == null)
{
return;
}
if (!ContainsKey(key))
{
int index = _AddImageInternal(image, -1);
_keysHash.Add(key, index);
}
}
}
public static IBitmapTransform ApplyTransform(Aurigma.GraphicsMill.Bitmap bitmap, System.Windows.Forms.UserControl propertyPage)
{
ITransformPropertyPage tpp = (ITransformPropertyPage)propertyPage;
tpp.Bitmap = bitmap;
TransformDialog dialog = new TransformDialog();
dialog.SuspendLayout();
dialog.ClientSize = new System.Drawing.Size(propertyPage.Width + 118, propertyPage.Height + 16);
propertyPage.Location = new System.Drawing.Point(8, 8);
propertyPage.TabIndex = 0;
dialog.Controls.Add(propertyPage);
dialog.buttonOK.Left = propertyPage.Width + 24;
dialog.buttonCancel.Left = propertyPage.Width + 24;
dialog.ResumeLayout(false);
dialog.Text = tpp.Title;
if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
return(tpp.Transform);
}
else
{
return(null);
}
}
public void SetThumbnail(Aurigma.GraphicsMill.Bitmap thumbnail)
{
if (thumbnail == null)
{
throw new System.ArgumentNullException("thumbnail");
}
IImageList imageList = this.Parent.GetImageList(View.Thumbnails);
if (!HasIcon(View.Thumbnails))
{
lock (imageList)
{
lock (this)
{
if (base.Parent != null)
{
base.Parent.QueueManager.Remove((IQueueItem)this);
}
imageList.AddImage(thumbnail, this);
_imageIndexKeys[View.Thumbnails] = this;
}
}
}
else
{
imageList.SetImage(thumbnail, this);
}
OnIconChanged(View.Thumbnails);
}
private void DoTransformBitmap(object bitmapObject)
{
Aurigma.GraphicsMill.Bitmap bitmap = (Aurigma.GraphicsMill.Bitmap)bitmapObject;
int transformsProgressStepCount = 0;
for (int i = 0; i < _transformIndex; i++)
{
transformsProgressStepCount += _transforms[i].TransformProgressStepCount;
}
_progressDialog.SetRange(0, transformsProgressStepCount);
for (int i = 0; i < _transformIndex; i++)
{
if (_progressDialog.IsAborted)
{
break;
}
_transforms[i].Progress += new Aurigma.GraphicsMill.ProgressEventHandler(TransformProgressEventHandler);
_transforms[i].Apply(bitmap);
_transforms[i].Progress -= new Aurigma.GraphicsMill.ProgressEventHandler(TransformProgressEventHandler);
}
if (_progressDialog.IsAborted)
{
_progressDialog.IsComplete = false;
}
else
{
_progressDialog.IsComplete = true;
}
_progressDialog.End();
}
public ImageVObject(Aurigma.GraphicsMill.Bitmap image, bool scaleToActualSize, float x, float y)
{
if (image == null)
{
throw new System.ArgumentNullException("image");
}
if (image.IsEmpty)
{
throw new System.ArgumentException(StringResources.GetString("ExStrBitmapCannotBeEmpty"), "image");
}
base.Name = "image";
_image = image;
_scaleToActualSize = scaleToActualSize;
float widthInPoints = Aurigma.GraphicsMill.UnitConverter.ConvertPixelsToUnits(this.DrawnImage.HorizontalResolution, this.DrawnImage.Width, Aurigma.GraphicsMill.Unit.Point);
float heightInPoints = Aurigma.GraphicsMill.UnitConverter.ConvertPixelsToUnits(this.DrawnImage.VerticalResolution, this.DrawnImage.Height, Aurigma.GraphicsMill.Unit.Point);
_rect = new RectangleVObject(0, 0, widthInPoints, heightInPoints);
_rect.Brush = System.Drawing.Brushes.Transparent;
_rect.Pen = null;
_rect.Transform.Translate(x, y);
}
/// <summary>
/// Loads non-RGB image with Aurigma.GraphicsMill.Bitmap, pass it to System.Drawing.Bitmap and
/// convert it back to Aurigma.GraphicsMill.Bitmap.
/// </summary>
private static void ProcessNonRgb()
{
// Imagine that you have a legacy application which works with System.Drawing.Bitmap,
// and you need to work with non-RGB images. You should convert it to RGB with Graphics Mill, cast it
// to System.Drawing.Bitmap and convert back.
using (var reader = new Aurigma.GraphicsMill.Codecs.JpegReader("../../../../_Input/Copenhagen_CMYK.jpg"))
using (var gmBitmap1 = reader.Frames[0].GetBitmap())
{
Aurigma.GraphicsMill.Bitmap rgbGmBitmap = null;
try
{
// Convert a non-RGB image to the RGB color space with the sRGB color profile
if (!gmBitmap1.PixelFormat.IsRgb)
{
rgbGmBitmap = new Aurigma.GraphicsMill.Bitmap(gmBitmap1);
rgbGmBitmap.ColorManagement.DestinationProfile = Aurigma.GraphicsMill.ColorProfile.FromSrgb();
rgbGmBitmap.ColorManagement.Convert(Aurigma.GraphicsMill.PixelFormat.Format24bppRgb);
}
using (var sdBitmap = (System.Drawing.Bitmap)(gmBitmap1.PixelFormat.IsRgb ? gmBitmap1 : rgbGmBitmap))
{
// Here we modify System.Drawing.Bitmap
ApplyWatermark(sdBitmap);
using (var gmBitmap2 = (Aurigma.GraphicsMill.Bitmap)sdBitmap)
{
// Convert an RGB image to the source color space (CMYK, grayscale, or Lab)
if (!gmBitmap1.PixelFormat.IsRgb)
{
gmBitmap2.ColorProfile = Aurigma.GraphicsMill.ColorProfile.FromSrgb();
gmBitmap2.ColorManagement.DestinationProfile = gmBitmap1.ColorProfile;
gmBitmap2.ColorManagement.Convert(gmBitmap1.PixelFormat);
}
// Copy color profile
gmBitmap2.ColorProfile = gmBitmap1.ColorProfile;
using (var writer = new Aurigma.GraphicsMill.Codecs.JpegWriter("../../../../_Output/ProcessNonRgb.jpg"))
{
// Copy metadata
writer.Exif = reader.Exif;
writer.Iptc = reader.Iptc;
writer.Xmp = reader.Xmp;
writer.AdobeResources = reader.AdobeResources;
Aurigma.GraphicsMill.Pipeline.Run(gmBitmap2 + writer);
}
}
}
}
finally
{
if (rgbGmBitmap != null)
{
rgbGmBitmap.Dispose();
}
}
}
}
public void Render(Aurigma.GraphicsMill.Bitmap canvas, float zoom, System.Drawing.Rectangle viewport, System.Drawing.Rectangle renderingRegion)
{
if (viewport.Width < 1 || viewport.Height < 1 || renderingRegion.Width < 1 || renderingRegion.Height < 1)
{
return;
}
if (canvas == null)
{
throw new System.ArgumentNullException("canvas");
}
if (canvas.IsEmpty)
{
throw new System.ArgumentException(StringResources.GetString("ExStrBitmapCannotBeEmpty"), "canvas");
}
if (!viewport.Contains(renderingRegion))
{
throw new System.ArgumentException(StringResources.GetString("ExStrRenderingRegionShouldBeInsideViewport"), "renderingRegion");
}
System.Drawing.Rectangle viewportInvalidatedRect = CoordinateMapper.WorkspaceToControl(this.InvalidatedRegion, zoom, System.Drawing.Point.Empty, Aurigma.GraphicsMill.Unit.Point, _renderingResolution);
if (renderingRegion.IntersectsWith(viewportInvalidatedRect) || !_viewportCache.IsEntirelyInCache(zoom, renderingRegion))
{
BuildUpViewportImage(canvas, zoom, viewport, viewportInvalidatedRect);
this.InvalidatedRegion = System.Drawing.RectangleF.Empty;
_viewportCache.UpdateCache(canvas, zoom, viewport);
}
else
{
System.Diagnostics.Debug.Assert(_viewportCache.IsEntirelyInCache(zoom, renderingRegion), "At this point we should already have actual image in cache.");
_viewportCache.DrawCached(canvas, zoom, viewport, renderingRegion);
}
}
/// <summary>
/// Retrieves thumbnail for specified file.
/// </summary>
/// <param name="pidl">Source object for which info should be retrieved.</param>
/// <param name="width">Desired thumbnail width.</param>
/// <param name="height">Desired thumbnail heigth</param>
/// <param name="image">Reference to variable where to store result thumbnail.</param>
/// <param name="icon">Reference to variable where to store large icon handle, in case when file thumbnail cannot be created.</param>
public static void RetrieveThumbnail(Pidl pidl, int width, int height, ref Aurigma.GraphicsMill.Bitmap image, ref IntPtr icon)
{
image = null;
icon = IntPtr.Zero;
try
{
using (var stream = pidl.Stream)
using (var reader = Aurigma.GraphicsMill.Codecs.ImageReader.Create(stream))
{
if (reader != null)
{
image = ExtractExifThumbnail(reader, width, height);
if (image == null)
{
image = reader.Frames[0].GetBitmap();
image.Transforms.Resize(width, height, Transforms.ResizeInterpolationMode.High, Transforms.ResizeMode.Fit);
}
}
}
}
catch
{
image = null;
}
if (image == null)
{
icon = FileInfoRetriever.GetIcon(pidl, false);
}
}
public override void Apply(Aurigma.GraphicsMill.Bitmap bitmap)
{
base.Apply(bitmap);
bitmap.Progress += new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
bitmap.Transforms.Crop(_x, _y, _width, _height);
bitmap.Progress -= new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
}
/// <summary>
/// Third method associated with the item. It retrieves file thumbnail.
/// </summary>
/// <returns>true if succeded; otherwise, false.</returns>
private bool EvalMethod2()
{
if (this.Parent == null)
{
return(false);
}
Aurigma.GraphicsMill.Bitmap image = null;
System.IntPtr icon = System.IntPtr.Zero;
try
{
if (this.Parent != null)
{
ThumbnailImageList imageList = (ThumbnailImageList)this.Parent.GetImageList(View.Thumbnails);
FileInfoRetriever.RetrieveThumbnail(_pidl, imageList.ThumbnailSize.Width, imageList.ThumbnailSize.Height, ref image, ref icon);
if (image == null && icon != System.IntPtr.Zero)
{
image = ImageListBase.IconToAlphaBitmap(icon);
}
OnThumbnailLoaded(image);
lock (imageList)
{
lock (this)
{
_imageIndexKeys[View.Thumbnails] = this;
if (this.Parent != null)
{
_imageIndexKeys[View.Thumbnails] = this;
if (imageList.ContainsKey(this))
{
imageList.SetImage(image, this);
}
else
{
imageList.AddImage(image, this);
}
}
}
}
}
}
finally
{
if (image != null)
{
image.Dispose();
}
NativeMethods.DestroyIcon(icon);
}
return(true);
}
/// <summary>
/// Ignores modifyLayer - not supported by this renderer.
/// </summary>
/// <param name="s"></param>
/// <param name="textLayers"></param>
/// <param name="showLayerCallback"></param>
/// <param name="modifyLayer"></param>
/// <returns></returns>
public System.Drawing.Bitmap Render(Stream s, out IList<IPsdLayer> layers, RenderLayerDelegate showLayerCallback, ModifyLayerDelegate modifyLayer)
{
// Create the resultBitmap object which contains merged bitmap,
// and the currentBitmap object which contains current bitmap during iteration.
// These object enable you to operate with layers.
Aurigma.GraphicsMill.Bitmap resultBitmap = new Aurigma.GraphicsMill.Bitmap();
using (Aurigma.GraphicsMill.Bitmap currentBitmap = new Aurigma.GraphicsMill.Bitmap())
{
// Create advanced PSD reader object to read .psd files.
using (Aurigma.GraphicsMill.Codecs.AdvancedPsdReader psdReader = new Aurigma.GraphicsMill.Codecs.AdvancedPsdReader(s))
{
// Load the background layer which you will put other layers on.
// Remember that the layer on zero position should be skiped
// because it contains merged bitmap.
Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame frame;
using (frame = (Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame)psdReader.LoadFrame(1))
{
frame.GetBitmap(resultBitmap);
}
//List of layers
layers = new List<IPsdLayer>();
//This code merges the rest layers with the background layer one by one.
for (int i = 2; i < psdReader.FrameCount; i++)
{
using (frame = (Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame)psdReader.LoadFrame(i))
{
// Do not forget to verify the unknown layer type.
if (frame.Type != Aurigma.GraphicsMill.Codecs.PsdFrameType.Unknown)
{
//Add layers
layers.Add(new PsdLayer(frame, i + 1));
bool showFrame = showLayerCallback(i - 1, frame.Name, frame.Visible); //Subtract 1 from index so layer 0 is the background layer
if (showFrame)
{
// Extract the current image from the layer.
frame.GetBitmap(currentBitmap);
// Draw current layer on the result bitmap.
// Also check out if the layer is visible or not.
// If the layer is invisible we skip it.
currentBitmap.Draw(currentBitmap, frame.Left, frame.Top, frame.Width, frame.Height, Aurigma.GraphicsMill.Transforms.CombineMode.Alpha, 1, Aurigma.GraphicsMill.Transforms.InterpolationMode.HighQuality);
}
}
}
}
}
}
return resultBitmap.ToGdiplusBitmapDirectly();
}
//Overload for Aurigma bitmaps
public static bool CheckForMovement(Aurigma.GraphicsMill.Bitmap aurigmaFile)
{
bool verdict = false;
using (System.Drawing.Bitmap inputFile = aurigmaFile.ToGdiPlusBitmap())
{
verdict = AnalyzeImage(inputFile);
}
return(verdict);
}
public override void Apply(Aurigma.GraphicsMill.Bitmap bitmap)
{
base.Apply(bitmap);
foreach (Transform transform in _transforms)
{
transform.Progress += new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
transform.Apply(bitmap);
transform.Progress -= new Aurigma.GraphicsMill.ProgressEventHandler(ProgressEventHandler);
}
}
private void Clear()
{
_zoom = -1.0f;
if (_image != null)
{
_image.Dispose();
_image = null;
}
}
/// <summary>
/// Ignores modifyLayer - not supported by this renderer.
/// </summary>
/// <param name="s"></param>
/// <param name="textLayers"></param>
/// <param name="showLayerCallback"></param>
/// <param name="modifyLayer"></param>
/// <returns></returns>
public System.Drawing.Bitmap Render(Stream s, out IList<IPsdLayer> layers, RenderLayerDelegate showLayerCallback, ModifyLayerDelegate modifyLayer)
{
// Create the resultBitmap object which contains merged bitmap,
// and the currentBitmap object which contains current bitmap during iteration.
// These object enable you to operate with layers.
Aurigma.GraphicsMill.Bitmap resultBitmap = new Aurigma.GraphicsMill.Bitmap();
using (Aurigma.GraphicsMill.Bitmap currentBitmap = new Aurigma.GraphicsMill.Bitmap())
{
// Create advanced PSD reader object to read .psd files.
using (Aurigma.GraphicsMill.Codecs.AdvancedPsdReader psdReader = new Aurigma.GraphicsMill.Codecs.AdvancedPsdReader(s))
{
// Load the background layer which you will put other layers on.
// Remember that the layer on zero position should be skiped
// because it contains merged bitmap.
Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame frame;
using (frame = (Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame)psdReader.LoadFrame(1))
{
frame.GetBitmap(resultBitmap);
}
//List of layers
layers = new List<IPsdLayer>();
//This code merges the rest layers with the background layer one by one.
for (int i = 2; i < psdReader.FrameCount; i++)
{
using (frame = (Aurigma.GraphicsMill.Codecs.AdvancedPsdFrame)psdReader.LoadFrame(i))
{
// Do not forget to verify the unknown layer type.
if (frame.Type != Aurigma.GraphicsMill.Codecs.PsdFrameType.Unknown)
{
//Add layers
layers.Add(new PsdLayer(frame, i + 1));
bool showFrame = showLayerCallback(i - 1, frame.Name, frame.Visible); //Subtract 1 from index so layer 0 is the background layer
if (showFrame)
{
// Extract the current image from the layer.
frame.GetBitmap(currentBitmap);
// Draw current layer on the result bitmap.
// Also check out if the layer is visible or not.
// If the layer is invisible we skip it.
currentBitmap.Draw(currentBitmap, frame.Left, frame.Top, frame.Width, frame.Height, Aurigma.GraphicsMill.Transforms.CombineMode.Alpha, 1, Aurigma.GraphicsMill.Transforms.InterpolationMode.HighQuality);
}
}
}
}
}
}
return resultBitmap.ToGdiplusBitmapDirectly();
}
public Aurigma.GraphicsMill.Bitmap RenderWorkspace(float renderingResolution)
{
if (renderingResolution < VObject.Eps)
{
throw new System.ArgumentOutOfRangeException("renderingResolution", StringResources.GetString("ExStrValueShouldBeAboveZero"));
}
float workspaceWidth, workspaceHeight;
Aurigma.GraphicsMill.Unit prevUnit = _hostViewer.Unit;
_hostViewer.Unit = Aurigma.GraphicsMill.Unit.Point;
try
{
workspaceWidth = _hostViewer.WorkspaceWidth;
workspaceHeight = _hostViewer.WorkspaceHeight;
}
finally
{
_hostViewer.Unit = prevUnit;
}
System.Drawing.Rectangle controlRectangle = CoordinateMapper.WorkspaceToControl(new System.Drawing.RectangleF(0, 0, workspaceWidth, workspaceHeight), 1.0f, System.Drawing.Point.Empty, Aurigma.GraphicsMill.Unit.Point, renderingResolution);
controlRectangle.Width = System.Math.Max(1, controlRectangle.Width);
controlRectangle.Height = System.Math.Max(1, controlRectangle.Height);
Aurigma.GraphicsMill.Bitmap result = new Aurigma.GraphicsMill.Bitmap(controlRectangle.Width, controlRectangle.Height, Aurigma.GraphicsMill.PixelFormat.Format32bppArgb, Aurigma.GraphicsMill.RgbColor.Transparent);
try
{
using (var g = result.GetGdiPlusGraphics())
{
CoordinateMapper coordMapper = new CoordinateMapper();
coordMapper.Resolution = renderingResolution;
coordMapper.Zoom = 1.0f;
coordMapper.Viewport = controlRectangle;
_alwaysUseGdiPlus = true;
DrawContent(g, controlRectangle, coordMapper);
_alwaysUseGdiPlus = false;
}
}
catch
{
if (result != null)
{
result.Dispose();
}
throw;
}
result.DpiX = renderingResolution;
result.DpiY = renderingResolution;
return(result);
}
private static Aurigma.GraphicsMill.Bitmap ExtractExifThumbnail(Aurigma.GraphicsMill.Codecs.ImageReader reader, int width, int height)
{
Aurigma.GraphicsMill.Codecs.ExifDictionary exif = null;
Aurigma.GraphicsMill.Bitmap result = null;
try
{
Aurigma.GraphicsMill.Codecs.JpegReader jpgReader = reader as Aurigma.GraphicsMill.Codecs.JpegReader;
if (jpgReader != null)
{
exif = jpgReader.Exif;
}
else
{
Aurigma.GraphicsMill.Codecs.TiffReader tiffReader = reader as Aurigma.GraphicsMill.Codecs.TiffReader;
if (tiffReader != null)
{
exif = tiffReader.Exif;
}
else
{
Aurigma.GraphicsMill.Codecs.Psd.PsdReader psdReader = reader as Aurigma.GraphicsMill.Codecs.Psd.PsdReader;
if (psdReader != null)
{
exif = psdReader.Exif;
}
}
}
if (exif != null && exif.Contains(Aurigma.GraphicsMill.Codecs.ExifDictionary.Thumbnail))
{
Aurigma.GraphicsMill.Bitmap exifThumbnail = (Aurigma.GraphicsMill.Bitmap)exif[Aurigma.GraphicsMill.Codecs.ExifDictionary.Thumbnail];
if (exifThumbnail.Width >= width || exifThumbnail.Height >= height)
{
exifThumbnail.Transforms.Resize(width, height, Transforms.ResizeInterpolationMode.High, Aurigma.GraphicsMill.Transforms.ResizeMode.Shrink);
result = exifThumbnail;
}
else
{
exifThumbnail.Dispose();
}
}
}
catch
{
if (exif != null)
{
exif.Dispose();
}
exif = null;
result = null;
}
return(result);
}
private Aurigma.GraphicsMill.Bitmap CreatePreviewBitmap(Aurigma.GraphicsMill.Bitmap sourceBitmap, Aurigma.GraphicsMill.Transforms.ResizeMode resizeMode)
{
var bitmap = new Aurigma.GraphicsMill.Bitmap();
using (var resize = new Aurigma.GraphicsMill.Transforms.Resize(new System.Drawing.Size((int)_frame.ImageSize.Width, (int)_frame.ImageSize.Height)))
{
resize.ResizeMode = resizeMode;
resize.ApplyTransform(sourceBitmap, bitmap);
}
return(bitmap);
}
/// <summary>
/// Method generates actual image for specified viewport.
/// </summary>
private void BuildUpViewportImage(Aurigma.GraphicsMill.Bitmap canvas, float zoom, System.Drawing.Rectangle viewport, System.Drawing.Rectangle invalidatedRect)
{
if (canvas.Width != viewport.Width || canvas.Height != viewport.Height)
{
throw new System.ArgumentException(StringResources.GetString("ExStrCanvasAndViewportDimsShouldBeEqual"));
}
// We should take into account 2 issues here
// 1) Shift or resize of the viewport.
// 2) Invalidated areas.
//
// Note: Current implementation may draw twice invalidatedRect in some case. Taking this case
// into account would cause code complication. I think that it is a rather rare case, because invalidatedRect
// is usually empty during scrolling. On the other hand, it is not empty during
// object editing, but in such case viewportOrigin is not changed. In both of these most regular cases
// invalidatedRect will be drawn once.
// Drawing actual cached region of the viewportOrigin.
System.Drawing.Rectangle cachedRegion = _viewportCache.GetActualRegion(zoom, viewport);
System.Drawing.Rectangle[] cachedActualRegions = VObjectsUtils.SubstractRectangle(cachedRegion, invalidatedRect);
for (int i = 0; i < cachedActualRegions.Length; i++)
{
if (cachedActualRegions[i].Width < 1 || cachedActualRegions[i].Height < 1)
{
continue;
}
using (var canvasGdiGraphics = canvas.GetGraphics())
{
_viewportCache.DrawCached(canvasGdiGraphics, zoom, viewport, cachedActualRegions[i]);
}
}
// Drawing non-cached parts of the viewportOrigin image.
invalidatedRect.Intersect(viewport);
if (invalidatedRect.Width > 0 && invalidatedRect.Height > 0)
{
DrawNoncachedArea(canvas, zoom, viewport, invalidatedRect);
}
System.Drawing.Rectangle[] newRegions = VObjectsUtils.SubstractRectangle(viewport, cachedRegion);
for (int i = 0; i < newRegions.Length; i++)
{
newRegions[i].Intersect(viewport);
if (newRegions[i].Width < 1 || newRegions[i].Height < 1)
{
continue;
}
DrawNoncachedArea(canvas, zoom, viewport, newRegions[i]);
}
}
protected override void DrawNoncachedArea(Aurigma.GraphicsMill.Bitmap canvas, float zoom, System.Drawing.Rectangle viewport, System.Drawing.Rectangle renderingRegion)
{
if (_renderBackground)
{
DrawViewportBackground(canvas, viewport, renderingRegion);
}
for (int i = 0; i < _childRenderers.Length; i++)
{
_childRenderers[i].Render(canvas, zoom, viewport, renderingRegion);
}
}
protected override TaskOutput Execute(TaskInput input, ITaskContext context)
{
foreach (var file in input.Files)
{
Rectangle cropRectangle;
bool cropped = false;
if (TryGetCropRectangle(file, out cropRectangle))
{
try
{
using (var readStream = new FileStream(file.Path, FileMode.Open))
{
using (var reader = FormatManager.CreateFormatReader(readStream))
{
using (var frame = reader.LoadFrame(0))
{
if ((cropRectangle.X > 0 || cropRectangle.Y > 0) && (cropRectangle.Width < frame.Width || cropRectangle.Height < frame.Height))
{
using (var resultBitmap = new Bitmap(frame.Width, frame.Height, Aurigma.GraphicsMill.PixelFormat.Format32bppArgb))
{
frame.GetBitmap(resultBitmap);
resultBitmap.Transforms.Crop(cropRectangle);
if (reader.MediaFormat == FormatManager.JpegFormat)
{
resultBitmap.Save(file.Path + ".tmp", new JpegEncoderOptions(95, false));
}
else
{
resultBitmap.Save(file.Path + ".tmp", FormatManager.CreateEncoderOptions(reader.MediaFormat));
}
}
cropped = true;
}
}
}
}
if (cropped)
{
File.Delete(file.Path);
File.Move(file.Path + ".tmp", file.Path);
}
}
catch (Exception ex)
{
Logger.ErrorException(string.Format("Error acquired while cropping file {0}", file.Path), ex);
}
}
}
return(new TaskOutput(input.Files, input.Params));
}
private string LoadImage(PictureBox imgPictureBox, TextBox txtCyanX, TextBox txtCyanY, TextBox txtMagentaX, TextBox txtMagentaY, TextBox txtYellowX, TextBox txtYellowY, TextBox txtBlackX, TextBox txtBlackY)
{
OpenFileDialog open = new OpenFileDialog();
if (open.ShowDialog() == DialogResult.OK)
{
Bitmap bmp = new Bitmap(open.FileName);
imgPictureBox.Image = bmp;
Aurigma.GraphicsMill.Bitmap bitmap = new Aurigma.GraphicsMill.Bitmap(open.FileName);
Bitmap cyanBitmap = (Bitmap)bitmap.Channels[Aurigma.GraphicsMill.Channel.Cyan];
Bitmap MagentaBitmap = (Bitmap)bitmap.Channels[Aurigma.GraphicsMill.Channel.Magenta];
Bitmap yellowBitmap = (Bitmap)bitmap.Channels[Aurigma.GraphicsMill.Channel.Yellow];
Bitmap blackBitmap = (Bitmap)bitmap.Channels[Aurigma.GraphicsMill.Channel.Black];
int cyanXPosition = GetLenghtToTheFirstLine(cyanBitmap);
int cyanYPosition = GetHeightToTheFirstLine(cyanBitmap);
int magentaXPosition = GetLenghtToTheFirstLine(MagentaBitmap);
int magentaYPosition = GetHeightToTheFirstLine(MagentaBitmap);
int yellowXPosition = GetLenghtToTheFirstLine(yellowBitmap);
int yellowYPosition = GetHeightToTheFirstLine(yellowBitmap);
int blackXPosition = GetLenghtToTheFirstLine(blackBitmap);
int blackYPosition = GetHeightToTheFirstLine(blackBitmap);
int magentaErrorX = cyanXPosition - magentaXPosition;
int magentaErrorY = cyanYPosition - magentaYPosition;
int yellowErrorX = cyanXPosition - yellowXPosition;
int yellowErrorY = cyanYPosition - yellowYPosition;
int blackErrorX = cyanXPosition - blackXPosition;
int blackErrorY = cyanYPosition - blackYPosition;
txtCyanX.Text = cyanXPosition.ToString();
txtCyanY.Text = cyanYPosition.ToString();
txtMagentaX.Text = magentaErrorX.ToString();
txtMagentaY.Text = magentaErrorY.ToString();
txtYellowX.Text = yellowErrorX.ToString();
txtYellowY.Text = yellowErrorY.ToString();
txtBlackX.Text = blackErrorX.ToString();
txtBlackY.Text = blackErrorY.ToString();
}
return("");
}
internal static Aurigma.GraphicsMill.Bitmap ConvertToNonextendedRgb(Aurigma.GraphicsMill.Bitmap image)
{
if (image.PixelFormat.ColorSpace == Aurigma.GraphicsMill.ColorSpace.Rgb && !image.PixelFormat.IsExtended)
{
return(image);
}
Aurigma.GraphicsMill.Transforms.ColorConverter converter = new Aurigma.GraphicsMill.Transforms.ColorConverter();
Aurigma.GraphicsMill.Bitmap resultImage = new Aurigma.GraphicsMill.Bitmap();
converter.DestinationPixelFormat = image.HasAlpha ? Aurigma.GraphicsMill.PixelFormat.Format32bppArgb : Aurigma.GraphicsMill.PixelFormat.Format24bppRgb;
resultImage = converter.Apply(image);
return(resultImage);
}
public ImageRubberband(Aurigma.GraphicsMill.Bitmap image)
{
if (image == null)
{
throw (new ArgumentNullException("image"));
}
_image = image;
this.GripSize = 8;
this.MaskStyle = Aurigma.GraphicsMill.WinControls.MaskStyle.None;
this.ResizeMode = Aurigma.GraphicsMill.WinControls.ResizeMode.Proportional;
this.Ratio = System.Convert.ToDouble(_image.Width) / System.Convert.ToDouble(_image.Height);
this.Erasable = false;
}
/// <summary>
/// Saves a copy of the specified image in the cache.
/// </summary>
/// <param name="image">New actual image of the viewport.</param>
/// <param name="zoom">Current zoom value.</param>
/// <param name="viewport">Viewport position and coordinates.</param>
public void UpdateCache(Aurigma.GraphicsMill.Bitmap image, float zoom, System.Drawing.Rectangle viewport)
{
if (image == null)
{
throw new System.ArgumentNullException("image");
}
if (viewport.Width != image.Width || viewport.Height != image.Height)
{
throw new System.ArgumentException(StringResources.GetString("ExStrImageAndViewportDimsShouldBeEqual"), "image");
}
_zoom = zoom;
_viewport = viewport;
_image = new Aurigma.GraphicsMill.Bitmap(image);
}
private void DrawViewportBackground(Aurigma.GraphicsMill.Bitmap canvas, System.Drawing.Rectangle viewport, System.Drawing.Rectangle renderingRegion)
{
using (Aurigma.GraphicsMill.Drawing.Graphics g = canvas.GetGraphics())
{
System.Drawing.Rectangle screenRect = renderingRegion;
screenRect.X -= viewport.X;
screenRect.Y -= viewport.Y;
if (_workspaceBackgroundStyle == Aurigma.GraphicsMill.WinControls.WorkspaceBackgroundStyle.Grid)
{
int gridPatternSize = 2 * bgGridCellSize;
int patternOffsetX = renderingRegion.X % gridPatternSize,
patternOffsetY = renderingRegion.Y % gridPatternSize;
CreateBackgroundGridTemplate(renderingRegion.Width + gridPatternSize);
System.Drawing.Rectangle srcRect = new System.Drawing.Rectangle(0, 0, _bgGridTemplate.Width, _bgGridTemplate.Height),
dstRect = new System.Drawing.Rectangle(renderingRegion.Location, srcRect.Size);
dstRect.Offset(-viewport.X, -viewport.Y);
dstRect.Offset(-patternOffsetX, -patternOffsetY);
g.SetClip(new System.Drawing.Rectangle(renderingRegion.X - viewport.X, renderingRegion.Y - viewport.Y, renderingRegion.Width, renderingRegion.Height));
try
{
int templateRepeats = (int)System.Math.Ceiling((float)(renderingRegion.Height + patternOffsetY) / _bgGridTemplate.Height);
for (int j = 0; j < templateRepeats; j++)
{
g.DrawImage(_bgGridTemplate, dstRect, /*srcRect,*/ Aurigma.GraphicsMill.Transforms.CombineMode.Copy, 1.0f, Aurigma.GraphicsMill.Transforms.ResizeInterpolationMode.NearestNeighbour);
dstRect.Offset(0, _bgGridTemplate.Height);
}
}
finally
{
g.ResetClip();
}
}
else if (_workspaceBackgroundStyle == Aurigma.GraphicsMill.WinControls.WorkspaceBackgroundStyle.Solid)
{
g.FillRectangle(new Aurigma.GraphicsMill.Drawing.SolidBrush(_workspaceBackColor1), screenRect);
}
else
{
g.FillRectangle(new Aurigma.GraphicsMill.Drawing.SolidBrush(_backColor), screenRect);
}
}
}
public override void Dispose()
{
try
{
if (_bgGridTemplate != null)
{
_bgGridTemplate.Dispose();
_bgGridTemplate = null;
}
DisposeLayerRenders();
}
finally
{
base.Dispose();
}
}
public Aurigma.GraphicsMill.Bitmap RenderRegion(string regionName, float dpi)
{
Layer renderedLayer = null;
List <Layer> hiddenLayers = new List <Layer>(_canvasViewer.Canvas.Layers.Count);
foreach (Layer l in _canvasViewer.Canvas.Layers)
{
if (l.Name == regionName)
{
renderedLayer = l;
}
else if (l.Visible)
{
l.Visible = false;
hiddenLayers.Add(l);
}
}
if (renderedLayer == null)
{
//TODO: throw exception
}
// Temporary remove region from rendered layer.
RectangleRegion rr = renderedLayer.Region;
renderedLayer.Region = null;
//render canvas
Aurigma.GraphicsMill.Bitmap bp = _canvasViewer.Canvas.RenderWorkspace(dpi, Aurigma.GraphicsMill.ColorSpace.Rgb);
// Restore region back.
renderedLayer.Region = rr;
//crop region
Rectangle r = new Rectangle(Common.ConvertPointsToPixels(dpi, renderedLayer.Region.Left),
Common.ConvertPointsToPixels(dpi, renderedLayer.Region.Top),
Common.ConvertPointsToPixels(dpi, renderedLayer.Region.Width),
Common.ConvertPointsToPixels(dpi, renderedLayer.Region.Height));
bp.Transforms.Crop(r);
//revert hidden layers
hiddenLayers.ForEach(delegate(Layer l) { l.Visible = true; });
return(bp);
}
public static Aurigma.GraphicsMill.Bitmap GreyscaleAndThreshold(Aurigma.GraphicsMill.Bitmap inputBitmap)
{
//Apply the Auto-level
inputBitmap.ColorAdjustment.AutoLevels(0.001f);
// apply the greyscale filter
Grayscale filter = new Grayscale(0.2125, 0.7154, 0.0721);
System.Drawing.Bitmap trueBWBitmap = filter.Apply((System.Drawing.Bitmap)inputBitmap);
//Apply the threshold filter
Threshold thresh = new Threshold(128);
thresh.ApplyInPlace(trueBWBitmap);
//Send it on back
return((Aurigma.GraphicsMill.Bitmap)trueBWBitmap);
}
private void ApplyCorrectionsToThumbnail()
{
using (var bmp = new Aurigma.GraphicsMill.Bitmap(_filePath))
{
int preHeight = bmp.Height;
int preWidth = bmp.Width;
if (preHeight > preWidth)
{
bmp.Transforms.Resize(0, 200, ResizeInterpolationMode.High);
}
else
{
bmp.Transforms.Resize(200, 0, ResizeInterpolationMode.High);
}
int thisHeight = bmp.Height;
int thisWidth = bmp.Width;
Aurigma.GraphicsMill.Bitmap adjBmp = Processor.ProcessBitmap(bmp, thumbCorrection, thisWidth, thisHeight);
imageBox.Image = (Image)adjBmp;
}
}
