TransformationModule.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.Common.Types.Geometry;
using IDSImaging.Peak.ICV.Pipeline.Types;
using IDSImaging.Peak.ICV.Types;
 
namespace IDSImaging.Peak.ICV.Pipeline.Modules;
 
public class TransformationModule : ModuleBase
{
    internal const bool DefaultMirrorLeftRight = false;
    internal const bool DefaultMirrorUpDown = false;
    internal const Rotation DefaultRotationAngle = Rotation.None;
    internal const bool DefaultIsMirrorEnabled = true;
    internal const bool DefaultIsRotationEnabled = true;
 
    private const string _leftRightKey = "LeftRight";
    private const string _upDownKey = "UpDown";
    private const string _mirrorKey = "Mirror";
    private const string _angleKey = "Angle";
    private const string _rotationKey = "Rotation";
 
    public override string TypeId => "TransformationModule";
 
    public override bool IsEnabled
    {
        get => IsMirrorEnabled || IsRotationEnabled;
        set
        {
            IsMirrorEnabled = value;
            IsRotationEnabled = value;
        }
    }
 
    public bool MirrorLeftRight { get; set; } = DefaultMirrorLeftRight;
 
    public bool MirrorUpDown { get; set; } = DefaultMirrorUpDown;
 
    public Rotation RotationAngle { get; set; } = DefaultRotationAngle;
 
    internal bool IsMirrorEnabled { get; set; } = DefaultIsMirrorEnabled;
    internal bool IsRotationEnabled { get; set; } = DefaultIsRotationEnabled;
 
    public override Image Process(Image inputImage)
    {
        var mirrorNeedsProcessing = IsMirrorEnabled && (MirrorLeftRight || MirrorUpDown);
        var rotationNeedsProcessing = IsRotationEnabled && RotationAngle != Rotation.None;
 
        if (!mirrorNeedsProcessing && !rotationNeedsProcessing)
        {
            return inputImage;
        }
 
        var parameters = new Backend.Types.peak_icv_preprocessing_transformation_parameters(
            IsMirrorEnabled && MirrorLeftRight,
            IsMirrorEnabled && MirrorUpDown,
            CInterface.RotationAngleToCType(IsRotationEnabled
                ? RotationAngle
                : Rotation.None));
 
        var outputFormat = new PixelFormat();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Transformation_GetOutputPixelFormat(inputImage.PixelFormat,
                parameters, out outputFormat));
 
        var transpose = IsRotationEnabled && (RotationAngle == Rotation.Degree90Clockwise ||
                                              RotationAngle == Rotation.Degree90Counterclockwise);
        Size outputSize = transpose ? inputImage.Size.Transposed() : inputImage.Size;
 
        var outputImage = new Image(outputFormat, outputSize);
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Preprocessing_Transformation_Process(inputImage._handle, parameters,
                outputImage._handle));
 
        return outputImage;
    }
 
    public override object Process(object input)
    {
        return base.Process(input);
    }
 
    public override void Serialize(IArchive archive)
    {
        archive.SetInt64(VersionKey, Version);
 
        IArchive mirrorArchive = archive.CreateArchive();
        mirrorArchive.SetBool(EnabledKey, IsMirrorEnabled);
        mirrorArchive.SetBool(_leftRightKey, MirrorLeftRight);
        mirrorArchive.SetBool(_upDownKey, MirrorUpDown);
        archive.SetArchive(_mirrorKey, mirrorArchive);
 
        IArchive rotationArchive = archive.CreateArchive();
        rotationArchive.SetBool(EnabledKey, IsRotationEnabled);
        rotationArchive.SetInt64(_angleKey, (int) RotationAngle);
        archive.SetArchive(_rotationKey, rotationArchive);
    }
 
    public override void Deserialize(IArchive archive)
    {
        var version = archive.GetInt64(VersionKey);
        ValidateVersion(version, TypeId);
 
        IArchive rotationArchive = archive.GetArchive(_rotationKey);
        IsRotationEnabled = rotationArchive.GetBool(EnabledKey);
 
        var angle = (int) rotationArchive.GetInt64(_angleKey);
        if (!Enum.IsDefined(typeof(Rotation), angle))
        {
            throw new IcvNotSupportedException($"The rotation angle {angle} is invalid!");
        }
 
        RotationAngle = (Rotation) angle;
 
        IArchive mirrorArchive = archive.GetArchive(_mirrorKey);
        IsMirrorEnabled = mirrorArchive.GetBool(EnabledKey);
        MirrorLeftRight = mirrorArchive.GetBool(_leftRightKey);
        MirrorUpDown = mirrorArchive.GetBool(_upDownKey);
    }
 
    public override void ResetToDefault()
    {
        MirrorLeftRight = DefaultMirrorLeftRight;
        MirrorUpDown = DefaultMirrorUpDown;
        RotationAngle = DefaultRotationAngle;
    }
 
    private static class CInterface
    {
        public static Backend.Types.peak_icv_preprocessing_transformation_rotation_angle RotationAngleToCType(
            Rotation rotation)
        {
            return rotation switch
            {
                Rotation.None => Backend.Types.peak_icv_preprocessing_transformation_rotation_angle
                    .PEAK_ICV_PREPROCESSING_TRANSFORMATION_ROTATION_NONE,
                Rotation.Degree90Counterclockwise => Backend.Types
                    .peak_icv_preprocessing_transformation_rotation_angle
                    .PEAK_ICV_PREPROCESSING_TRANSFORMATION_ROTATION_90_DEGREE_COUNTERCLOCKWISE,
                Rotation.Degree180 => Backend.Types.peak_icv_preprocessing_transformation_rotation_angle
                    .PEAK_ICV_PREPROCESSING_TRANSFORMATION_ROTATION_180_DEGREE,
                Rotation.Degree90Clockwise => Backend.Types.peak_icv_preprocessing_transformation_rotation_angle
                    .PEAK_ICV_PREPROCESSING_TRANSFORMATION_ROTATION_90_DEGREE_CLOCKWISE,
                _ => throw new IcvNotSupportedException("Unsupported rotation angle.")
            };
        }
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status
            peak_icv_Preprocessing_Transformation_GetOutputPixelFormat(
                PixelFormat inputPixelFormat,
                Backend.Types.peak_icv_preprocessing_transformation_parameters parameters,
                out PixelFormat outputPixelFormat);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Preprocessing_Transformation_Process(
            Image.Handle inputImageHandle, Backend.Types.peak_icv_preprocessing_transformation_parameters parameters,
            Image.Handle outputImageHandle);
    }
}