Threshold.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.Common.Types.Detail;
using IDSImaging.Peak.ICV.Algorithms.Thresholds.Detail;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types;
 
namespace IDSImaging.Peak.ICV.Algorithms.Thresholds
{
    namespace Detail
    {
        public abstract class ThresholdT<T> where T : struct, IComparable<T>
        {
            public ThresholdT(IntervalT<T> interval)
            {
                Interval = interval;
            }
 
            public IntervalT<T> Interval { get; }
 
            public Region Process(Image image)
            {
                var region = new Region();
                var sizeOfInterval = Marshal.SizeOf(typeof(Backend.Types.peak_icv_interval_u));
 
                var intervalBackend = Activator.CreateInstance(TypeTraits.GetCTypeOfInterval<IntervalT<T>>(),
                    Interval.Minimum, Interval.Maximum);
 
                var handle = GCHandle.Alloc(intervalBackend, GCHandleType.Pinned);
                IntPtr ptr = handle.AddrOfPinnedObject();
 
                try
                {
                    DllHelper.ExecuteAndMapReturnCodes(() =>
                        CInterface.peak_icv_Threshold_Process(image._handle,
                            ptr,
                            (nuint) sizeOfInterval, out region._handle));
                }
                finally
                {
                    handle.Free();
                }
 
                return region;
            }
        }
    }
 
    public class Threshold : ThresholdT<int>
    {
        public Threshold(Interval interval) : base(interval)
        {
        }
 
        public static Interval GetRange(Image image)
        {
            var intervalBackend = new Backend.Types.peak_icv_interval();
            var sizeOfInterval = Marshal.SizeOf(typeof(Backend.Types.peak_icv_interval));
 
            unsafe
            {
                Backend.Types.peak_icv_interval* ptr = &intervalBackend;
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Threshold_GetRange(image._handle, (IntPtr) ptr, (nuint) sizeOfInterval));
            }
 
            return new Interval(intervalBackend.minimum, intervalBackend.maximum);
        }
    }
 
    public class ThresholdF : ThresholdT<float>
    {
        public ThresholdF(IntervalF interval) : base(interval)
        {
        }
 
        public static IntervalF GetRange(Image image)
        {
            var intervalBackend = new Backend.Types.peak_icv_interval_f();
            var sizeOfInterval = Marshal.SizeOf(typeof(Backend.Types.peak_icv_interval_f));
 
            unsafe
            {
                Backend.Types.peak_icv_interval_f* ptr = &intervalBackend;
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Threshold_GetRange(image._handle, (IntPtr) ptr, (nuint) sizeOfInterval));
            }
 
            return new IntervalF(intervalBackend.minimum, intervalBackend.maximum);
        }
    }
 
    internal static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Threshold_Process(Image.Handle inputImage,
            IntPtr interval, nuint sizeOfInterval, out Region.Handle outputRegion);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Threshold_GetRange(Image.Handle inputImage,
            IntPtr interval, nuint sizeOfInterval);
    }
}