DebayerModule.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 DebayerModule : ModuleBase, IDisposable
{
    public const DebayerChannelLayout DefaultChannelLayout = DebayerChannelLayout.RGB;
 
    public const DebayerConversionPolicy DefaultConversionPolicy = DebayerConversionPolicy.BayerOnly;
 
    public const uint DefaultTargetBitDepth = 8;
 
    public const ProcessingPolicy DefaultPolicy = ProcessingPolicy.Fast;
 
    internal const string ConversionPolicyKey = "ConversionPolicy";
    internal const string ChannelLayoutKey = "ChannelLayout";
    private readonly ImageConverterCInterface.Handle _handle;
 
    public DebayerModule()
    {
        var handle = new ImageConverterCInterface.Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_Create(out handle));
        _handle = handle;
    }
 
    public override string TypeId => "Debayer";
 
    public DebayerChannelLayout ChannelLayout { get; set; } = DefaultChannelLayout;
 
    public DebayerConversionPolicy ConversionPolicy { get; set; } = DefaultConversionPolicy;
 
    public uint TargetBitDepth { get; set; } = DefaultTargetBitDepth;
 
    public ProcessingPolicy ProcessingPolicy { get; set; } = DefaultPolicy;
 
    public void Dispose()
    {
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override Image Process(Image inputImage)
    {
        if (!IsEnabled)
        {
            return inputImage;
        }
 
        PixelFormat inputFormat = inputImage.PixelFormat;
        PixelFormat outputFormat = GetOutputFormat(inputFormat);
 
        if (inputFormat == outputFormat)
        {
            return inputImage;
        }
 
        var outputImageHandle = new Image.Handle();
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_Convert(_handle,
                inputImage._handle,
                outputFormat, out outputImageHandle));
 
        return new Image(outputImageHandle);
    }
 
    public override void Serialize(IArchive archive)
    {
        base.Serialize(archive);
 
        archive.SetString(ChannelLayoutKey, ChannelLayout.ToString());
        archive.SetString(ConversionPolicyKey, ConversionPolicy.ToString());
    }
 
    public override void Deserialize(IArchive archive)
    {
        base.Deserialize(archive);
 
        try
        {
            ChannelLayout =
                (DebayerChannelLayout) Enum.Parse(typeof(DebayerChannelLayout), archive.GetString(ChannelLayoutKey));
            ConversionPolicy =
                (DebayerConversionPolicy) Enum.Parse(typeof(DebayerConversionPolicy),
                    archive.GetString(ConversionPolicyKey));
        }
        catch (Exception e)
        {
            throw new IcvCorruptedException(e.Message);
        }
    }
 
    public override void ResetToDefault()
    {
        ChannelLayout = DefaultChannelLayout;
        ConversionPolicy = DefaultConversionPolicy;
        TargetBitDepth = DefaultTargetBitDepth;
        ProcessingPolicy = DefaultPolicy;
    }
 
    public void ReleaseBuffers()
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            ImageConverterCInterface.CInterface.peak_icv_Preprocessing_ImageConverter_ReleaseBuffers(_handle));
    }
 
    private long GetOutputBitDepth(long inputBitDepth)
    {
        return ProcessingPolicy switch
        {
            ProcessingPolicy.Fast => Math.Min(inputBitDepth, TargetBitDepth),
            ProcessingPolicy.Enhanced => Math.Max(inputBitDepth, TargetBitDepth),
            _ => inputBitDepth
        };
    }
 
    private PixelFormat GetOutputFormat(PixelFormat inputFormat)
    {
        if (ConversionPolicy == DebayerConversionPolicy.Bypass)
        {
            return inputFormat;
        }
 
        var info = new PixelFormatInfo(inputFormat);
 
        if (!info.IsSingleChannel)
        {
            return inputFormat;
        }
 
        var isBayer = info.HasChannel(Channel.Bayer);
        var isMono = info.HasIntensityChannel;
 
        if (!isBayer && (!isMono || ConversionPolicy != DebayerConversionPolicy.BayerAndMono))
        {
            return inputFormat;
        }
 
        var inputBitDepth = info.StorageBitsPerChannel;
        var outputBitDepth = GetOutputBitDepth(inputBitDepth);
 
        PixelFormat ThrowNotSupported()
        {
            throw new IcvNotSupportedException(
                $"The given input pixel format 0x{(long) inputFormat:X} is unknown!");
        }
 
        if (outputBitDepth <= 8)
        {
            return ChannelLayout switch
            {
                DebayerChannelLayout.RGB => PixelFormat.RGB8,
                DebayerChannelLayout.BGR => PixelFormat.BGR8,
                DebayerChannelLayout.RGBA => PixelFormat.RGBa8,
                DebayerChannelLayout.BGRA => PixelFormat.BGRa8,
                _ => ThrowNotSupported()
            };
        }
 
        if (outputBitDepth <= 10)
        {
            return ChannelLayout switch
            {
                DebayerChannelLayout.RGB => PixelFormat.RGB10,
                DebayerChannelLayout.BGR => PixelFormat.BGR10,
                DebayerChannelLayout.RGBA => PixelFormat.RGBa10,
                DebayerChannelLayout.BGRA => PixelFormat.BGRa10,
                _ => ThrowNotSupported()
            };
        }
 
        if (outputBitDepth <= 12)
        {
            return ChannelLayout switch
            {
                DebayerChannelLayout.RGB => PixelFormat.RGB12,
                DebayerChannelLayout.BGR => PixelFormat.BGR12,
                DebayerChannelLayout.RGBA => PixelFormat.RGBa12,
                DebayerChannelLayout.BGRA => PixelFormat.BGRa12,
                _ => ThrowNotSupported()
            };
        }
 
        return ThrowNotSupported();
    }
}