GradientFloatToInt.cs

This code demonstrates how to adapt a float ImageView into a 16-bit unsigned integer ImageView. Data are converted on the fly, and the resulting image has values between 0 and 65535. Both images are displayed to show their content.

using IOLink;
using Newtonsoft.Json.Linq;
using System;
using System.Runtime.Intrinsics;
 
namespace Examples
{
    public class GradientFloatToInt
    {
 
        private static ImageView GenerateGradientWithGivenRange(Vector2f inputRange)
        {
            VectorXu64 shape = new VectorXu64(5, 30);
            // To create a float ImageView, the datatype of the
            // image can be FLOAT (32bits) or DOUBLE (64 bits)
            DataType dt = DataTypeId.FLOAT;
 
            // create an image view in CPU memory
            ImageView image = ImageViewFactory.Allocate(shape, dt);
 
            // create a buffer to write a line of data
            // this buffer is float-typed to match the image
            // datatype
            float[] lineBuffer = new float[shape[0]];
 
            VectorXu64 lineSize = new VectorXu64(shape[0], 1);
 
            // define the step between two values in the gradient
            float stepLine = ((float)inputRange[1] - (float)inputRange[0]) / shape[1];
 
            Console.WriteLine("Writing data slice by slice, line by line");
 
            // write data slice by slice, line by line with a
            // growing value
            float valueInit = (float)inputRange[0];
            float valueToSet = valueInit;
            for (ulong j = 0; j < shape[1]; ++j)
            {
                RegionXu64 lineRegion = new RegionXu64(new VectorXu64(0, j), lineSize);
 
                // fill buffer with the same value
                Array.Fill(lineBuffer, valueToSet);
 
                image.WriteRegion(lineRegion, lineBuffer);
                valueToSet = valueInit + j * stepLine;
            }
 
            Console.WriteLine("Writing completed");
 
            return image;
        }
 
        // Display the content of an ImageView containing values
        // of type T.
        private static void displayImageContent<T>(ImageView image)
        {
            VectorXu64 shape = image.Shape;
            RegionXu64 fullRegion = RegionXu64.CreateFullRegion(image.Shape);
            T[] buffer = new T[fullRegion.ElementCount];
            image.ReadRegion(fullRegion, buffer);
            Console.WriteLine("Image content: ");
            for (ulong j = 0; j < shape[1]; ++j)
            {
                for (ulong i = 0; i < shape[0]; ++i)
                {
                    Console.Write(buffer[i + j * shape[0]]);
                    Console.Write(" ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
 
        public static void Main(string[] args)
        {
            Vector2f inputRange = new Vector2f(0.0f, 5.0f);
 
            ImageView floatImage = GenerateGradientWithGivenRange(inputRange);
 
            // display ImageView content
            GradientFloatToInt.displayImageContent<float>(floatImage);
 
            // Adapt the float ImageView into a 16-bit unsigned
            // integer ImageView. Data are not duplicated, only
            // the datatype is changed. Conversion is done on the
            // fly when reading the data.
            // Range of data is mapped from [0, 5] to [0, 65535].
            ImageView IntImage = ImageViewFactory.AdaptDynamicRange(
              floatImage,
              DataTypeId.UINT16,
              new Vector2d((double)inputRange[0], (double)inputRange[1]),
              new Vector2d(0.0, 65535.0));
 
            // display ImageView content
            GradientFloatToInt.displayImageContent<UInt16>(IntImage);
 
            Console.WriteLine("SUCCESS");
        }
    }
}