The Graphics Mill core class library contains classes implementing all imaging functionality (loading/saving images, applying effects, transforming, drawing, etc). Below is the overview of its features. Please notice that all the features listed here are found only in the Pro edition. To avoid misunderstanding, we recommend seeing the Standard vs. Pro editions comparison chart.

• Load and Save Images
• Image Metadata Manipulation
• Advanced On-the-Fly Thumbnailing
• Natural Pixel Formats Are Preserved
• Advanced Color Management
• Color Reduction
• Imaging Operations
• Unique Multithreading Support
• Drawing
• Managed and Unmanaged Code
• Add-ons

The Graphics Mill core class library contains classes implementing all imaging functionality (loading/saving images, applying effects, transforms, drawing, etc).

Load and Save Images

Graphics Mill supports the following file formats:

• JPEG, PNG, GIF, WBMP, TIFF, BMP, JPEG2000 (both read and write). Can read and write multipage TIFF and animated GIF files;
• PCX, PSD (read only);
• PDF, SWF (write only). Can write animated SWF files and multipage PDF files;

Images can be loaded not only from files, but also from sources. This way you can load images from databases, memory, URL, etc.

The essential feature of Graphics Mill™ is the possibility to extract thumbnails in a fast and memory-friendly way. It is achieved by generating thumbnails on-the-fly, while the file is read. For example if you are generating a 100x100 thumbnail from a 4000x4000 image, Graphics Mill™ allows you to avoid occupying 64 megabytes (as would happen if you first loaded the image, then resized it). It can create a thumbnail while reading the image from the file, so you will never commit extra memory.

Alternatively, you can load (as well as save) not pixels, but EXIF and IPTC metadata from files. In particular, this allows to extract thumbnails from files even faster than on-the-fly technique described above.

One more great feature is the possibility to process uncompressed JPEG files. In particular, you can:

• Rotate and Flip without loss.
• Recompress only a part of a JPEG file. E.g. if you put a watermark on the image, you can recompress only the part of the JPEG file which was changed and leave the rest intact.
• Edit EXIF and IPTC metadata without JPEG recompression.

On-the-fly Thumbnailing

To make a thumbnail, imaging APIs often load entire source image into memory and then resize the image. Graphics Mill™ implements a different approach: thumbnails are created on-the-fly (i.e. in the course of reading the source image), thereby greatly decreasing bitmap memory footprint and increasing the performance.

Image Metadata Manipulation

Graphics Mill for .NET enables you to extract and modify EXIF, IPTC, XMP and Adobe Image Resource Blocks metadata from files.

EXIF data contains information provided by the digital camera, including camera settings, date of capturing, and sometimes even GPS details. You can use EXIF data for different tasks: use some fields to post-process the photo (e.g. automatically rotate the image by analyzing the orientation of the camera during capturing), organize photos in a gallery by capture date, etc.

IPTC is commonly used in journalistic industry to keep information about image author, subject, location, etc. So you can use it for cataloging your photos. XMP is used by Adobe Photoshop to store various metainformation.

Adobe Image Resource Blocks (also known as 8BIM resources) are represented by binary buffer which contains meta-data information intended specifically for the Adobe products family. For example, there you can find color management settings, clipping path, background color, etc. specified in the Photoshop properties. This meta-information is saved along with PSD, JPEG and TIFF files.

Graphics Mill 4.5 for .NET lets you iterate through all Adobe Image Resource Blocks and perform the needed operations. For example, you can get Adobe Image Resources from one file, make some modifications (for example, remove thumbnail saved in Adobe Resources by Photoshop) and save it along with another image file.

Natural Pixel Formats

Graphics Mill™ allows you to load and save images in their natural pixel formats: 1, 4, 8, 16, 24, 32, 40, 48, 64, 80 bits per pixel. So if you load a 1-bit image, it won't be converted to a 32-bit image ( thus occupying 32 times more memory);

Most effects can be applied directly to RGB, Grayscale and CMYK image without any conversion. It not only prevents wasting of extra resources, but preserves the image from degradation.

Another important feature of Graphics Mill for .NET™ is that it supports extended pixel formats, i.e. 16 bits per channel.

Advanced Color Management

To be sure that the hardcopy image will have the same colors as the image file, you need to apply color management. Graphics Mill for .NET™ allows to do it as easily as possible. The following features are available:

• Loading and saving embedded ICC profiles in files;
• Conversion between color spaces (RGB, CMYK and Grayscale) based on ICC profiles;
• Conversion of not only bitmaps, but also individual colors;
• Display of image on screen using a device profile. Possibility to use two profiles together (to see on the current device what the image will look like on the target device);
• Specifying rendering intent and possibility to use black point compensation algorithm to preserve image contrast after conversion;
• Extraction of the color profile information;

Color Reduction

Color reduction is a process of converting TrueColor images into the images with 2-256 colors (i.e. indexed images). It consists of two subtasks - palette generation and the conversion itself. Graphics Mill for .NET™ excellently resolves both of them.

With Graphics Mill for .NET™ you can:

• Generate adaptive palette using Octree algorithm;
• Use one of predefined palettes:
  • Windows;
  • Macintosh;
  • Web Safe;
  • Adaptive;
• Use custom palette;

When the conversion starts, a special technique called dithering is used to reduce halftone "washing out". Graphics Mill for .NET™ supports the following dithering modes:

• Error Diffusion (8 algorithms - Floyd Steinberg, Fan, Jarvis, Original, Stucki, Sierra, Burkes, and Stephenson);
• Ordered Dithering (2 algorithms - Bayers and spiral);
• White Noise;

Imaging Operations

Graphics Mill for .NET™ allows you to apply different imaging operations. You can apply geometry transforms:

