DownsamplingModule.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.Common.Types.Geometry;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public enum DownsamplingMode
{
    BinningAverage = Backend.Types.peak_icv_downsampling_mode.PEAK_ICV_BINNING_AVERAGE,
 
    BinningSum = Backend.Types.peak_icv_downsampling_mode.PEAK_ICV_BINNING_SUM,
 
    Decimation = Backend.Types.peak_icv_downsampling_mode.PEAK_ICV_DECIMATION
}
 
public class DownsamplingModule : ModuleBase, IDisposable, IHasSafeHandle
{
    private const string _modeKey = "Mode";
    private const string _xKey = "X";
    private const string _yKey = "Y";
    private const string _defaultModeKey = "DefaultMode";
 
    internal const uint DefaultX = 1;
    internal const uint DefaultY = 1;
 
    private readonly Handle _handle;
 
 
    private DownsamplingMode _defaultMode = DownsamplingMode.BinningAverage;
 
    public DownsamplingModule()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Downsampling_Create(out handle,
                new Backend.Types.peak_common_point_u(1, 1),
                (Backend.Types.peak_icv_downsampling_mode) _defaultMode));
        _handle = handle;
    }
 
    public DownsamplingModule(DownsamplingMode defaultMode, string customName)
    {
        _defaultMode = defaultMode;
        CustomId = customName;
 
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Downsampling_Create(out handle,
                new Backend.Types.peak_common_point_u(1, 1),
                (Backend.Types.peak_icv_downsampling_mode) _defaultMode));
        _handle = handle;
    }
 
    public string? CustomId { get; set; }
 
    public override string TypeId => CustomId ?? "Downsampling";
 
    public uint X
    {
        get => Factor.X;
 
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_SetFactor(_handle,
                    new Backend.Types.peak_common_point_u(value, Y)));
        }
    }
 
    public uint Y
    {
        get => Factor.Y;
 
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_SetFactor(_handle,
                    new Backend.Types.peak_common_point_u(X, value)));
        }
    }
 
    public IntervalU Range
    {
        get
        {
            var range = new Backend.Types.peak_icv_interval_u();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_GetRange(_handle,
                    out range));
            return new IntervalU(range.minimum, range.maximum);
        }
    }
 
    public DownsamplingMode Mode
    {
        get
        {
            Backend.Types.peak_icv_downsampling_mode mode = Backend.Types.peak_icv_downsampling_mode
                .PEAK_ICV_BINNING_AVERAGE;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_GetMode(_handle,
                    out mode));
            return (DownsamplingMode) mode;
        }
        set
        {
            // Note: No checks done in C!
            if (!Enum.IsDefined(typeof(DownsamplingMode), value))
            {
                throw new IcvNotSupportedException("Given DownsamplingMode mode is not supported.");
            }
 
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_SetMode(_handle,
                    (Backend.Types.peak_icv_downsampling_mode) value));
        }
    }
 
    internal PointU Factor
    {
        get
        {
            var factor = new Backend.Types.peak_common_point_u();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_GetFactor(_handle,
                    out factor));
            return new PointU(factor.x, factor.y);
        }
        set
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_SetFactor(_handle,
                    new Backend.Types.peak_common_point_u(value.X, value.Y)));
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override Image Process(Image inputImage)
    {
        if (!IsEnabled || !NeedsProcessing())
        {
            return inputImage;
        }
 
        var outputImageSize = new Backend.Types.peak_common_size();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Downsampling_GetOutputImageSize(_handle,
                inputImage._handle, out outputImageSize));
 
        var outputImage = new Image(inputImage.PixelFormat, new Size(outputImageSize.width, outputImageSize.height));
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Downsampling_Process(_handle,
                inputImage._handle, outputImage._handle));
 
        return outputImage;
 
        bool NeedsProcessing()
        {
            var shouldProcess = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_Downsampling_NeedsProcessing(_handle, out shouldProcess));
            return shouldProcess;
        }
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override void Serialize(IArchive archive)
    {
        base.Serialize(archive);
 
        PointU factor = Factor;
        archive.SetInt64(_xKey, factor.X);
        archive.SetInt64(_yKey, factor.Y);
 
        archive.SetString(_modeKey, Mode.ToString());
        archive.SetString(_defaultModeKey, _defaultMode.ToString());
    }
 
    public override void Deserialize(IArchive archive)
    {
        base.Deserialize(archive);
 
        var x = (uint) archive.GetInt64(_xKey);
        var y = (uint) archive.GetInt64(_yKey);
        Factor = new PointU(x, y);
 
        var modeStr = archive.GetString(_modeKey);
        var defaultModeStr = archive.GetString(_defaultModeKey);
 
        if (!Enum.TryParse(modeStr, out DownsamplingMode mode))
        {
            throw new IcvCorruptedException($"The given downsampling mode \"{modeStr}\" is unknown!");
        }
 
        if (!Enum.TryParse(defaultModeStr, out DownsamplingMode defaultMode))
        {
            throw new IcvCorruptedException(
                $"The given default downsampling mode \"{defaultModeStr}\" is unknown!");
        }
 
        Mode = mode;
        _defaultMode = defaultMode;
    }
 
    public override void ResetToDefault()
    {
        base.ResetToDefault();
 
        X = 1;
        Y = 1;
        Mode = _defaultMode;
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        public Handle() : base(true)
        {
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Preprocessing_Downsampling_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_Downsampling_Create(
            out Handle handle, Backend.Types.peak_common_point_u factor,
            Backend.Types.peak_icv_downsampling_mode mode);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_SetFactor(
            Handle handle, Backend.Types.peak_common_point_u factor);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_GetFactor(
            Handle handle, out Backend.Types.peak_common_point_u factor);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_GetRange(
            Handle handle, out Backend.Types.peak_icv_interval_u range);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_SetMode(
            Handle handle, Backend.Types.peak_icv_downsampling_mode mode);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_GetMode(
            Handle handle, out Backend.Types.peak_icv_downsampling_mode mode);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_GetOutputImageSize(
            Handle handle, Image.Handle imageHandle, out Backend.Types.peak_common_size outputImageSize);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Downsampling_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_Downsampling_Process(
            Handle handle, Image.Handle inputImageHandle, Image.Handle outputImageHandle);
    }
}