The NOV framework provides two classes for in-memory representation of raster images:

• NImageData – stores the image data in encoded form. This class can be used for obtaining the image format and decoding the image.
• NRaster – represents a decoded image. The image’s pixel data in stored in uncompressed form, which makes possible the reading and writing of individual pixels.

Following are more detailed reviews of the capabilities of these types.

An instance of the NImageData type can be created by specifying a byte array that contains the image data. In the following example the data is obtained from a local file:

NFile file = NFileSystem.GetFile(@"D:\TestImage.png");
file.ReadAllBytes(
    delegate (byte[] imageBytes)
    {
        NImageData imageData = new NImageData(imageBytes);
    },
    delegate (Exception ex)
    {
        // Reading of the file failed
    }
);

To decode the encoded image you have to use the NImageData.Decode method. This creates a new NRaster object:

NRaster raster = imageData.Decode();

The NImageData object can also be used for obtaining the encoding format of the image:

NImageFormat imageFormat = imageData.ImageFormat;

When the image format for a particular NImageData instance is acquired for the first time, it is stored in the instance, so subsequent calls to the ImageFormat property do not need to perform format recognition again.

Decoded raster images are represented by the NRaster type. An NRaster instance keeps image information (width, height, pixel format, etc.) and an array in which the pixels are stored in uncompressed form (in one of the supported pixel formats). This representation allows for various image processing features, some of which are listed below:

• Reading and modification of the pixels of an existing image.
• Programmatic generation of an image.
• Image encoding (into the supported image formats).
• Rasterization of vector paintings.
• Pixel format conversions.
• Color conversions (like grayscale, invert colors).
• Transforms like image flipping and rotation.

There are different ways to create an NRaster object, depending on the purpose and the initial information. As mentioned previously, an NRaster instance can be produced by the NImageData.Decode method. It is also possible to create an NRaster object directly, using one of several constructors. For example, the following code creates a new image with certain dimensions and pixel format:

NRaster raster = new NRaster(200, 160, NPixelFormat.ARGB32);

The first two parameters are the image’s width and height specified in pixels. The pixel format is set to ARGB32 – this denotes a 32 bpp format with 4 channels (Alpha, Red, Green and Blue, 8-bits per channel).

To create a raster from an exsisting image you can also use the CreateRaster and the TryCreateRaster methods of the image's image source. The difference between the two methods is that CreateRaster throws and exception if a raster couldn't be created, but the TryCreateRaster doesn't throw an exception in this case and returns null instead. The following piece of code demonstrates how to create a raster from an image:

NRaster raster = image.ImageSource.CreateRaster();

You can also create an NRaster object from an existing image by using the NImageData.Decode method:

byte[] imageBytes = File.ReadAllBytes(@"D:\Gradient.png");
NImageData imageData = new NImageData(imageBytes);
NRaster raster = imageData.Decode();

for (int j = 0; j < 160; j++)
{
    for (int i = 0; i < 200; i++)
    {
        float red = i / 200.0f;
        float blue = j / 160.0f;
        raster.SetPixel(i, j, NColor.FromRGBA(red, 0.0f, blue, 1.0f));
    }
}

The following code encodes the raster into PNG format and saves it to a local file:

NImage image = new NImage(raster);
image.Save(@"D:\Gradient.png", NImageFormat.Png);

The resulting image “Gradient.png” is presented below:

To create an NRaster object from an existing image, you can use the NImageData.Decode method. The following code reads the “Gradient.png” image (the one created in the previous example), decodes it to a raster and inverts its colors pixel by pixel:

byte[] imageBytes = NFile.ReadAllBytes(@"D:\Gradient.png");
NImageData imageData = new NImageData(imageBytes);
NRaster raster = imageData.Decode();
for (int j = 0; j < raster.Height; j++)
{
    for (int i = 0; i < raster.Width; i++)
    {
        NColor color = raster.GetPixel(i, j);
        raster.SetPixel(i, j, color.Invert());
    }
}

