Region.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Types.Geometry;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Painting;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Types;
 
public class Region : IDisposable, IDrawable, IHasSafeHandle
{
    internal Handle _handle;
 
    public Region()
    {
        var handle = new Handle();
        _handle = handle;
    }
 
    public Region(Point[] points)
    {
        Backend.Types.peak_icv_point[] cPoints = points
            .Select(coordinate => new Backend.Types.peak_icv_point { x = coordinate.X, y = coordinate.Y })
            .ToArray();
        var handle = new Handle(cPoints);
        _handle = handle;
    }
 
    public Region(Rectangle rectangle)
    {
        var cRectangle = new Backend.Types.peak_common_rectangle
            { x = rectangle.X, y = rectangle.Y, width = rectangle.Width, height = rectangle.Height };
        var handle = new Handle(cRectangle);
        _handle = handle;
    }
 
    internal Region(Handle handle)
    {
        _handle = handle;
    }
 
    public DisposableList<Region> ConnectedComponents
    {
        get
        {
            nuint numConnectedComponents = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_GetConnectedComponents_GetCount(_handle, out numConnectedComponents));
 
            if (numConnectedComponents == 0)
            {
                return new DisposableList<Region>();
            }
 
            var cConnectedComponentsHandles = new IntPtr[numConnectedComponents];
            try
            {
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Region_Array_Create(cConnectedComponentsHandles, numConnectedComponents));
 
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Region_GetConnectedComponents(_handle, cConnectedComponentsHandles,
                        numConnectedComponents));
 
                return
                    new DisposableList<Region>(
                        cConnectedComponentsHandles.Select(handle => new Region(new Handle(handle))).ToList());
            }
            catch (Exception)
            {
                CInterface.peak_icv_Region_Array_Destroy(cConnectedComponentsHandles, numConnectedComponents);
                throw;
            }
        }
    }
 
    public List<Point> Points
    {
        get
        {
            nuint numPoints = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_GetPoints_GetCount(_handle, out numPoints));
 
            if (numPoints == 0)
            {
                return new List<Point>();
            }
 
            var cPoints = new Backend.Types.peak_icv_point[numPoints];
 
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_GetPoints(_handle, cPoints, numPoints));
            return cPoints.Select(cCoordinate => new Point(cCoordinate.x, cCoordinate.y)).ToList();
        }
    }
 
    public uint Area
    {
        get
        {
            nuint area = 0;
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Region_GetArea(_handle, out area));
            return (uint) area;
        }
    }
 
    public PointF CenterOfGravity
    {
        get
        {
            var cCenterOfGravity = new Backend.Types.peak_icv_point_f();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_GetCenterOfGravity(_handle, out cCenterOfGravity));
            return new PointF(cCenterOfGravity.x, cCenterOfGravity.y);
        }
    }
 
    public static IEqualityComparer<Region> Comparer { get; } = new RegionEqualityComparer();
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    void IDrawable.Draw(Image image, DrawingOptions drawingOptions)
    {
        var cOptions = new Backend.Types.peak_icv_drawing_options
        {
            color = drawingOptions.Color.ColorCode,
            opacity = drawingOptions.Opacity.Value
        };
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Draw(image._handle, _handle, cOptions));
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public Region Difference(Region other)
    {
        var outputRegion = new Region();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Difference(_handle, other._handle, ref outputRegion._handle));
 
        return outputRegion;
    }
 
    public Region Union(Region other)
    {
        var outputRegion = new Region();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Union(_handle, other._handle, ref outputRegion._handle));
 
        return outputRegion;
    }
 
    public Region Intersection(Region other)
    {
        var outputRegion = new Region();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Intersection(_handle, other._handle, ref outputRegion._handle));
 
        return outputRegion;
    }
 
    public Region Dilation(Region structuringElement)
    {
        var outputRegion = new Region();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Dilation(_handle, structuringElement._handle, ref outputRegion._handle));
 
        return outputRegion;
    }
 
    public Region Erosion(Region structuringElement)
    {
        var outputRegion = new Region();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Region_Erosion(_handle, structuringElement._handle, ref outputRegion._handle));
 
        return outputRegion;
    }
 
    public override string ToString()
    {
        List<Point> points = Points;
        return "{" + string.Join(", ", points.Select(p => $"{{X: {p.X}, Y: {p.Y}}}")) + "}";
    }
 
    public static Region operator -(Region regionMinuend, Region regionSubtrahend)
    {
        return regionMinuend.Difference(regionSubtrahend);
    }
 
    public static Region operator +(Region region1, Region region2)
    {
        return region1.Union(region2);
    }
 
    private sealed class RegionEqualityComparer : IEqualityComparer<Region>
    {
        public bool Equals(Region x, Region y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }
 
            if (ReferenceEquals(x, null))
            {
                return false;
            }
 
            if (ReferenceEquals(y, null))
            {
                return false;
            }
 
            var isEqual = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_Compare(x._handle, y._handle, out isEqual));
 
            return isEqual;
        }
 
        public int GetHashCode(Region obj)
        {
            unchecked
            {
                return obj.Points?.Aggregate(17, (current, p) => current * 31 + p.GetHashCode()) ?? 0;
            }
        }
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Region_Create(out handle));
        }
 
        internal Handle(Backend.Types.peak_icv_point[] cPoints) : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_CreateFromPoints(out handle, cPoints, (uint) cPoints.Length));
        }
 
        internal Handle(Backend.Types.peak_common_rectangle cRectangle) : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Region_CreateFromRectangle(out handle, cRectangle));
        }
 
        internal Handle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Region_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_Region_Create(out IntPtr region_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_CreateFromPoints(
            out IntPtr region_handle,
            Backend.Types.peak_icv_point[] points, nuint num_points);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_CreateFromRectangle(
            out IntPtr region_handle,
            Backend.Types.peak_common_rectangle rectangle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Destroy(IntPtr region_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetArea(Handle input_region,
            out nuint area);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetPoints_GetCount(
            Handle input_region,
            out nuint points_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetPoints(Handle input_region,
            [Out] Backend.Types.peak_icv_point[] points, nuint num_points);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetConnectedComponents_GetCount(
            Handle input_region, out nuint num_connected_components);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetConnectedComponents(
            Handle input_region,
            IntPtr[] output_regions, nuint num_connected_components);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Array_Create(IntPtr[] region_handles,
            nuint num_region_handles);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Array_Destroy(IntPtr[] region_handles,
            nuint num_region_handles);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Compare(Handle region_lhs,
            Handle region_rhs,
            [MarshalAs(UnmanagedType.I1)] out bool is_equal);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_GetCenterOfGravity(Handle input_region,
            out Backend.Types.peak_icv_point_f center_of_gravity);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Difference(Handle input_region_minuend,
            Handle input_region_subtrahend, ref Handle output_region_difference);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Union(Handle input_region_1,
            Handle input_region_2, ref Handle output_region_united);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Intersection(Handle input_region_1,
            Handle input_region_2, ref Handle output_region_intersection);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Dilation(Handle input_region,
            Handle input_structuring_element, ref Handle output_region_dilation);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Erosion(Handle input_region,
            Handle input_structuring_element, ref Handle output_region_erosion);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Region_Draw(Image.Handle input_image,
            Handle input_region, Backend.Types.peak_icv_drawing_options drawing_options);
    }
}