DefaultPipeline.cs

Go to the documentation of this file.

using IDSImaging.Peak.Common.Pipeline;
using IDSImaging.Peak.Common.Pipeline.Modules;
using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Pipeline.Features;
using IDSImaging.Peak.ICV.Pipeline.Modules;
using IDSImaging.Peak.ICV.Serialization;
using IDSImaging.Peak.ICV.Types;
using DebayerConversionPolicy = IDSImaging.Peak.ICV.Pipeline.Types.DebayerConversionPolicy;
using ProcessingPolicy = IDSImaging.Peak.ICV.Pipeline.Types.ProcessingPolicy;
using DebayerChannelLayout = IDSImaging.Peak.ICV.Pipeline.Types.DebayerChannelLayout;
using BackendStatus = IDSImaging.Peak.ICV.Backend.Types.peak_icv_status;
using Utils = IDSImaging.Peak.ICV.Backend.Utils;
 
namespace IDSImaging.Peak.ICV.Pipeline;
 
public class DefaultPipeline : PipelineBase, IDisposable
{
    private const ProcessingPolicy _defaultProcessingPolicy = ProcessingPolicy.Fast;
 
    private readonly DownsamplingModule _binning = new(DownsamplingMode.BinningAverage, "Binning");
    private readonly ColorMatrixTransformationModule _colorCorrection = new();
    private readonly DebayerModule _debayer = new();
    private readonly DownsamplingModule _decimation = new(DownsamplingMode.Decimation, "Decimation");
    private readonly PixelFormatConversionModule _finalConversion = new();
    private readonly GainModule _gain = new();
    private readonly HotpixelCorrectionModule _hotpixel = new();
    private readonly MonoConversionModule _monoConversion = new();
    private readonly SharpeningModule _sharpening = new();
    private readonly ToneCurveCorrectionModule _toneCurveCorrection = new();
    private readonly TransformationModule _transformation = new();
    private readonly UnpackModule _unpack = new();
 
    private IAutoFeature? _autoFeatureModule;
 
    private bool _disposed;
    private ProcessingPolicy _processingPolicy = _defaultProcessingPolicy;
 
    public DefaultPipeline()
    {
        _monoConversion.IsEnabled = false;
        PixelFormat format = _finalConversion.OutputPixelFormat;
        var bitDepth = new PixelFormatInfo(format).StorageBitsPerChannel;
        _unpack.ProcessingPolicy = _processingPolicy;
        _unpack.TargetBitDepth = bitDepth;
 
        _debayer.ProcessingPolicy = _processingPolicy;
        _debayer.TargetBitDepth = bitDepth;
 
        Hotpixel = new HotpixelCorrectionFeature(_hotpixel);
 
        Rotation = new RotationFeature(_transformation);
        Mirror = new MirrorFeature(_transformation);
 
        Gain = new GainFeature(_gain);
 
        Binning = new BinningFeature(_binning);
        Decimation = new DecimationFeature(_decimation);
 
        ColorCorrection = new ColorCorrectionFeature(_colorCorrection);
        Saturation = new SaturationFeature(_colorCorrection);
        ChromaticAdaption = new ChromaticAdaptionFeature(_colorCorrection);
 
        Gamma = new GammaFeature(_toneCurveCorrection);
        DigitalBlack = new DigitalBlackFeature(_toneCurveCorrection);
 
        Sharpening = new SharpeningFeature(_sharpening);
    }
 
    private static int Version => 1;
 
    public override string TypeId => "DefaultPipeline";
 
    public ProcessingPolicy ProcessingPolicy
    {
        get => _processingPolicy;
        set => UpdateProcessingPolicy(value);
    }
 
    public PixelFormat OutputPixelFormat
    {
        get => _finalConversion.OutputPixelFormat;
        set => UpdateOutputPixelFormat(value);
    }
 
    public HotpixelCorrectionFeature Hotpixel { get; }
 
    public BinningFeature Binning { get; }
 
    public DecimationFeature Decimation { get; }
 
    public MirrorFeature Mirror { get; }
 
    public RotationFeature Rotation { get; }
 
    public GainFeature Gain { get; }
 
    public ColorCorrectionFeature ColorCorrection { get; }
 
    public SaturationFeature Saturation { get; }
 
    public ChromaticAdaptionFeature ChromaticAdaption { get; }
 
    public SharpeningFeature Sharpening { get; }
 
    public GammaFeature Gamma { get; }
 
    public DigitalBlackFeature DigitalBlack { get; }
 