• Resize (12 interpolation algorithms, including Scale-To-Gray for 1-bit images displaying, and Scale-To-Color for color indexed bitmaps);
• Rotate (precise rotation on small angle, antialising, fast rotation on 90, 180 and 270 degrees);
• Arbitrary affine and projective transforms (e.g. skew, perspective, etc.);
• Crop;
• Flip;
• Swirl;
• Wave;
• WaterDrop;
• Cylindrize;

You can also apply tone and color adjustment algorithms:

• Hue/Saturation/Lightness correction;
• Brightness correction (both automatic and manual);
• Contrast correction (both automatic and manual);
• Levels tone correction (both automatic and manual);
• Curves tone correction;
• Custom LUT;
• Histogram equalization;
• Channel balance;
• Desaturation;

Use different filters:

• Blur (Gaussian blur and fast implementation);
• Edge Detect;
• Maximum Filter (also known as Erosion);
• Median Filter;
• Minimum Filter (also know as Dilation);
• Sharpen;
• Unsharp Mask;

Apply artistic effects:

• Waddle;
• Add Noise (with uniform and Gaussian distribution);
• Buttonize (with 3 diffrent button types);
• Emboss;
• Glow;
• Mosaic;
• Page Curl;
• Shadow;
• Solarize;
• Invert;
• Spray;
• Texturize (neighbour images are connected seamlessly).

You can apply effects and color/tone adjustments to a part of the image using a rectangle or a raster mask.

You can also combine images with full support of alpha channel and various combine modes (such as Alpha, Add, Xor, Substract, Texturize, Screen, Overlay and others - total 22 modes). Overall opacity can be specified.

To get statistics about the bitmap you can generate a histogram. Analyzing the histogram you can estimate whether the image is too bright, too dark, or has too low a contrast.

If standard imaging algorithms implemented in Graphics Mill for .NET™ are not enough for you, you can create your own effects. It becomes easy because Graphics Mill for .NET™ provides low level access to pixel data.

Unique Multithreading Support

Graphics Mill for .NET™ is designed to reduce efforts when creating multithreaded user interface. It takes most multithreading-related details upon itself, so you don't have to spend your time on investigating and implementing these details. Just concentrate on your application development.

In short, it has the following multithreading features:

• Thread safety of most Graphics Mill™ classes;
• Possibility to run all the operations in asynchronous mode;
• Possibility to abort, pause, and resume the operation execution in the asynchronous mode;
• All the multithread-oriented code is hidden from the developer - which makes it much easier to use;

Drawing

Graphics Mill for .NET™ provides powerful drawing features.

• Close integration with GDI+. You can draw high quality graphics on Aurigma.GraphicsMill.Bitmap using classes from System.Drawing namespace.
• The class which is an analogue for System.Drawing.Graphics class but which is based on GDI. This way you can provide extremely high speed of drawing without having to import Win32API functions and structures, or getting into DirectX. It allows to:
  • Draw lines, curves (bezier splines, arcs), shapes (rectangles, ellipses, polygons, pies);
  • Use various pens to outline shape (you can specify width, color, style, etc.);
  • Use various brushes to fill shapes (you can change color, specify whether brush is hatched and so on);
  • Draw text with True Type, Type1 and OpenType fonts. Text can be both single-line and multi-line with automatic words wrapping, clipping, adding ellipsis, etc;
  • Retrieve font metrics (ascent, descent, internal and external leading, etc);
  • Measure text string, get individual character position in the text, etc;
  • Draw outlined text;
  • Set affine transformation when some graphics is drawn (rotate, scale, shear);
  • Set clipping region when drawing something;

Managed + Unmanaged Code

None of the imaging software can be 100% managed. Otherwise it will have significant performance problems. That's why all the high-performance imaging components for .NET are written by mixing managed .NET code with unmanaged code written in C/C++. Most companies implement mixing of managed and unmanaged code by writing wrapper .NET classes for COM components or common Windows DLLs. However this approach has an obvious disadvantage: it is vulnerable to the so-called "DLL Hell" problem which happens when different versions of the same component are installed on the same machine.

Graphics Mill for .NET™ implements a different approach. Written in the MC++ (Managed C++), it mixes managed and unmanaged C++ code in a single assembly. It means no .NET-foreign DLLs are distributed. So you do not need to register any DLLs or put them into system folders. You can deploy your applications with a simple xcopy and never have versioning problems. Also, since unmanaged code can be called inside the managed one without any platform interoperability, it has higher performance.

Another great feature of the unmanaged code in Graphics Mill for .NET™ is the possibility to use Assembler. Most speed-critical portions of code are written in Assembler with MMX optimization. It enables Graphics Mill for .NET™ to be much faster than other imaging toolkits which do not use such kind of optimization.

Add-ons

Graphics Mill for .NET™ includes powerful add-ons - additional modules which enhance its functionality with new features. The following add-ons are included:

• AVI Processor Add-on™ - adds AVI format support. With this add-on Graphics Mill for .NET™ can read/write AVI files, work with audio tracks, put watermarks onto it, add transition effects, etc.
• Media Processor Add-on™ - allows to generate thumbnails from different kinds of video files and extract different meta-information from them.
• Advanced PSD Add-on™ - improves PSD format support. It allows to read separate layers from PSD file, get image (for raster layers) and text information (for text layers). All these layers can be merged with Graphics Mill for .NET™.
• Red-Eye Removal Add-on™ - features red-eye effect removal functionality. It implements unique semiautomatic mode which requires the user just select a red-eyed face. Also, manual mode is available.

Feature Highlights for Different Fields

Graphics Mill for .NET™ is a very versatile component and it can be used in a wide variety of applications. To help you to examine benefits of the Graphics Mill for .NET™ for your kind of applications, we have prepared features highlights for the following fields:

• Photo Imaging
• Print Imaging
• Document Imaging