CalibrationParameters.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.ICV.Backend;
 
namespace IDSImaging.Peak.ICV.Algorithms.Calibration;
 
public class CalibrationParameters
{
    public CalibrationParameters(string filePath)
    {
        var parameters = new Backend.Types.peak_icv_calibration_parameters();
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_CalibrationParameters_CreateFromFile(
                out parameters,
                (nuint) Marshal.SizeOf<Backend.Types.peak_icv_calibration_parameters>(),
                Utils.ToUtf8(filePath)));
 
        IntrinsicParameters = new IntrinsicParameters(parameters.intrinsic_parameters);
        ExtrinsicParameters = new ExtrinsicParameters(parameters.extrinsic_parameters);
    }
 
    public CalibrationParameters(IntrinsicParameters intrinsicParameters, ExtrinsicParameters extrinsicParameters)
    {
        IntrinsicParameters = intrinsicParameters;
        ExtrinsicParameters = extrinsicParameters;
    }
 
    public CalibrationParameters(byte[] data)
    {
        var isValid = false;
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_ValidateBinary(data, (nuint) data.Length, out isValid));
 
        if (!isValid)
        {
            throw new IcvCorruptedException("The given binary data is invalid");
        }
 
        var calibrationParameters = new Backend.Types.peak_icv_calibration_parameters();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_CalibrationParameters_CreateFromBinary(data,
                (nuint) data.Length,
                out calibrationParameters,
                (nuint) Marshal.SizeOf<Backend.Types.peak_icv_calibration_parameters>()));
 
        IntrinsicParameters =
            new IntrinsicParameters(calibrationParameters.intrinsic_parameters);
        ExtrinsicParameters =
            new ExtrinsicParameters(calibrationParameters.extrinsic_parameters);
    }
 
    internal CalibrationParameters(Backend.Types.peak_icv_calibration_parameters calibrationParameters) : this(
        new IntrinsicParameters(calibrationParameters.intrinsic_parameters),
        new ExtrinsicParameters(calibrationParameters.extrinsic_parameters))
    {
    }
 
    public IntrinsicParameters IntrinsicParameters { get; }
 
    public ExtrinsicParameters ExtrinsicParameters { get; set; }
 
    public static IEqualityComparer<CalibrationParameters> Comparer { get; } =
        new CalibrationParametersEqualityComparer();
 
    public byte[] ToBinary()
    {
        Backend.Types.peak_icv_calibration_parameters parameters = ToCType();
 
        nuint binarySize = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_CalibrationParameters_ToBinaryGetSizeInBytes(
                (nuint) Marshal.SizeOf<Backend.Types.peak_icv_calibration_parameters>(), out binarySize));
 
        var binary = new byte[(int) binarySize];
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_CalibrationParameters_ToBinary(
                parameters,
                (nuint) Marshal.SizeOf<Backend.Types.peak_icv_calibration_parameters>(),
                binary,
                binarySize));
 
        return binary;
    }
 
    public override string ToString()
    {
        return $"IntrinsicParameters: ({IntrinsicParameters}), ExtrinsicParameters: ({ExtrinsicParameters})";
    }
 
    public override int GetHashCode()
    {
        return IntrinsicParameters.GetHashCode();
    }
 
    internal Backend.Types.peak_icv_calibration_parameters ToCType()
    {
        return new Backend.Types.peak_icv_calibration_parameters
        {
            intrinsic_parameters = IntrinsicParameters.ToCType(),
            extrinsic_parameters = ExtrinsicParameters.ToCType()
        };
    }
 
    private sealed class CalibrationParametersEqualityComparer : IEqualityComparer<CalibrationParameters>
    {
        public bool Equals(CalibrationParameters x, CalibrationParameters y)
        {
            if (ReferenceEquals(x, y))
            {
                return true;
            }
 
            if (ReferenceEquals(x, null))
            {
                return false;
            }
 
            if (ReferenceEquals(y, null))
            {
                return false;
            }
 
            return IntrinsicParameters.Comparer.Equals(x.IntrinsicParameters, y.IntrinsicParameters) &&
                   ExtrinsicParameters.Comparer.Equals(x.ExtrinsicParameters, y.ExtrinsicParameters);
        }
 
        public int GetHashCode(CalibrationParameters obj)
        {
            return (IntrinsicParameters.Comparer.GetHashCode(obj.IntrinsicParameters),
                ExtrinsicParameters.Comparer.GetHashCode(obj.ExtrinsicParameters)).GetHashCode();
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_CalibrationParameters_CreateFromFile(
            out Backend.Types.peak_icv_calibration_parameters calibrationParameters,
            nuint calibrationParametersSize,
            byte[] filePath);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_CalibrationParameters_ToBinaryGetSizeInBytes(
            nuint calibrationParametersSize,
            out nuint binarySize);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_CalibrationParameters_ToBinary(
            Backend.Types.peak_icv_calibration_parameters calibrationParameters,
            nuint calibrationParametersSize,
            [Out] byte[] binaryParameters,
            nuint binaryParametersSize);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_ValidateBinary(
            byte[] binary,
            nuint binarySize,
            [MarshalAs(UnmanagedType.I1)] out bool isValid);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_CalibrationParameters_CreateFromBinary(
            [In] byte[] binaryParameters,
            nuint binaryParametersSize,
            out Backend.Types.peak_icv_calibration_parameters calibrationParameters,
            nuint calibrationParametersSize
        );
    }
}