NRaster provides built-in methods for some common operations like the color inversion demonstrated above. Instead of the double for loop in the previous example you can simply use:

raster.InvertColors();

Using similar methods you can easily clear a raster, convert its pixels to grayscale, fill a part of it with a certain color, flip it horizontally or vertically, rotate it etc.

Certain situations require that a raster is represented in a specific pixel format. It is not possible to change the pixel format of an existing NRaster, but you create a new raster with the desired pixel format and convert the pixel data from the original one. This is a built-in functionality implemented by the Convert function:

NRaster rasterBGR24 = raster.Convert(NPixelFormat.BGR24, true);

An important feature of NRaster is the ability to rasterize custom painted vector graphics. The RasterizePainting method creates a new raster and paints a vector scene inside it. The scene should be described in a paint method like the one below:

void PaintMethod(NPaintVisitor visitor)
{
    visitor.SetFill(NColor.SlateBlue);
    visitor.PaintRectangle(0, 0, 300, 200);

    visitor.SetFill(NColor.Thistle);
    visitor.PaintEllipse(0, 0, 300, 200);

    visitor.SetStroke(NColor.Crimson, 2);
    visitor.ClearFill();
    visitor.PaintEllipse(30, 28, 50, 50);
}

The PaintMethod is passed as a parameter to the RasterizePainting method, along with the size and the resolution of the new raster:

NRaster raster = NRaster.RasterizePainting(300, 200, 96, PaintMethod);

The generated raster is displayed below:

The NRaster class also provides some other useful methods, the most notable of them being:

• Resize - creates a new raster from the original one and resizes it to a given size.
• CreateSubRaster - creates a new raster as a portion of the original one.
• FlipX, FlipY - creates a new raster by flipping the original one horizontally of vertically.
• RotateClockwise, RotateCounterClockwise - creates a new raster by rotating the original one.

Nevron Open Vision provides an easy way to encode rasters to a raster image format, so that you can easily save them as an image file. To do this, you should create an image from the raster and use the Save method of NImage. You can pass an encoder settings object to the Save method, which defines format specific settings to apply when encoding the raster, for example, the image quality of a JPEG image, the compression level and the color type (grayscale, true color, true color with alpha, palette, etc.) of a PNG image and so on.

The following example demonstrates how to create a simple raster, how to draw a red line at its forward diagonal and a blue one at its backward diagonal and how to save the result to a PNG file on disk:

// Create a raster
NRaster raster = new NRaster(16, 16, NPixelFormat.ARGB32);
for (int i = 0; i < raster.Width; i++)
{
    raster.SetPixel(i, i, NColor.Red);
    raster.SetPixel(raster.Width - i - 1, i, NColor.Blue);
}

// Save the raster to a file
NImage image = new NImage(raster);
image.Save(NFileSystem.GetFile(@"D:\test.png"), NImageFormat.Png);

NRaster provides the Encode method for encoding of the image data into a specific image format. This method is used internall by the Save method of NImage to encode the raster. In the example above we used PNG format with default encoder settings. If you need to use specific encoder settings you can pass a settings object to the Save method of the image. Image formats that support encoder settings have corresponding types that are derived from NImageEncoderSettings. The following table shows these relations:

Encoding a PNG image with transparency is a common scenario that requires the usage of custom encoder settings. The default color type for the PNG encoder is ENPngColorType.Truecolor, which does not support an alpha channel. To encode a semi-transparent PNG, you have to create an NPngEncoderSettings object and set its ColorType property to ENPngColorType.TruecolorWithAlpha:

NPngEncoderSettings settings = new NPngEncoderSettings();
settings.ColorType = ENPngColorType.TruecolorWithAlpha;
NImageData imgData = raster.Encode(NImageFormat.Png, settings);

NPngEncoderSettings settings = new NPngEncoderSettings();
settings.ColorType = ENPngColorType.TruecolorWithAlpha;

NImage image = new NImage(raster);
image.Save(NFileSyste.GetFile(@"D:\test.png"), NImageFormat.Png, settings, NImageFormat.Png.EncoderPreference);