SharpeningModule.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.Common.Types;
using IDSImaging.Peak.ICV.Types;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class SharpeningModule : ModuleBase
{
    private const string _levelKey = "Level";
 
    internal const uint DefaultLevel = 0;
 
    private uint _level = DefaultLevel;
 
    public override string TypeId => "Sharpening";
 
    public uint Level
    {
        get => _level;
        set
        {
            IntervalU range = LevelRange;
            if (value < range.Minimum || value > range.Maximum)
            {
                throw new IcvOutOfRangeException($"The given level value {value} is out of range!");
            }
 
            _level = value;
        }
    }
 
    public IntervalU LevelRange
    {
        get
        {
            var levelRange = new Backend.Types.peak_icv_interval_u();
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_ImageFilter_Sharpening_GetRange(out levelRange));
            return new IntervalU(levelRange.minimum, levelRange.maximum);
        }
    }
 
    public override void Serialize(IArchive archive)
    {
        base.Serialize(archive);
 
        archive.SetInt64(_levelKey, _level);
    }
 
    public override void Deserialize(IArchive archive)
    {
        base.Deserialize(archive);
 
        Level = (uint) archive.GetInt64(_levelKey);
    }
 
    public override Image Process(Image inputImage)
    {
        if (!IsEnabled || Level == 0)
        {
            return inputImage;
        }
 
        PixelFormat pixelFormat = inputImage.PixelFormat;
        var info = new PixelFormatInfo(pixelFormat);
        var isSupportedMonoImage = pixelFormat is PixelFormat.Mono8 or PixelFormat.Mono10 or PixelFormat.Mono12;
        var isColorImage = info.HasChannel(Channel.Red) && info.HasChannel(Channel.Green) &&
                           info.HasChannel(Channel.Blue);
        var isSupportedColorImage = isColorImage && pixelFormat != PixelFormat.RGB10p32
                                                 && pixelFormat != PixelFormat.BGR10p32;
        if (!isSupportedMonoImage && !isSupportedColorImage)
        {
            return inputImage;
        }
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_ImageFilter_Sharpening_ProcessInPlace(inputImage._handle, _level));
 
        return inputImage;
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override void ResetToDefault()
    {
        base.ResetToDefault();
 
        _level = DefaultLevel;
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_ImageFilter_Sharpening_GetRange(
            out Backend.Types.peak_icv_interval_u range);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        internal static extern Backend.Types.peak_icv_status peak_icv_ImageFilter_Sharpening_ProcessInPlace(
            Image.Handle inputImageHandle, uint level);
    }
}