CalibrationResult.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.ICV.Backend;
using IDSImaging.Peak.ICV.Types;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Algorithms.Calibration;
 
public class CalibrationResult : IDisposable, IHasSafeHandle
{
    internal readonly Handle _handle;
 
    public CalibrationResult(string filePath)
    {
        var handle = new Handle(filePath);
        _handle = handle;
    }
 
    internal CalibrationResult(Handle handle)
    {
        _handle = handle;
    }
 
    public CalibrationParameters CalibrationParameters
    {
        get
        {
            var calibrationParameters = new Backend.Types.peak_icv_calibration_parameters();
 
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Calibration_Result_ToParameters(
                _handle, out calibrationParameters,
                (nuint) Marshal.SizeOf<Backend.Types.peak_icv_calibration_parameters>()));
            return new CalibrationParameters(calibrationParameters);
        }
    }
 
    public double MeanReprojectionError
    {
        get
        {
            var meanReprojectionError = 0.0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_Result_GetMeanReprojectionError(
                    _handle, out meanReprojectionError));
            return meanReprojectionError;
        }
    }
 
    public DisposableList<CalibrationView> Views
    {
        get
        {
            nuint numViews = 0;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_Result_GetCalibrationViews_GetCount(
                    _handle, out numViews));
 
            if (numViews == 0)
            {
                return new DisposableList<CalibrationView>();
            }
 
            var viewHandles = new IntPtr[numViews];
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_View_Array_Create(viewHandles, numViews));
 
            try
            {
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Calibration_Result_GetCalibrationViews(_handle, viewHandles, numViews));
 
                return new DisposableList<CalibrationView>(viewHandles
                    .Select(handle => new CalibrationView(new CalibrationView.Handle(handle)))
                    .ToList());
            }
            catch (Exception)
            {
                CInterface.peak_icv_Calibration_View_Array_Destroy(viewHandles, numViews);
                throw;
            }
        }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public static implicit operator CalibrationParameters(CalibrationResult calibrationResult)
    {
        return calibrationResult.CalibrationParameters;
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_Result_Create(out handle));
        }
 
        internal Handle(string filePath) : base(true)
        {
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Calibration_Result_CreateFromFile(out handle,
                    Utils.ToUtf8(filePath)));
        }
 
        protected override bool ReleaseHandle()
        {
            return CInterface.peak_icv_Calibration_Result_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_Result_Create(
            out IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_CreateFromFile(
            out IntPtr handle,
            byte[] filePath);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_Destroy(
            IntPtr handle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_GetMeanReprojectionError(
            Handle handle, out double meanReprojectionError);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_ToParameters(
            Handle handle, out Backend.Types.peak_icv_calibration_parameters calibration_parameters,
            nuint size_of_calibration_parameters);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_GetCalibrationViews_GetCount(
            Handle handle, out nuint calibration_view_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_Result_GetCalibrationViews(
            Handle handle, IntPtr[] calibration_view_handle, nuint calibration_view_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_Array_Create(
            IntPtr[] handle, nuint calibration_view_count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Calibration_View_Array_Destroy(
            IntPtr[] handle, nuint calibration_view_count);
    }
}