UnpackModule.cs

Go to the documentation of this file.

using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Pipeline.Modules.Internal;
using IDSImaging.Peak.ICV.Pipeline.Types;
using IDSImaging.Peak.ICV.Types;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class UnpackModule : ModuleBase, IDisposable
{
    public const uint DefaultTargetBitDepth = 8;
 
    public const ProcessingPolicy DefaultProcessingPolicy = ProcessingPolicy.Fast;
 
    private readonly ImageConverterCInterface.Handle _handle;
 
    public UnpackModule()
    {
        var handle = new ImageConverterCInterface.Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_Create(out handle));
        _handle = handle;
    }
 
    public override string TypeId => "Unpack";
 
    public uint TargetBitDepth { get; set; } = DefaultTargetBitDepth;
 
    public ProcessingPolicy ProcessingPolicy { get; set; } = DefaultProcessingPolicy;
 
    public override bool IsEnabled
    {
        get => true;
        set { }
    }
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    public override Image Process(Image inputImage)
    {
        var inputBitDepth = new PixelFormatInfo(inputImage.PixelFormat).StorageBitsPerChannel;
        var outputBitDepth = GetOutputBitDepth(inputBitDepth);
        PixelFormat outputPixelFormat = GetOutputPixelFormat(inputImage.PixelFormat, outputBitDepth);
 
        if (inputImage.PixelFormat == outputPixelFormat)
        {
            return inputImage;
        }
 
        var outputImageHandle = new Image.Handle();
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_Convert(_handle,
                inputImage._handle,
                outputPixelFormat, out outputImageHandle));
 
        return new Image(outputImageHandle);
    }
 
    public override void ResetToDefault()
    {
        ProcessingPolicy = DefaultProcessingPolicy;
        TargetBitDepth = DefaultTargetBitDepth;
    }
 
    public void ReleaseBuffers()
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_ReleaseBuffers(_handle));
    }
 
    public override void Serialize(IArchive archive)
    {
        // Unlike other modules, Unpack behaves differently: it has no version,
        // is always enabled, and therefore cannot use the base class implementation.
    }
 
    public override void Deserialize(IArchive archive)
    {
        // Unpack behaves differently from other modules. Since it is always enabled,
        // the archive does not need to include an "enabled" entry.
        // It also does not have a version.
    }
 
    private uint GetOutputBitDepth(uint inputBitDepth)
    {
        return ProcessingPolicy switch
        {
            ProcessingPolicy.Fast => Math.Min(inputBitDepth, TargetBitDepth),
            ProcessingPolicy.Enhanced => Math.Max(inputBitDepth, TargetBitDepth),
            _ => inputBitDepth
        };
    }
 
    private PixelFormat GetOutputPixelFormat(PixelFormat inputPixelFormat, uint outputBitDepth)
    {
        var inputPixelFormatInfo = new PixelFormatInfo(inputPixelFormat);
        var isBayer = inputPixelFormatInfo.HasChannel(Channel.Bayer);
        var isYuv = inputPixelFormatInfo.HasChannel(Channel.ChromaV);
        var isMono = !isYuv && inputPixelFormatInfo.HasChannel(Channel.Intensity);
 
        if (isYuv)
        {
            return PixelFormat.RGB8;
        }
 
        if (isMono)
        {
            return outputBitDepth switch
            {
                >= 12 => PixelFormat.Mono12,
                >= 10 => PixelFormat.Mono10,
                _ => PixelFormat.Mono8
            };
        }
 
        if (isBayer)
        {
            PixelFormat unpackedFormat = new PixelFormatInfo(inputPixelFormat).UnpackedPixelFormat;
 
            var isBayerRg = unpackedFormat is
                PixelFormat.BayerRG8 or
                PixelFormat.BayerRG10 or
                PixelFormat.BayerRG12;
            if (isBayerRg)
            {
                return outputBitDepth switch
                {
                    >= 12 => PixelFormat.BayerRG12,
                    >= 10 => PixelFormat.BayerRG10,
                    _ => PixelFormat.BayerRG8
                };
            }
 
            var isBayerGr = unpackedFormat is
                PixelFormat.BayerGR8 or
                PixelFormat.BayerGR10 or
                PixelFormat.BayerGR12;
            if (isBayerGr)
            {
                return outputBitDepth switch
                {
                    >= 12 => PixelFormat.BayerGR12,
                    >= 10 => PixelFormat.BayerGR10,
                    _ => PixelFormat.BayerGR8
                };
            }
 
            var isBayerBg = unpackedFormat is
                PixelFormat.BayerBG8 or
                PixelFormat.BayerBG10 or
                PixelFormat.BayerBG12;
            if (isBayerBg)
            {
                return outputBitDepth switch
                {
                    >= 12 => PixelFormat.BayerBG12,
                    >= 10 => PixelFormat.BayerBG10,
                    _ => PixelFormat.BayerBG8
                };
            }
 
            var isBayerGb = unpackedFormat is
                PixelFormat.BayerGB8 or
                PixelFormat.BayerGB10 or
                PixelFormat.BayerGB12;
            if (isBayerGb)
            {
                return outputBitDepth switch
                {
                    >= 12 => PixelFormat.BayerGB12,
                    >= 10 => PixelFormat.BayerGB10,
                    _ => PixelFormat.BayerGB8
                };
            }
        }
 
        return inputPixelFormat;
    }
}