    public IAutoFeature? AutoFeatureModule
    {
        get => _autoFeatureModule;
        set
        {
            _autoFeatureModule?.SetGainModule(null);
            _autoFeatureModule = value;
 
            _colorCorrection.SetAutoFeatureModule(_autoFeatureModule);
            _autoFeatureModule?.SetGainModule(_gain);
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    ~DefaultPipeline()
    {
        Dispose(false);
    }
 
    private void Dispose(bool disposing)
    {
        if (_disposed)
        {
            return;
        }
 
        _autoFeatureModule?.SetGainModule(null);
 
        if (disposing)
        {
            // Do not reorder, otherwise we dispose the autofeature module
            _autoFeatureModule = null;
 
            // dispose managed objects
            foreach (IModule? module in GetModules())
            {
                var mod = module as IDisposable;
                mod?.Dispose();
            }
        }
 
        _disposed = true;
    }
 
    protected override IReadOnlyList<IModule> GetModules()
    {
        if (_autoFeatureModule == null)
        {
            return new List<IModule>
            {
                _unpack, _hotpixel, _binning, _decimation, _transformation, _gain, _debayer, _colorCorrection,
                _monoConversion,
                _sharpening, _toneCurveCorrection, _finalConversion
            };
        }
 
        return new List<IModule>
        {
            _unpack, _hotpixel, _binning, _decimation, _transformation, _gain, _debayer, _colorCorrection,
            _autoFeatureModule,
            _monoConversion, _sharpening, _toneCurveCorrection, _finalConversion
        };
    }
 
    private IReadOnlyList<IFeature> GetFeatures()
    {
        return new List<IFeature>
        {
            Hotpixel, Binning, Decimation, Mirror, Rotation, Gain,
            ColorCorrection, Saturation, Sharpening, Gamma, DigitalBlack
        };
    }
 
    public override string ExportSettingsToString()
    {
        using var archive = new Archive();
 
        IReadOnlyList<IModule> moduleList = GetModules();
        var modules = new List<IArchive>(moduleList.Count);
 
        foreach (IModule? module in moduleList)
        {
            IArchive moduleArchive = archive.CreateArchive();
            moduleArchive.SetString("Type", module.TypeId);
 
            IArchive moduleDataArchive = moduleArchive.CreateArchive();
            module.Serialize(moduleDataArchive);
            moduleArchive.SetArchive("Data", moduleDataArchive);
            modules.Add(moduleArchive);
        }
 
        archive.SetArchiveArray("Modules", modules);
        archive.SetInt64("Version", Version);
        archive.SetString("Type", TypeId);
        archive.SetString("Creation", GetCurrentIsoUtcTime());
 
        var stream = new MemoryStream();
        var serializer = new Serializer();
        serializer.Write(archive, stream);
 
        return Utils.FromUtf8(stream.ToArray());
    }
 
    public override void ImportSettingsFromString(string settings)
    {
        var stream = new MemoryStream(Utils.ToUtf8(settings));
 
        var deserializer = new Deserializer();
        IArchive archive = deserializer.Read(stream);
        using var dispose = archive as IDisposable;
 
        var version = archive.GetInt64("Version");
        if (version < 1)
        {
            throw new IcvNotSupportedException(
                $"The 'Version' entry {version} in the settings string is invalid! Must be at least 1.");
        }
 
        var pipelineType = archive.GetString("Type");
        if (pipelineType != TypeId)
        {
            throw new IcvNotPossibleException(
                $"The settings for {pipelineType} are not compatible with this pipeline ({TypeId}).");
        }
 
        IReadOnlyList<IModule> modules = GetModules();
 
        var archiveMap = new Dictionary<string, IArchive>();
        IReadOnlyList<IArchive> moduleArchives = archive.GetArchiveArray("Modules");
 
        foreach (IArchive? moduleArchive in moduleArchives)
        {
            using var disposeModuleArchive = moduleArchive as IDisposable;
            var moduleType = moduleArchive.GetString("Type");
            IArchive data = moduleArchive.GetArchive("Data");
            archiveMap.Add(moduleType, data);
        }
 
        try
        {
            foreach (IModule? module in modules)
            {
                if (!archiveMap.TryGetValue(module.TypeId, out IArchive? foundArchive))
                {
                    throw new IcvCorruptedException($"The settings for module {module.TypeId} are missing!");
                }
 
                module.Deserialize(foundArchive);
            }
        }
        finally
        {
            foreach (IArchive? moduleArchive in archiveMap.Values)
            {
                using var disposeModuleArchive = moduleArchive as IDisposable;
            }
        }
    }
 
    public override void ResetToDefault()
    {
        foreach (IModule? module in GetModules())
        {
            module.ResetToDefault();
            module.IsEnabled = true;
        }
 
        foreach (IFeature? feature in GetFeatures())
        {
            feature.ResetToDefault();
            feature.IsEnabled = true;
        }
 
        _monoConversion.IsEnabled = false;
        ProcessingPolicy = _defaultProcessingPolicy;
    }
 
    internal IModule? TryGetModuleById(string typeId)
    {
        return GetModules()
            .FirstOrDefault(m => m != null && m.TypeId == typeId);
    }
 
    public Image Process(Image image)
    {
        Image current = image;
        foreach (IModule? mod in GetModules())
        {
            try
            {
                try
                {
                    var next = (Image) mod.Process(current);
 
                    if (!ReferenceEquals(next, current))
                    {
                        // Dispose replaced intermediate image
                        if (!ReferenceEquals(current, image))
                        {
                            current.Dispose();
                        }
                    }
 
                    current = next;
                }
                catch (IcvException e)
                {
                    BackendStatus errorCode = e.ErrorCode;
                    var what = e.Message;
                    var moduleType = mod.TypeId;
 
                    var errorText = $"[{moduleType}] {what}";
                    switch (errorCode)
                    {
                        case BackendStatus.PEAK_ICV_STATUS_LIBRARY_NOT_INITIALIZED:
                        case BackendStatus.PEAK_ICV_STATUS_DYNAMIC_DEPENDENCY_MISSING:
                            throw new IcvInvalidConfigurationException(errorText, errorCode);
                        case BackendStatus.PEAK_ICV_STATUS_INVALID_HANDLE:
                        case BackendStatus.PEAK_ICV_STATUS_INVALID_BUFFER_SIZE:
                        case BackendStatus.PEAK_ICV_STATUS_MISMATCH:
                        case BackendStatus.PEAK_ICV_STATUS_NULL_POINTER:
                        case BackendStatus.PEAK_ICV_STATUS_NOT_SUPPORTED:
                        case BackendStatus.PEAK_ICV_STATUS_NOT_POSSIBLE:
                            throw new IcvNotSupportedException(errorText);
                        case BackendStatus.PEAK_ICV_STATUS_CORRUPTED:
                            throw new IcvCorruptedException(errorText);
                        case BackendStatus.PEAK_ICV_STATUS_OUT_OF_RANGE:
                            throw new IcvOutOfRangeException(errorText);
                        case BackendStatus.PEAK_ICV_STATUS_INTERNAL_ERROR:
                            throw new IcvException(errorText, errorCode);
                        default:
                            throw new IcvException("Generic Error!", errorCode);
                    }
                }
            }
            catch
            {
                // Dispose intermediate image if needed
                if (!ReferenceEquals(current, image))
                {
                    current.Dispose();
                }
 
                throw;
            }
        }
 
        return image.Data == current.Data ? current.Copy() : current;
    }
 
    public override object Process(object input)
    {
        if (input is not Image image)
        {
            throw new IcvNotSupportedException(
                $"Casting from {input.GetType().Name} to the given type {typeof(Image).Name} is not supported!");
        }
 
        return Process(image);
    }
 
    public Image Process(IImageView imageView)
    {
        using var image = new Image(imageView);
        return Process(image);
    }
 
    public void ReleaseBuffers()
    {
        _unpack.ReleaseBuffers();
        _debayer.ReleaseBuffers();
        _monoConversion.ReleaseBuffers();
        _finalConversion.ReleaseBuffers();
    }
 
 
    private static string GetCurrentIsoUtcTime()
    {
        DateTime utcNow = DateTime.UtcNow;
        var isoTimestamp = utcNow.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'");
        return isoTimestamp;
    }
 
    private void UpdateProcessingPolicy(ProcessingPolicy policy)
    {
        _processingPolicy = policy;
 
        _unpack.ProcessingPolicy = _processingPolicy;
        _debayer.ProcessingPolicy = _processingPolicy;
    }
 
    private void UpdateOutputPixelFormat(PixelFormat format)
    {
        var info = new PixelFormatInfo(format);
 
        var isBayerFormat = info.IsSingleChannel && info.HasChannel(Channel.Bayer);
        var isMonoFormat = info.IsSingleChannel && info.HasIntensityChannel;
 
        if (isBayerFormat)
        {
            _debayer.ConversionPolicy = DebayerConversionPolicy.Bypass;
        }
        else if (isMonoFormat)
        {
            _debayer.ConversionPolicy = DebayerConversionPolicy.BayerOnly;
            _debayer.ChannelLayout = DebayerChannelLayout.RGB;
        }
        else
        {
            _debayer.ConversionPolicy = DebayerConversionPolicy.BayerAndMono;
 
            if (info.HasChannel(Channel.Red) && info.HasChannel(Channel.Green)
                                             && info.HasChannel(Channel.Blue))
            {
                _debayer.ConversionPolicy = DebayerConversionPolicy.BayerAndMono;
                switch (format)
                {
                    case PixelFormat.RGB8:
                    case PixelFormat.RGB10:
                    case PixelFormat.RGB12:
                        _debayer.ChannelLayout = DebayerChannelLayout.RGB;
                        break;
                    case PixelFormat.RGBa8:
                    case PixelFormat.RGBa10:
                    case PixelFormat.RGBa12:
                        _debayer.ChannelLayout = DebayerChannelLayout.RGBA;
                        break;
                    case PixelFormat.BGR8:
                    case PixelFormat.BGR10:
                    case PixelFormat.BGR12:
                        _debayer.ChannelLayout = DebayerChannelLayout.BGR;
                        break;
                    case PixelFormat.BGRa8:
                    case PixelFormat.BGRa10:
                    case PixelFormat.BGRa12:
                        _debayer.ChannelLayout = DebayerChannelLayout.BGRA;
                        break;
                }
            }
        }
 
        _monoConversion.IsEnabled = isMonoFormat;
 
        _finalConversion.OutputPixelFormat = format;
 
        var bitDepth = info.StorageBitsPerChannel;
        _unpack.TargetBitDepth = bitDepth;
        _debayer.TargetBitDepth = bitDepth;
    }
}