The Graphics Mill core class library contains the classes that implement all of Aurigma's 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 viewing the Standard vs. Pro editions comparison chart.
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, AVI videos (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;
- With Media Processor Add-on it is possible to get thumbnails for any video formats that are supported on a computer (all necessary codecs are installed).
NoteIn Pro edition the PSD format has an extended support: you can read individual raster and text layers
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. This 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. This allows you to extract thumbnails from files even faster than the on-the-fly technique described above.
Another great feature is the ability 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 the 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 the bitmap memory footprint and increasing the performance.
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 capture, 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 metadata.
Adobe Image Resource Blocks (also known as 8BIM resources) are represented by a binary buffer which contains meta-data information intended specifically for the Adobe products family. For example, 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 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.
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 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 makes the process easy. 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 resolves both of them superbly.
With Graphics Mill 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 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 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).
NoteRed-eye effect removal functionality (including unique semiautomatic mode) is now included in both Pro and Standard editions of Graphics Mill.
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. By analyzing the histogram you can estimate whether the image is too bright, too dark, or low contrast.
If standard imaging algorithms implemented in Graphics Mill are not enough for you, you can create your own effects. It becomes easy because Graphics Mill provides low level access to pixel data.
Unique Multithreading Support
Graphics Mill is designed to reduce your efforts when creating a multithreaded user interface. It takes most multithreading-related details upon itself, so you don't have to spend your time 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;
- Ability to run all the operations in asynchronous mode;
- Ability 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 provides powerful drawing features.
- Close integration with GDI+. You can draw high quality graphics within 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 you 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 are drawn (rotate, scale, shear);
- Set clipping region when drawing something;
Managed + Unmanaged Code
Imaging software can't be 100% managed. If it were, there would be 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 a mix 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 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 code without any platform interoperability, it has higher performance.
Another great feature of the unmanaged code in Graphics Mill is the ability to use Assembler. Most speed-critical portions of code are written in Assembler with MMX optimization. It enables Graphics Mill to be much faster than other imaging toolkits which do not use such kind of optimization.
Add-ons
Graphics Mill 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 can read/write AVI files, work with audio tracks, put watermarks onto it, add transition effects, etc.
- Media Processor Add-on - allows you 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 you 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.
- 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 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 your applications, we have prepared feature highlights for the following fields: