Size.cs

Go to the documentation of this file.

using IDSImaging.Peak.Common.Internal;
using IDSImaging.Peak.Common.Types.Geometry.Detail;
 
namespace IDSImaging.Peak.Common.Types.Geometry
{
    namespace Detail
    {
 
        public class SizeT<T>
        {
            public SizeT(T width, T height)
            {
                Width = width;
                Height = height;
            }
 
            public SizeT<T> Transposed() => new SizeT<T>(Height, Width);
 
            public T Width { get; }
 
            public T Height { get; }
 
            public override bool Equals(object? obj)
            {
                if (obj is null)
                {
                    return false;
                }
 
                if (ReferenceEquals(this, obj))
                {
                    return true;
                }
 
                if (obj is not SizeT<T> other)
                {
                    return false;
                }
 
                return Equals(other);
            }
 
            protected bool Equals(SizeT<T> other)
            {
                return Width != null && Width.Equals(other.Width) && Height != null && Height.Equals(other.Height);
            }
 
            public override int GetHashCode()
            {
                return (Width, Height).GetHashCode();
            }
 
            public override string ToString()
            {
                return Formatting.Invariant(
                    $"{GetType().Name}{{ {nameof(Width)} = {Width}, {nameof(Height)} = {Height} }}");
            }
        }
    }
 
 
    public class Size : SizeT<uint>
    {
        public Size()
            : base(0, 0)
        {
        }
 
        public Size(uint width, uint height)
            : base(width, height)
        {
        }
 
        private Size(SizeT<uint> size)
            : base(size.Width, size.Height)
        {
        }
 
        public new Size Transposed() => new (base.Transposed());
    }
 
 
    public class SizeF : SizeT<float>
    {
        public SizeF()
            : base(0.0f, 0.0f)
        {
        }
 
        public SizeF(float width, float height)
            : base(width, height)
        {
        }
 
        private SizeF(SizeT<float> size)
            : base(size.Width, size.Height)
        {
        }
 
        public new SizeF Transposed() => new (base.Transposed());
    }
}