ColorMatrixTransformationModule.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.Pipeline.Features;
using IDSImaging.Peak.ICV.Pipeline.Types;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
using IHasSafeHandle = IDSImaging.Peak.ICV.Backend.IHasSafeHandle;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class ColorMatrixTransformationModule : ModuleBase, IDisposable, IHasSafeHandle
{
    private const string _saturationKey = "Saturation";
    private const string _matrixKey = "ColorCorrection";
    private const string _chromaticAdaptionKey = "ChromaticAdaption";
    private const string _valueKey = "Value";
    private const string _algorithmKey = "Algorithm";
    private const string _targetColorSpaceKey = "TargetColorSpace";
    private const string _colorTemperatureKey = "ColorTemperature";
 
    internal const float DefaultSaturation = 1.0f;
 
    internal const ChromaticAdaptionAlgorithm DefaultChromaticAdaptionAlgorithm = ChromaticAdaptionAlgorithm.Bradford;
 
    internal const ColorSpace DefaultColorSpace = ColorSpace.SRGB_D65;
 
    private readonly Handle _handle;
    private IAutoFeature? _autoFeatureModule;
 
    public ColorMatrixTransformationModule()
    {
        Version = 2;
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_Create(out handle));
        _handle = handle;
    }
 
    internal static ColorCorrectionMatrix DefaultColorCorrectionMatrix => ColorCorrectionMatrix.Identity();
 
    public override string TypeId => "ColorMatrixTransformation";
 
    public override bool IsEnabled
    {
        get => IsColorCorrectionEnabled || IsSaturationEnabled || IsChromaticAdaptionEnabled;
        set
        {
            IsColorCorrectionEnabled = value;
            IsSaturationEnabled = value;
            IsChromaticAdaptionEnabled = value;
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public ColorCorrectionMatrix Matrix
    {
        get
        {
            Backend.Types.peak_icv_color_correction_matrix backendMatrix =
                ColorCorrectionMatrix.Identity().ToBackend();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_GetColorCorrectionMatrix(
                        _handle, out backendMatrix));
            return new ColorCorrectionMatrix(backendMatrix);
        }
        set
        {
            Backend.Types.peak_icv_color_correction_matrix backendMatrix = value.ToBackend();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_SetColorCorrectionMatrix(
                        _handle, backendMatrix));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public float Saturation
    {
        get
        {
            var saturation = 1.0f;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturation(
                    _handle, out saturation));
            return saturation;
        }
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_SetSaturation(
                    _handle, value));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public IntervalF SaturationRange
    {
        get
        {
            var interval = new Backend.Types.peak_icv_interval_f();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturationRange(
                    _handle, out interval));
            return new IntervalF(interval.minimum, interval.maximum);
        }
    }
 
    public ChromaticAdaptionAlgorithm ChromaticAdaptionAlgorithm
    {
        get
        {
            Backend.Types.peak_icv_chromatic_adaption_algorithm algorithm = Backend.Types
                .peak_icv_chromatic_adaption_algorithm.PEAK_ICV_CHROMATIC_ADAPTION_ALGORITHM_BRADFORD;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetAlgorithm(
                        _handle, out algorithm));
            return (ChromaticAdaptionAlgorithm) algorithm;
        }
        set
        {
            var algorithm = (Backend.Types.peak_icv_chromatic_adaption_algorithm) value;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetAlgorithm(
                        _handle, algorithm));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public ColorSpace TargetColorSpace
    {
        get
        {
            Backend.Types.peak_icv_color_space colorSpace =
                Backend.Types.peak_icv_color_space.PEAK_ICV_COLOR_SPACE_SRGB_D65;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetTargetColorSpace(
                        _handle, out colorSpace));
            return (ColorSpace) colorSpace;
        }
        set
        {
            var colorSpace = (Backend.Types.peak_icv_color_space) value;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetTargetColorSpace(
                        _handle, colorSpace));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public uint? ColorTemperature
    {
        get
        {
            if (!HasColorTemperature())
            {
                return null;
            }
 
            var colorTemperature = 0u;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperature(
                        _handle, out colorTemperature));
            return colorTemperature;
        }
        set
        {
            if (value == null)
            {
                ResetColorTemperature();
                return;
            }
 
            var colorTemperature = (uint) value;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetColorTemperature(
                        _handle, colorTemperature));
 
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public RangeU ColorTemperatureRange
    {
        get
        {
            var range = new Backend.Types.peak_icv_range_u();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperatureRange(
                        _handle, out range));
            return new RangeU(range.minimum, range.maximum, range.increment);
        }
    }
 
    internal bool IsColorCorrectionEnabled
    {
        get
        {
            var enabled = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_IsEnabled(
                        _handle, out enabled));
            return enabled;
        }
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_SetEnabled(
                        _handle, value));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    internal bool IsSaturationEnabled
    {
        get
        {
            var enabled = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_IsEnabled(
                    _handle, out enabled));
            return enabled;
        }
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_SetEnabled(
                        _handle, value));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    internal bool IsChromaticAdaptionEnabled
    {
        get
        {
            var enabled = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_IsEnabled(
                        _handle, out enabled));
            return enabled;
        }
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface
                    .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetEnabled(
                        _handle, value));
            UpdateMatrixInAutoFeatureModule();
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override void Serialize(IArchive archive)
    {
        archive.SetInt64(VersionKey, Version);
 
        IArchive saturationArchive = archive.CreateArchive();
        saturationArchive.SetBool(EnabledKey, IsSaturationEnabled);
        saturationArchive.SetDouble(_valueKey, Saturation);
        archive.SetArchive(_saturationKey, saturationArchive);
 
        IArchive matrixArchive = archive.CreateArchive();
        matrixArchive.SetBool(EnabledKey, IsColorCorrectionEnabled);
        Matrix.Serialize(matrixArchive);
        archive.SetArchive(_matrixKey, matrixArchive);
 
        IArchive chromaticAdaptionArchive = archive.CreateArchive();
        chromaticAdaptionArchive.SetBool(EnabledKey, IsChromaticAdaptionEnabled);
        chromaticAdaptionArchive.SetString(_algorithmKey,
            ChromaticAdaptionAlgorithm.ToString());
 
        chromaticAdaptionArchive.SetString(_targetColorSpaceKey, TargetColorSpace.ToString());
        var colorTemperature = ColorTemperature;
        if (colorTemperature is not null)
        {
            chromaticAdaptionArchive.SetInt64(_colorTemperatureKey, (long) colorTemperature);
        }
 
        archive.SetArchive(_chromaticAdaptionKey, chromaticAdaptionArchive);
    }
 
    public override void Deserialize(IArchive archive)
    {
        var version = archive.GetInt64(VersionKey);
        ValidateVersion(version, TypeId);
 
        IArchive saturationArchive = archive.GetArchive(_saturationKey);
        IArchive matrixArchive = archive.GetArchive(_matrixKey);
 
        IsColorCorrectionEnabled = matrixArchive.GetBool(EnabledKey);
        IsSaturationEnabled = saturationArchive.GetBool(EnabledKey);
 
        var matrix = ColorCorrectionMatrix.Identity();
        matrix.Deserialize(matrixArchive);
        Matrix = matrix;
        Saturation = (float) saturationArchive.GetDouble(_valueKey);
 
        if (version >= 2)
        {
            IArchive chromaticAdaptionArchive = archive.GetArchive(_chromaticAdaptionKey);
            if (chromaticAdaptionArchive.HasKey(_colorTemperatureKey))
            {
                ColorTemperature = (uint) chromaticAdaptionArchive.GetInt64(_colorTemperatureKey);
            }
            else
            {
                ResetColorTemperature();
            }
 
            try
            {
                TargetColorSpace = (ColorSpace) Enum.Parse(typeof(ColorSpace),
                    chromaticAdaptionArchive.GetString(_targetColorSpaceKey));
                ChromaticAdaptionAlgorithm = (ChromaticAdaptionAlgorithm) Enum.Parse(typeof(ChromaticAdaptionAlgorithm),
                    chromaticAdaptionArchive.GetString(_algorithmKey));
            }
            catch (Exception e)
            {
                throw new IcvCorruptedException(e.Message);
            }
 
            IsChromaticAdaptionEnabled = chromaticAdaptionArchive.GetBool(EnabledKey);
        }
        else
        {
            ResetChromaticAdaption();
        }
 
        UpdateMatrixInAutoFeatureModule();
    }
 
    public override void ResetToDefault()
    {
        Matrix = DefaultColorCorrectionMatrix;
        Saturation = DefaultSaturation;
        ResetChromaticAdaption();
    }
 
    public override Image Process(Image inputImage)
    {
        if (!IsEnabled || !NeedsProcessing())
        {
            return inputImage;
        }
 
        PixelFormat pixelFormat = inputImage.PixelFormat;
        var info = new PixelFormatInfo(pixelFormat);
        var isColorImage = info.HasChannel(Channel.Red) && info.HasChannel(Channel.Green) &&
                           info.HasChannel(Channel.Blue);
        if (!isColorImage || info.IsPacked)
        {
            return inputImage;
        }
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_ProcessInplace(
                _handle, inputImage._handle));
 
        return inputImage;
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public void SetAutoFeatureModule(IAutoFeature? module)
    {
        _autoFeatureModule = module;
        UpdateMatrixInAutoFeatureModule();
    }
 
    internal void ResetChromaticAdaption()
    {
        ChromaticAdaptionAlgorithm = DefaultChromaticAdaptionAlgorithm;
        TargetColorSpace = DefaultColorSpace;
        ResetColorTemperature();
 
        UpdateMatrixInAutoFeatureModule();
    }
 
    private void ResetColorTemperature()
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface
                .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_ResetColorTemperature(
                    _handle));
 
        UpdateMatrixInAutoFeatureModule();
    }
 
    public bool HasColorTemperature()
    {
        var value = false;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface
                .peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_HasColorTemperature(
                    _handle, out value));
 
        return value;
    }
 
    private bool NeedsProcessing()
    {
        var value = false;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_NeedsProcessing(
                _handle, out value));
 
        return value;
    }
 
    private void UpdateMatrixInAutoFeatureModule()
    {
        if (_autoFeatureModule == null)
        {
            return;
        }
 
        ColorCorrectionMatrix matrix = GetEffectiveMatrix();
        _autoFeatureModule.SetColorCorrectionMatrix(matrix.Flatten());
    }
 
    private ColorCorrectionMatrix GetEffectiveMatrix()
    {
        Backend.Types.peak_icv_color_correction_matrix ccm = new();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_GetEffectiveMatrix(
                _handle,
                out ccm
            )
        );
 
        return new ColorCorrectionMatrix(ccm);
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        public Handle() : base(true)
        {
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Preprocessing_ColorMatrixTransformation_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_Preprocessing_ColorMatrixTransformation_Create(
            out Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_ColorMatrixTransformation_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_NeedsProcessing(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool needsProcessing);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ProcessInplace(
                Handle handle, Image.Handle imageHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_SetColorCorrectionMatrix(
                Handle handle, Backend.Types.peak_icv_color_correction_matrix matrix);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_GetColorCorrectionMatrix(
                Handle handle, out Backend.Types.peak_icv_color_correction_matrix matrix);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_GetEffectiveMatrix(
                Handle handle, out Backend.Types.peak_icv_color_correction_matrix matrix);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_SetSaturation(
                Handle handle, float saturation);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturation(
                Handle handle, out float saturation);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturationRange(
                Handle handle, out Backend.Types.peak_icv_interval_f range);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetTargetColorSpace(
                Handle handle, out Backend.Types.peak_icv_color_space colorSpace);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetTargetColorSpace(
                Handle handle, Backend.Types.peak_icv_color_space colorSpace);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetAlgorithm(
                Handle handle, out Backend.Types.peak_icv_chromatic_adaption_algorithm algorithm);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetAlgorithm(
                Handle handle, Backend.Types.peak_icv_chromatic_adaption_algorithm algorithm);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetColorTemperature(
                Handle handle, uint colorTemperature);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperature(
                Handle handle, out uint colorTemperature);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_ResetColorTemperature(
                Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperatureRange(
                Handle handle, out Backend.Types.peak_icv_range_u range);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_HasColorTemperature(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool hasColorTemperature);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] bool enabled);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_IsEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool enabled);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_SetEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] bool enabled);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_IsEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool enabled);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_SetEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] bool enabled);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_IsEnabled(
                Handle handle, [MarshalAs(UnmanagedType.I1)] out bool enabled);
    }
}