PixelFormatInfo.cs

Go to the documentation of this file.

using System;
using System.Linq;
using IDSImaging.Peak.Common.Exceptions;
using IDSImaging.Peak.Common.Internal;
using IDSImaging.Peak.Common.Types.Geometry;
using IDSImaging.Peak.Common.Types.Internal;
 
namespace IDSImaging.Peak.Common.Types;
 
 
public class PixelFormatInfo
{
    private readonly PixelFormatDefinition _pixelFormatInfo;
 
    public PixelFormatInfo(PixelFormat pixelFormat)
    {
        _pixelFormatInfo = PixelFormatDefinition.FormatMap[pixelFormat];
    }
 
    public PixelFormatInfo(string name)
    {
        _pixelFormatInfo = PixelFormatDefinition.NameMap[name];
    }
 
    public uint StorageBitsPerPixel => _pixelFormatInfo.StorageBitsPerPixel;
 
    public uint StorageBitsPerChannel
    {
        // TODO: is this correct?
        get
        {
            switch (PixelFormat)
            {
                case PixelFormat.YUV422_8_UYVY:
                case PixelFormat.YUV420_8_YY_UV_SemiplanarIDS:
                case PixelFormat.YUV420_8_YY_VU_SemiplanarIDS:
                {
                    return StorageBitsPerPixel;
                }
 
                default:
                    return StorageBitsPerPixel / NumberOfChannels;
            }
        }
    }
 
    public uint AllocatedBitsPerPixel => _pixelFormatInfo.AllocatedBitsPerPixel;
 
    public string Name => _pixelFormatInfo.Name;
 
    public Channel[] Channels => _pixelFormatInfo.Channels;
 
    public bool HasIntensityChannel => HasChannel(Channel.Intensity);
 
    public uint NumberOfChannels => (uint) Channels.Length;
 
    public bool IsSingleChannel => NumberOfChannels == 1;
 
    public PixelFormat PixelFormat => _pixelFormatInfo.Format;
 
    public bool IsPacked => _pixelFormatInfo.IsPacked;
 
    public bool IsFloat => _pixelFormatInfo.IsFloat;
 
    public bool IsInterleaved => _pixelFormatInfo.IsInterleaved;
 
    public PixelFormat UnpackedPixelFormat => _pixelFormatInfo.UnpackedFormat;
 
    public T MinimumValuePerChannel<T>()
    {
        if (typeof(T) == typeof(float) && IsFloat)
        {
            return (T) (object) float.MinValue;
        }
 
        if (typeof(T) == typeof(int) && !IsFloat)
        {
            return (T) (object) 0;
        }
 
        var expectedType = IsFloat ? "float" : "int";
        throw new CommonInvalidParameterException(
            $"Minimum value type {expectedType} of format {Name} does not match requested type {typeof(T).Name}");
    }
 
    public int MinimumValuePerChannel()
    {
        return MinimumValuePerChannel<int>();
    }
 
    public T MaximumValuePerChannel<T>()
    {
        if (typeof(T) == typeof(float) && IsFloat)
        {
            return (T) (object) float.MaxValue;
        }
 
        if (typeof(T) == typeof(int) && !IsFloat)
        {
            return (T) (object) (int) (Math.Pow(2, StorageBitsPerChannel) - 1);
        }
 
        var expectedType = IsFloat ? "float" : "int";
        throw new CommonInvalidParameterException(
            $"Maximum value type {expectedType} of format {Name} does not match requested type {typeof(T).Name}");
    }
 
    public int MaximumValuePerChannel()
    {
        return MaximumValuePerChannel<int>();
    }
 
    public int GetChannelIndex(Channel channel)
    {
        return Array.IndexOf(Channels, channel);
    }
 
    public bool HasChannel(Channel channel)
    {
        return Channels.Contains(channel);
    }
 
    public ulong GetSizeInBytes(Size size)
    {
        return (size.Height * size.Width * AllocatedBitsPerPixel + 7) / 8;
    }
 
    public override bool Equals(object? obj)
    {
        if (obj is null)
        {
            return false;
        }
 
        if (ReferenceEquals(this, obj))
        {
            return true;
        }
 
        if (obj is not PixelFormatInfo other)
        {
            return false;
        }
 
        return Equals(other);
    }
 
    protected bool Equals(PixelFormatInfo other)
    {
        return PixelFormat.Equals(other.PixelFormat);
    }
 
    public override int GetHashCode()
    {
        return PixelFormat.GetHashCode();
    }
 
    public override string ToString()
    {
        return Formatting.Invariant($"{GetType().Name}{{ {nameof(PixelFormat)} = {PixelFormat} }}");
    }
}