Image.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.Common.Types.Geometry;
using IDSImaging.Peak.ICV.Backend;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Types;
 
public class Image : IDisposable, IHasSafeHandle
{
    private readonly uint _bufferSize;
    internal readonly Handle _handle;
    SafeHandle IHasSafeHandle.Handle => _handle;
    private Metadata? _metadata;
 
    internal Image(Handle handle)
    {
        _handle = handle;
 
        var cImageInfo = new Backend.Types.peak_icv_image_info();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_GetInfo(_handle, out cImageInfo,
                (nuint) Marshal.SizeOf(cImageInfo)));
 
        Size = new Size(cImageInfo.size.width, cImageInfo.size.height);
        PixelFormat = cImageInfo.pixelFormat;
 
        _bufferSize = (uint) cImageInfo.bufferSize;
        Data = cImageInfo.buffer;
    }
 
    public Image(IImageView imageView) : this(CreateFromImageView(imageView))
    {
        Metadata = imageView.Metadata.Clone();
    }
 
    public Image(PixelFormat pixelFormat, Size imageSize) : this(CreateFromSize(pixelFormat, imageSize))
    {
    }
 
    public Image(PixelFormat pixelFormat, Size imageSize, IntPtr buffer, uint bufferSize) : this(
        CreateFromBuffer(pixelFormat, imageSize, buffer, bufferSize))
    {
    }
 
    public Image(string filePath) : this(CreateFromFile(filePath))
    {
    }
 
    public Image(string filePath, PixelFormat pixelFormat) : this(CreateFromFile(filePath, pixelFormat))
    {
    }
 
    internal Image(Image other)
        : this(new Handle(other._handle.DangerousGetHandle()))
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_IncreaseUseCount(_handle));
 
        _metadata = other._metadata;
    }
 
    public PixelFormat PixelFormat { get; }
 
    public Size Size { get; }
 
    public uint Width => Size.Width;
 
    public uint Height => Size.Height;
 
    public IntPtr Data { get; }
 
    public long SizeInBytes => _bufferSize;
 
    public Metadata Metadata
    {
        get
        {
            if (_metadata != null)
            {
                return _metadata;
            }
 
            var cCaptureInformation = new Backend.Types.peak_icv_capture_information();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Image_GetCaptureInformation(_handle, out cCaptureInformation,
                    (nuint) Marshal.SizeOf(cCaptureInformation)));
 
            _metadata = CaptureInformation.ToMetadata(cCaptureInformation);
 
            _metadata.Changed += (_, _) =>
            {
                Backend.Types.peak_icv_capture_information cCaptureInformation =
                    CaptureInformation.FromMetadata(_metadata, Size);
                CInterface.peak_icv_Image_SetCaptureInformation(_handle, cCaptureInformation,
                    (nuint) Marshal.SizeOf(cCaptureInformation));
            };
 
            return _metadata;
        }
 
        set
        {
            Backend.Types.peak_icv_capture_information cCaptureInformation =
                CaptureInformation.FromMetadata(value, Size);
 
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Image_SetCaptureInformation(_handle, cCaptureInformation,
                    (nuint) Marshal.SizeOf(cCaptureInformation)));
 
            _metadata = value.Clone();
            CaptureInformation.MergeWithMetadata(cCaptureInformation, _metadata);
        }
    }
 
    public Region Region
    {
        get
        {
            var region = new Region();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Image_GetRegion(_handle, ref region._handle));
 
            return region;
        }
        set { DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Image_SetRegion(_handle, value._handle)); }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    public void ResetRegion()
    {
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Image_ResetRegion(_handle));
    }
 
    public Image Copy()
    {
        var image = new Image(PixelFormat, Size);
        unsafe
        {
            Buffer.MemoryCopy((void*) Data, (void*) image.Data, (int) _bufferSize, (int) _bufferSize);
        }
 
 
        image.Metadata = Metadata.Clone();
        return image;
    }
 
    public Image ConvertPixelFormat(PixelFormat pixelFormat)
    {
        var outputImage = new Image(pixelFormat, Size);
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_ConvertPixelFormat(_handle, pixelFormat,
                outputImage._handle));
        return outputImage;
    }
 
    public Image ConvertPixelFormatWithFactor(PixelFormat pixelFormat, double factor)
    {
        var outputImage = new Image(pixelFormat, Size);
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_ConvertPixelFormatWithFactor(_handle, pixelFormat, factor,
                outputImage._handle));
        return outputImage;
    }
 
    public Image Subtract(Image subtrahend)
    {
        var outputImage = new Image(PixelFormat, Size);
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_Subtract(_handle, subtrahend._handle,
                outputImage._handle));
        return outputImage;
    }
 
    public static Image operator -(Image minuend, Image subtrahend)
    {
        return minuend.Subtract(subtrahend);
    }
 
    private static Handle CreateFromSize(PixelFormat pixelFormat, Size imageSize)
    {
        var imageHandle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Image_Create(out imageHandle,
            pixelFormat, new Backend.Types.peak_common_size
                { width = imageSize.Width, height = imageSize.Height }));
 
        return imageHandle;
    }
 
    private static Handle CreateFromBuffer(PixelFormat pixelFormat, Size imageSize, IntPtr buffer, nuint bufferSize)
    {
        var imageHandle = new Handle();
 
        var imageInfo = new Backend.Types.peak_icv_image_info
        {
            pixelFormat = pixelFormat,
            size = new Backend.Types.peak_common_size { width = imageSize.Width, height = imageSize.Height },
            bufferSize = bufferSize,
            buffer = buffer
        };
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_CreateFromImageInfo(out imageHandle, imageInfo,
                (nuint) Marshal.SizeOf(imageInfo)));
 
        return imageHandle;
    }
 
    private static Handle CreateFromFile(string filePath)
    {
        var imageHandle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_CreateFromFile(out imageHandle, Utils.ToUtf8(filePath)));
 
        return imageHandle;
    }
 
    private static Handle CreateFromFile(string filePath, PixelFormat forcePixelFormat)
    {
        var imageHandle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_CreateFromFileWithPixelFormat(out imageHandle, Utils.ToUtf8(filePath),
                forcePixelFormat));
 
        return imageHandle;
    }
 
    private static Handle CreateFromImageView(IImageView imageView)
    {
        Size imageViewSize = imageView.Size;
        nuint lineStartOffset = imageView.LineStartOffset;
        var validBytesPerLine = (nuint)new PixelFormatInfo(imageView.PixelFormat)
            .GetSizeInBytes(new Size(imageViewSize.Width, 1 ));
 
        if (lineStartOffset == 0 && validBytesPerLine == imageView.BytesPerLine)
        {
            return CreateFromBuffer(imageView.PixelFormat, imageViewSize, imageView.Data, imageView.SizeInBytes);
        }
 
        Handle handle = CreateFromSize(imageView.PixelFormat, imageViewSize);
 
        try
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Buffer_CutBytes(imageView.Data, lineStartOffset, imageView.BytesPerLine,
                    validBytesPerLine, imageViewSize.Height, handle));
        }
        catch (Exception)
        {
            handle.Dispose();
            throw;
        }
 
        return handle;
    }
 
    private sealed class ImageEqualityComparer : IEqualityComparer<Image>
    {
        public bool Equals(Image x, Image y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }
 
            if (ReferenceEquals(x, null))
            {
                return false;
            }
 
            if (ReferenceEquals(y, null))
            {
                return false;
            }
 
            var isEqual = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Image_Compare(x._handle, y._handle, out isEqual));
 
            return isEqual;
        }
 
        public int GetHashCode(Image obj)
        {
            var width = obj.Size.Width;
            var height = obj.Size.Height;
 
            unsafe
            {
                var ptr = (byte*) obj.Data;
 
                var p1 = ptr[0];
                var p2 = ptr[width - 1];
                var p3 = ptr[height / 2 + width / 2];
                var p4 = ptr[height - 1];
                var p5 = ptr[height - 1 + (width - 1)];
 
                return (obj.Size, obj.PixelFormat, p1, p2, p3, p4, p5).GetHashCode();
            }
        }
    }
 
    public static IEqualityComparer<Image> Comparer { get; } = new ImageEqualityComparer();
 
    public List<Image> Deinterleave()
    {
        nuint numOutputImages = 0;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_Deinterleave_GetOutputImageCount(PixelFormat, ref numOutputImages));
 
        PixelFormat pixelFormat = PixelFormat.Mono8;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_Deinterleave_GetOutputPixelFormat(PixelFormat, ref pixelFormat));
 
        var cInputImageSize = new Backend.Types.peak_common_size { width = Size.Width, height = Size.Height };
        var cOutputImageSize = new Backend.Types.peak_common_size();
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Image_Deinterleave_GetOutputImageSize(PixelFormat, cInputImageSize,
                out cOutputImageSize));
 
        var outputImages = new List<Image>();
        for (var i = 0; i < (int) numOutputImages; i++)
        {
            outputImages.Add(new Image(pixelFormat, new Size(cOutputImageSize.width, cOutputImageSize.height)));
        }
 
        IntPtr[] outputHandles = SafeHandles.ExtractHandles(
            outputImages,
            out Action release);
 
        try
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Image_Deinterleave(_handle, outputHandles, (nuint) outputHandles.Length));
        }
        finally
        {
            release();
        }
 
        return outputImages;
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        public Handle() : base(true)
        {
        }
 
        public Handle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Image_Destroy(handle) ==
                   Backend.Types.peak_icv_status.PEAK_ICV_STATUS_SUCCESS;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_SetRegion(Handle image_handle,
            Region.Handle region_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_ResetRegion(Handle image_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Create(out Handle image_handle,
            PixelFormat pixel_format, Backend.Types.peak_common_size image_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_CreateFromImageInfo(
            out Handle image_handle,
            Backend.Types.peak_icv_image_info image_info, nuint image_info_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_GetInfo(Handle image_handle,
            out Backend.Types.peak_icv_image_info image_info, nuint image_info_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_GetRegion(
            Handle image_handle, ref Region.Handle region_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Destroy(IntPtr image_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_SetCaptureInformation(Handle image_handle,
            Backend.Types.peak_icv_capture_information capture_information, nuint capture_information_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_GetCaptureInformation(Handle image_handle,
            out Backend.Types.peak_icv_capture_information capture_information, nuint capture_information_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Compare(Handle image_handle_lhs,
            Handle image_handle_rhs, [MarshalAs(UnmanagedType.I1)] out bool is_equal);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_IncreaseUseCount(Handle image_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_CreateFromFile(out Handle image_handle,
            byte[] file_path);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_ConvertPixelFormat(Handle input_handle,
            PixelFormat pixel_format, Handle output_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_ConvertPixelFormatWithFactor(
            Handle input_handle,
            PixelFormat pixel_format, double factor, Handle output_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Subtract(Handle input_handle,
            Handle subtrahend_handle, Handle output_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_CreateFromFileWithPixelFormat(
            out Handle image_handle,
            byte[] file_path, PixelFormat forced_pixelformat);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Deinterleave_GetOutputImageCount(
            PixelFormat input_pixel_format, ref nuint output_image_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Deinterleave_GetOutputPixelFormat(
            PixelFormat input_pixel_format, ref PixelFormat output_pixel_format);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Deinterleave_GetOutputImageSize(
            PixelFormat input_pixel_format, Backend.Types.peak_common_size input_image_size,
            out Backend.Types.peak_common_size output_image_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Image_Deinterleave(
            Handle input_image_handle, IntPtr[] output_image_handles, nuint output_image_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Buffer_CutBytes(IntPtr data,
            nuint line_start_offset, nuint bytes_per_line, nuint valid_bytes_per_line, nuint number_of_lines,
            Handle output_image_handle);
    }
}