CalibrationView.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types.Geometry;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Algorithms.Calibration;
 
public class CalibrationView : IDisposable, IHasSafeHandle
{
    private readonly Handle _handle;
 
    internal CalibrationView(Handle handle)
    {
        _handle = handle;
    }
 
    internal CalibrationView()
    {
        _handle = new Handle();
    }
 
    public ReprojectionError[] ReprojectionErrors
    {
        get
        {
            nuint numReprojectionErrors = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetReprojectionErrors_GetCount(
                    _handle, out numReprojectionErrors));
 
            if (numReprojectionErrors == 0)
            {
                return Array.Empty<ReprojectionError>();
            }
 
            var cReprojectionErrors = new Backend.Types.peak_icv_reprojection_error[numReprojectionErrors];
 
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetReprojectionErrors(_handle,
                    cReprojectionErrors,
                    numReprojectionErrors));
            return cReprojectionErrors.Select(cReprojectionError => new ReprojectionError(cReprojectionError))
                .ToArray();
        }
    }
 
    public double MeanReprojectionError
    {
        get
        {
            double cMeanReprojectionError = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetMeanReprojectionError(
                    _handle, out cMeanReprojectionError));
            return cMeanReprojectionError;
        }
    }
 
    public double MaxReprojectionError
    {
        get
        {
            double cMaxReprojectionError = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetMaximumReprojectionError(
                    _handle, out cMaxReprojectionError));
            return cMaxReprojectionError;
        }
    }
 
    public CoordinateSystem CoordinateSystem
    {
        get
        {
            var cCoordinateSystem = new Backend.Types.peak_icv_coordinate_system();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetCoordinateSystem(_handle, out cCoordinateSystem));
            return new CoordinateSystem(cCoordinateSystem);
        }
    }
 
    public ExtrinsicParameters ExtrinsicParameters
    {
        get
        {
            var cExtrinsicParameters = new Backend.Types.peak_icv_extrinsic_parameters();
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Calibration_View_GetExtrinsicParameters(
                _handle, out cExtrinsicParameters,
                (nuint) Marshal.SizeOf(cExtrinsicParameters)));
            return new ExtrinsicParameters(cExtrinsicParameters);
        }
    }
 
    public PolygonF ConvexHull
    {
        get
        {
            var handle = new PolygonF.Handle();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_GetConvexHull(_handle, out handle));
            return new PolygonF(handle);
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Calibration_View_Create(out handle));
        }
 
        internal Handle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Calibration_View_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_Calibration_View_Create(
            out IntPtr calibration_view_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_Destroy(
            IntPtr calibration_view_handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetExtrinsicParameters(
            Handle calibration_view_handle, out Backend.Types.peak_icv_extrinsic_parameters extrinsic_parameters,
            nuint extrinsic_parameters_size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetCoordinateSystem(
            Handle calibration_view_handle, out Backend.Types.peak_icv_coordinate_system coordinate_system);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetReprojectionErrors_GetCount(
            Handle calibration_view_handle, out nuint num_reprojection_errors);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetReprojectionErrors(
            Handle calibration_view_handle, [Out] Backend.Types.peak_icv_reprojection_error[] reprojection_errors,
            nuint num_reprojection_errors);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetMeanReprojectionError(
            Handle calibration_view_handle, out double mean_reprojection_error);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetMaximumReprojectionError(
            Handle calibration_view_handle, out double max_reprojection_error);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_GetConvexHull(
            Handle calibration_view_handle, out PolygonF.Handle polygon_handle);
    }
}