Hdr.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Experimental.Hdr;
 
public enum HdrAlgorithm
{
    Debevec = 0
}
 
public class Hdr : IDisposable, IHasSafeHandle
{
    private readonly Handle _handle;
    private bool _disposed;
 
    public Hdr()
    {
        _handle = new Handle();
    }
 
    public HdrAlgorithm Algorithm
    {
        get
        {
            ThrowIfDisposed();
            var algorithm = 0;
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_HDR_GetAlgorithm(_handle, out algorithm));
            return (HdrAlgorithm) algorithm;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    ~Hdr()
    {
        Dispose(false);
    }
 
    public void EstimateResponseCurve(IEnumerable<Image> images)
    {
        ThrowIfDisposed();
 
        if (images == null)
        {
            throw new ArgumentNullException(nameof(images));
        }
 
        Image[] imageArray = images.ToArray();
        if (imageArray.Length == 0)
        {
            throw new ArgumentException("The image collection must not be empty.", nameof(images));
        }
 
        IntPtr[] imageHandles = imageArray.Select(img => img._handle.DangerousGetHandle()).ToArray();
 
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_HDR_EstimateResponseCurve(
            _handle,
            imageHandles,
            (nuint) imageHandles.Length));
    }
 
    public Image Process(IEnumerable<Image> images)
    {
        ThrowIfDisposed();
 
        if (images == null)
        {
            throw new IcvNullPointerException("The given image enumerable is null.");
        }
 
        Image[] imageArray = images.ToArray();
        if (imageArray.Length == 0)
        {
            throw new IcvNullPointerException("The given image enumerable is empty.");
        }
 
        Image refImage = imageArray.First();
        PixelFormat outputPixelFormat = new();
 
        IntPtr[] imageHandles = imageArray.Select(img => img._handle.DangerousGetHandle()).ToArray();
 
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_HDR_Process_GetOutputPixelFormat(
            _handle,
            refImage.PixelFormat,
            out outputPixelFormat));
 
        Image outputImage = new(
            outputPixelFormat,
            refImage.Size);
 
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_HDR_Process(
            _handle,
            imageHandles,
            (nuint) imageHandles.Length,
            outputImage._handle));
 
        return outputImage;
    }
 
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
        {
            return;
        }
 
        if (disposing)
        {
            _handle.Dispose();
        }
 
        _disposed = true;
    }
 
    private void ThrowIfDisposed()
    {
        if (_disposed)
        {
            throw new IcvNotPossibleException("The class is already disposed.");
        }
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_HDR_Create(out handle));
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_HDR_Destroy(handle) == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_Create(
            out IntPtr hdr_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_Destroy(
            IntPtr hdr_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_GetAlgorithm(
            Handle hdr_handle,
            out int algorithm);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_EstimateResponseCurve(
            Handle hdr_handle,
            [In] IntPtr[] image_handles,
            nuint image_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_Process_GetOutputPixelFormat(
            Handle hdr_handle,
            PixelFormat input_pixel_format,
            out PixelFormat output_pixel_format);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_HDR_Process(
            Handle hdr_handle,
            [In] IntPtr[] image_handles,
            nuint image_count,
            Image.Handle output_image_handle);
    }
}