GainModule.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Pipeline.Modules;
using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class GainModule : ModuleBase, IGain, IDisposable, IHasSafeHandle
{
    private const string _masterGainKey = "MasterGain";
    private const string _redGainKey = "RedGain";
    private const string _greenGainKey = "GreenGain";
    private const string _blueGainKey = "BlueGain";
    internal const float DefaultGain = 1.0f;
 
    private readonly Handle _handle;
    private float _blueGain = DefaultGain;
    private float _greenGain = DefaultGain;
    private bool _isEnabled = true;
    private float _masterGain = DefaultGain;
    private float _redGain = DefaultGain;
 
    public GainModule()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Gain_Create(out handle)
        );
        _handle = handle;
    }
 
    public IntervalF Range
    {
        get
        {
            var range = new Backend.Types.peak_icv_interval_f();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Gain_GetRange(
                    _handle, out range)
            );
 
            return new IntervalF(range.minimum, range.maximum);
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    public override string TypeId => "Gain";
 
    public override bool IsEnabled
    {
        get => _isEnabled;
        set
        {
            _isEnabled = value;
            ApplyGain();
        }
    }
 
    public override void Serialize(IArchive archive)
    {
        base.Serialize(archive);
 
        archive.SetDouble(_masterGainKey, Master);
        archive.SetDouble(_redGainKey, Red);
        archive.SetDouble(_greenGainKey, Green);
        archive.SetDouble(_blueGainKey, Blue);
    }
 
    public override void Deserialize(IArchive archive)
    {
        base.Deserialize(archive);
 
        Master = (float) archive.GetDouble(_masterGainKey);
        Red = (float) archive.GetDouble(_redGainKey);
        Green = (float) archive.GetDouble(_greenGainKey);
        Blue = (float) archive.GetDouble(_blueGainKey);
    }
 
    public float Master
    {
        get => _masterGain;
        set
        {
            _masterGain = value;
 
            ApplyGain();
        }
    }
 
    public float Red
    {
        get => _redGain;
        set
        {
            _redGain = value;
 
            ApplyGain();
        }
    }
 
    public float Green
    {
        get => _greenGain;
        set
        {
            _greenGain = value;
 
            ApplyGain();
        }
    }
 
    public float Blue
    {
        get => _blueGain;
        set
        {
            _blueGain = value;
 
            ApplyGain();
        }
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override void ResetToDefault()
    {
        Master = DefaultGain;
        Red = DefaultGain;
        Green = DefaultGain;
        Blue = DefaultGain;
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override Image Process(Image input)
    {
        if (!IsEnabled || !NeedsProcessing())
        {
            return input;
        }
 
        Image.Handle inputImageHandle = input._handle;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Gain_ProcessInplace(
                _handle, inputImageHandle)
        );
 
        return input;
    }
 
    private void ApplyGain()
    {
        SetGain(Backend.Types.peak_icv_gain_type.PEAK_ICV_GAIN_TYPE_MASTER, _masterGain);
        SetGain(Backend.Types.peak_icv_gain_type.PEAK_ICV_GAIN_TYPE_RED, _redGain);
        SetGain(Backend.Types.peak_icv_gain_type.PEAK_ICV_GAIN_TYPE_GREEN, _greenGain);
        SetGain(Backend.Types.peak_icv_gain_type.PEAK_ICV_GAIN_TYPE_BLUE, _blueGain);
    }
 
    private void SetGain(Backend.Types.peak_icv_gain_type type, float value)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Gain_SetValue(_handle, type, value)
        );
    }
 
    private bool NeedsProcessing()
    {
        var needsProcessing = false;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Gain_NeedsProcessing(
                _handle, out needsProcessing)
        );
 
        return needsProcessing;
    }
 
    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_Gain_Destroy(handle) == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_Create(out Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_Destroy(IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_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_Gain_ProcessInplace(
            Handle handle, Image.Handle imageHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_GetValue(
            Handle handle, Backend.Types.peak_icv_gain_type type, out float value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_SetValue(
            Handle handle, Backend.Types.peak_icv_gain_type type, float value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Gain_GetRange(
            Handle handle, out Backend.Types.peak_icv_interval_f range);
    }
}