ToneMapping.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 ToneMappingAlgorithm
{
    Reinhard = 0
}
 
public class ToneMapping : IDisposable, IHasSafeHandle
{
    private readonly Handle _handle;
    private bool _disposed;
 
    public ToneMapping()
    {
        _handle = new Handle();
    }
 
    public ToneMappingAlgorithm Algorithm
    {
        get
        {
            ThrowIfDisposed();
            var algorithm = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_ToneMapping_GetAlgorithm(_handle, out algorithm));
            return (ToneMappingAlgorithm) algorithm;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    ~ToneMapping()
    {
        Dispose(false);
    }
 
    public Image Process(Image image)
    {
        ThrowIfDisposed();
 
        if (image == null)
        {
            throw new IcvNullPointerException("The input image cannot be null.");
        }
 
        PixelFormat outputPixelFormat = new();
 
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_ToneMapping_Process_GetOutputPixelFormat(
            _handle,
            image.PixelFormat,
            out outputPixelFormat));
 
        Image outputImage = new(
            outputPixelFormat,
            image.Size);
 
        DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_ToneMapping_Process(
            _handle,
            image._handle,
            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_ToneMapping_Create(out handle));
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_ToneMapping_Destroy(handle) == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ToneMapping_Create(
            out IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ToneMapping_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ToneMapping_GetAlgorithm(
            Handle handle,
            out int algorithm);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ToneMapping_SetAlgorithm(
            Handle handle,
            int algorithm);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ToneMapping_Process_GetOutputPixelFormat(
            Handle 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_ToneMapping_Process(
            Handle handle,
            Image.Handle input_image_handle,
            Image.Handle output_image_handle);
    }
}