PolygonF.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Types.Geometry;
using IDSImaging.Peak.ICV.Backend;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Types.Geometry;
 
public class PolygonF : IDisposable, IHasSafeHandle
{
    internal readonly Handle _handle;
 
    public PolygonF()
    {
        _handle = new Handle();
    }
 
    public PolygonF(PointF[] points)
    {
        Backend.Types.peak_icv_point_f[] cPoints = points
            .Select(coordinate => new Backend.Types.peak_icv_point_f { x = coordinate.X, y = coordinate.Y })
            .ToArray();
 
        _handle = new Handle(cPoints);
    }
 
    internal PolygonF(Handle handle)
    {
        _handle = handle;
    }
 
    public bool IsClosed
    {
        get
        {
            var isClosed = false;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Polygon_IsClosed(_handle, out isClosed));
            return isClosed;
        }
    }
 
    public PointF[] Points
    {
        get
        {
            nuint numPoints = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Polygon_GetPoints_GetCount(_handle, out numPoints));
 
            if (numPoints == 0)
            {
                return Array.Empty<PointF>();
            }
 
            var cPoints = new Backend.Types.peak_icv_point_f[numPoints];
            var cPointsHandle = GCHandle.Alloc(cPoints, GCHandleType.Pinned);
 
            try
            {
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Polygon_GetPoints(_handle, cPointsHandle.AddrOfPinnedObject(),
                        numPoints * (nuint) Marshal.SizeOf(typeof(Backend.Types.peak_icv_point_f))));
            }
            finally
            {
                cPointsHandle.Free();
            }
 
            return cPoints.Select(cCoordinate => new PointF(cCoordinate.x, cCoordinate.y)).ToArray();
        }
    }
 
    public static IEqualityComparer<PolygonF> Comparer { get; } = new PolygonFEqualityComparer();
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override string ToString()
    {
        PointF[] points = Points;
        return "(" + string.Join(", ", points.Select(p => "(" + p + ")")) + ")";
    }
 
    private sealed class PolygonFEqualityComparer : IEqualityComparer<PolygonF>
    {
        public bool Equals(PolygonF x, PolygonF y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }
 
            if (ReferenceEquals(x, null))
            {
                return false;
            }
 
            if (ReferenceEquals(y, null))
            {
                return false;
            }
 
            return x.Points.SequenceEqual(y.Points);
        }
 
        public int GetHashCode(PolygonF obj)
        {
            return obj.Points.Aggregate(17, (current, point) =>
                current * 31 + (point?.GetHashCode() ?? 0));
        }
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Polygon_Create(out handle));
        }
 
        internal Handle(Backend.Types.peak_icv_point_f[] cPoints) : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Polygon_CreateFromPoints(out handle,
                cPoints, (uint) cPoints.Length, Backend.Types.peak_icv_point_type.PEAK_ICV_POINT_TYPE_XY));
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Polygon_Destroy(handle) ==
                   Backend.Types.peak_icv_status.PEAK_ICV_STATUS_SUCCESS;
        }
    }
 
    internal static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_Create(out IntPtr polygon_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_CreateFromPoints(
            out IntPtr polygon_handle, Backend.Types.peak_icv_point_f[] points, nuint num_points,
            Backend.Types.peak_icv_point_type point_type);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_Destroy(IntPtr polygon_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_IsClosed(Handle polygon_handle,
            [MarshalAs(UnmanagedType.I1)] out bool is_closed);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_GetPoints_GetCount(
            Handle polygon_handle,
            out nuint num_points);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Polygon_GetPoints(Handle polygon_handle,
            IntPtr points, nuint byte_size_points);
    }
}