ToneCurveCorrectionModule.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Pipeline.Features;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class ToneCurveCorrectionModule : ModuleBase, IDisposable, IHasSafeHandle
{
    private const string _valueKey = "Value";
    private const string _gammaKey = "Gamma";
    private const string _digitalBlackKey = "DigitalBlack";
 
    internal const float DefaultGamma = 1.0f;
    internal const float DefaultDigitalBlack = 0.0f;
 
    private readonly Handle _handle;
    private float _digitalBlack = DefaultDigitalBlack;
    private float _gamma = DefaultGamma;
    private bool _isDigitalBlackEnabled = true;
    private bool _isGammaEnabled = true;
 
    public ToneCurveCorrectionModule()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ToneCurveCorrection_Create(
                out handle
            )
        );
        _handle = handle;
    }
 
    public override string TypeId => "ToneCurveCorrection";
 
    public override bool IsEnabled
    {
        get => IsGammaEnabled || IsDigitalBlackEnabled;
        set
        {
            IsGammaEnabled = value;
            IsDigitalBlackEnabled = value;
        }
    }
 
    public float Gamma
    {
        get => _gamma;
        set
        {
            _gamma = value;
 
            if (IsGammaEnabled)
            {
                ApplyGamma();
            }
        }
    }
 
    public IntervalF GammaRange
    {
        get
        {
            var interval = new Backend.Types.peak_icv_interval_f();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ToneCurveCorrection_GetGammaRange(
                    _handle,
                    out interval
                )
            );
 
            return new IntervalF(interval.minimum, interval.maximum);
        }
    }
 
    public float DigitalBlack
    {
        get => _digitalBlack;
        set
        {
            _digitalBlack = value;
 
            if (IsDigitalBlackEnabled)
            {
                ApplyDigitalBlack();
            }
        }
    }
 
    public IntervalF DigitalBlackRange
    {
        get
        {
            var interval = new Backend.Types.peak_icv_interval_f();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ToneCurveCorrection_GetDigitalBlackRange(
                    _handle,
                    out interval
                )
            );
 
            return new IntervalF(interval.minimum, interval.maximum);
        }
    }
 
    internal bool IsGammaEnabled
    {
        get => _isGammaEnabled;
        set
        {
            _isGammaEnabled = value;
 
            ApplyGamma();
        }
    }
 
    internal bool IsDigitalBlackEnabled
    {
        get => _isDigitalBlackEnabled;
        set
        {
            _isDigitalBlackEnabled = value;
 
            ApplyDigitalBlack();
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override void Serialize(IArchive archive)
    {
        archive.SetInt64(VersionKey, 1);
 
        IArchive gammaArchive = archive.CreateArchive();
        gammaArchive.SetBool(EnabledKey, IsGammaEnabled);
        gammaArchive.SetDouble(_valueKey, Gamma);
        archive.SetArchive(_gammaKey, gammaArchive);
 
        IArchive digitalBlackArchive = archive.CreateArchive();
        digitalBlackArchive.SetBool(EnabledKey, IsDigitalBlackEnabled);
        digitalBlackArchive.SetDouble(_valueKey, DigitalBlack);
        archive.SetArchive(_digitalBlackKey, digitalBlackArchive);
    }
 
    public override void Deserialize(IArchive archive)
    {
        var version = archive.GetInt64(VersionKey);
        ValidateVersion(version, TypeId);
 
        IArchive gammaArchive = archive.GetArchive(_gammaKey);
        _gamma = (float) gammaArchive.GetDouble(_valueKey);
        IsGammaEnabled = gammaArchive.GetBool(EnabledKey);
 
        IArchive digitalBlackArchive = archive.GetArchive(_digitalBlackKey);
        _digitalBlack = (float) digitalBlackArchive.GetDouble(_valueKey);
        IsDigitalBlackEnabled = digitalBlackArchive.GetBool(EnabledKey);
    }
 
    public override void ResetToDefault()
    {
        Gamma = DefaultGamma;
        DigitalBlack = DefaultDigitalBlack;
    }
 
    public override Image Process(Image input)
    {
        if (!IsEnabled || !NeedsProcessing())
        {
            return input;
        }
 
        if (!IsSupportedPixelFormat(input.PixelFormat))
        {
            return input;
        }
 
        Image.Handle inputImageHandle = input._handle;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ToneCurveCorrection_ProcessInplace(
                _handle, inputImageHandle));
 
        return input;
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    private void ApplyGamma()
    {
        var newGamma = _isGammaEnabled ? _gamma : DefaultGamma;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ToneCurveCorrection_SetGamma(
                _handle,
                newGamma
            )
        );
    }
 
    private void ApplyDigitalBlack()
    {
        var newDigitalBlack = _isDigitalBlackEnabled ? _digitalBlack : DefaultDigitalBlack;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ToneCurveCorrection_SetDigitalBlack(
                _handle,
                newDigitalBlack
            )
        );
    }
 
    private bool NeedsProcessing()
    {
        var needsProcessing = false;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ToneCurveCorrection_NeedsProcessing(
                _handle, out needsProcessing));
 
        return needsProcessing;
    }
 
    private bool IsSupportedPixelFormat(PixelFormat format)
    {
        var info = new PixelFormatInfo(format);
 
        var isSupportedMonoImage =
            format == PixelFormat.Mono8
            || format == PixelFormat.Mono10
            || format == PixelFormat.Mono12
            || format == PixelFormat.Mono16;
 
        var isSupportedColorImage =
            info.HasChannel(Channel.Red)
            && info.HasChannel(Channel.Green)
            && info.HasChannel(Channel.Blue)
            && !info.IsPacked;
 
        return isSupportedMonoImage || isSupportedColorImage;
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
        }
 
        internal Handle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Preprocessing_ToneCurveCorrection_Destroy(handle) == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_ToneCurveCorrection_Create(
            out Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_ToneCurveCorrection_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_NeedsProcessing(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool needsProcessing);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_ProcessInplace(
                Handle handle, Image.Handle imageHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_ToneCurveCorrection_SetGamma(
            Handle handle, float gamma);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_ToneCurveCorrection_GetGamma(
            Handle handle, out float gamma);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_GetGammaRange(
                Handle handle, out Backend.Types.peak_icv_interval_f range);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_SetDigitalBlack(
                Handle handle, float digitalBlack);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_GetDigitalBlack(
                Handle handle, out float digitalBlack);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ToneCurveCorrection_GetDigitalBlackRange(
                Handle handle, out Backend.Types.peak_icv_interval_f range);
    }
}