HotpixelCorrectionModule.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 class HotpixelCorrectionModule : ModuleBase, IDisposable, IHasSafeHandle
{
    private const string _xKey = "X";
    private const string _yKey = "Y";
    private const string _hotpixelListKey = "HotpixelList";
 
    private readonly Handle _handle;
 
    public HotpixelCorrectionModule()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_HotpixelCorrection_Create(out handle));
        _handle = handle;
    }
 
    public override string TypeId => "HotpixelCorrection";
 
    public IEnumerable<Point> HotpixelList
    {
        get
        {
            nuint hotpixelCount = 0;
 
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(
                    _handle, out hotpixelCount));
 
            var hotpixelList = new Backend.Types.peak_icv_point[hotpixelCount];
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_HotpixelCorrection_GetList(
                    _handle, hotpixelList, hotpixelCount));
 
            return hotpixelList.Select(point => new Point(point.x, point.y));
        }
        set
        {
            Backend.Types.peak_icv_point[] hotpixelList =
                value.Select(point => new Backend.Types.peak_icv_point(point.X, point.Y)).ToArray();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_HotpixelCorrection_SetList(
                    _handle, hotpixelList, (nuint) hotpixelList.Count()));
        }
    }
 
    public IntervalU SensitivityRange
    {
        get
        {
            var interval = new Backend.Types.peak_icv_interval_u();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_HotpixelCorrection_GetSensitivityRange(
                    _handle, out interval));
            return new IntervalU(interval.minimum, interval.maximum);
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override Image Process(Image inputImage)
    {
        if (!IsEnabled || !NeedsProcessing())
        {
            return inputImage;
        }
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_HotpixelCorrection_ProcessInplace(
                _handle, inputImage._handle));
 
        return inputImage;
 
        bool NeedsProcessing()
        {
            nuint hotpixelCount = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(
                    _handle, out hotpixelCount));
 
            return hotpixelCount != 0;
        }
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override void Serialize(IArchive archive)
    {
        base.Serialize(archive);
 
        Point[] hotpixelList = HotpixelList.ToArray();
        var archivesList = new List<IArchive>(hotpixelList.Length);
        foreach (Point pixel in hotpixelList)
        {
            IArchive pixelArchive = archive.CreateArchive();
            pixelArchive.SetInt64(_xKey, pixel.X);
            pixelArchive.SetInt64(_yKey, pixel.Y);
            archivesList.Add(pixelArchive);
        }
 
        archive.SetArchiveArray(_hotpixelListKey, archivesList);
    }
 
    public override void Deserialize(IArchive archive)
    {
        base.Deserialize(archive);
 
        IReadOnlyList<IArchive> archives = archive.GetArchiveArray(_hotpixelListKey);
        var hotpixelList = new List<Point>(archives.Count);
        foreach (IArchive? pixelArchive in archives)
        {
            var x = pixelArchive.GetInt64(_xKey);
            var y = pixelArchive.GetInt64(_yKey);
            hotpixelList.Add(new Point((int) x, (int) y));
        }
 
        HotpixelList = hotpixelList;
    }
 
    public void Detect(Image image, uint sensitivity = 3, float gainFactor = 1.0F)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_HotpixelCorrection_Detect(
                _handle, image._handle, sensitivity, gainFactor));
    }
 
    public override void ResetToDefault()
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_HotpixelCorrection_ResetList(
                _handle));
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Preprocessing_HotpixelCorrection_Destroy(handle) == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_Create(
            out Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_HotpixelCorrection_ProcessInplace(
                Handle handle, Image.Handle imageHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_ResetList(
            Handle handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_SetList(
            Handle handle, Backend.Types.peak_icv_point[] list, nuint count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(
                Handle handle, out nuint count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_GetList(
            Handle handle, [Out] Backend.Types.peak_icv_point[] list, nuint count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_HotpixelCorrection_Detect(
            Handle handle, Image.Handle imageHandle, uint sensitivity, float gainFactor);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_HotpixelCorrection_GetSensitivityRange(
                Handle handle, out Backend.Types.peak_icv_interval_u range);
    }
}