CaptureInformation.cs

Go to the documentation of this file.

using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.Common.Types.Geometry;
 
namespace IDSImaging.Peak.ICV.Backend;
 
internal static class CaptureInformation
{
    public static Metadata ToMetadata(Types.peak_icv_capture_information captureInfo)
    {
        var metadata = new Metadata();
        MergeWithMetadata(captureInfo, metadata);
        return metadata;
    }
 
    public static void MergeWithMetadata(Types.peak_icv_capture_information captureInfo, Metadata metadata)
    {
        metadata.SetValueByKey(MetadataKeys.DeviceTimestamp, captureInfo.relative_timestamp);
        metadata.SetValueByKey(MetadataKeys.BinningHorizontal, captureInfo.binning_factor.x);
        metadata.SetValueByKey(MetadataKeys.BinningVertical, captureInfo.binning_factor.y);
        metadata.SetValueByKey(MetadataKeys.Roi, new RectangleU(
            new PointU(captureInfo.region_of_interest.x, captureInfo.region_of_interest.y),
            new Size(captureInfo.region_of_interest.width, captureInfo.region_of_interest.height)));
        metadata.SetValueByKey(MetadataKeys.DeviceExposureTime, captureInfo.exposure_time);
        metadata.SetValueByKey(MetadataKeys.DeviceExposureTimeSequence, new List<double>(captureInfo
            .exposure_time_sequence));
        metadata.SetValueByKey(MetadataKeys.DeviceGain, captureInfo.gain);
        metadata.SetValueByKey(MetadataKeys.DeviceGainSequence, new List<double>(captureInfo.gain_sequence));
    }
 
    public static Types.peak_icv_capture_information FromMetadata(Metadata metadata, Size imageSize)
    {
        if (!metadata.HasEntryByKey(MetadataKeys.Roi))
        {
            metadata.SetValueByKey(MetadataKeys.Roi, new RectangleU(new PointU(0, 0), imageSize));
        }
 
        return FromMetadata(metadata);
    }
 
    public static Types.peak_icv_capture_information FromMetadata(Metadata metadata)
    {
        var captureInfo = new Types.peak_icv_capture_information();
        captureInfo.binning_factor.x = 1;
        captureInfo.binning_factor.y = 1;
        captureInfo.relative_timestamp = 0;
 
        if (metadata.TryGetValueByKey(MetadataKeys.BinningHorizontal, out var binningHorizontal))
        {
            captureInfo.binning_factor.x = binningHorizontal;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.BinningVertical, out var binningVertical))
        {
            captureInfo.binning_factor.y = binningVertical;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.DeviceTimestamp, out var timestamp))
        {
            captureInfo.relative_timestamp = timestamp;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.Roi, out RectangleU? roi) && roi != null)
        {
            captureInfo.region_of_interest.x = roi.X;
            captureInfo.region_of_interest.y = roi.Y;
            captureInfo.region_of_interest.width = roi.Width;
            captureInfo.region_of_interest.height = roi.Height;
        }
        else
        {
            captureInfo.region_of_interest.x = 0;
            captureInfo.region_of_interest.y = 0;
            captureInfo.region_of_interest.width = 0;
            captureInfo.region_of_interest.height = 0;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.DeviceExposureTime, out var exposureTime))
        {
            captureInfo.exposure_time = exposureTime;
        }
        else
        {
            captureInfo.exposure_time = 0;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.DeviceExposureTimeSequence, out List<double>? exposureTimeSequence))
        {
            if (exposureTimeSequence != null && exposureTimeSequence.Count > 4)
            {
                throw new NotSupportedException(
                    "Exposure time sequence has to be smaller than or equal to 4.");
            }
 
            var paddedExposureTimeSequence = new double[4];
            exposureTimeSequence?.CopyTo(paddedExposureTimeSequence, 0);
 
            captureInfo.exposure_time_sequence = paddedExposureTimeSequence;
        }
        else
        {
            captureInfo.exposure_time_sequence = new double[4];
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.DeviceGain, out var gain))
        {
            captureInfo.gain = gain;
        }
        else
        {
            captureInfo.gain = 0;
        }
 
        if (metadata.TryGetValueByKey(MetadataKeys.DeviceGainSequence, out List<double>? gainSequence))
        {
            if (gainSequence != null && gainSequence.Count > 4)
            {
                throw new NotSupportedException(
                    "Gain sequence has to be smaller than or equal to 4.");
            }
 
            var paddedGainSequence = new double[4];
            gainSequence?.CopyTo(paddedGainSequence, 0);
 
            captureInfo.gain_sequence = paddedGainSequence;
        }
        else
        {
            captureInfo.gain_sequence = new double[4];
        }
 
        return captureInfo;
    }
}