Add Short2

That was hard!

src/ImageSharp/Colors/PackedPixel/Short2.cs

@@ -0,0 +1,199 @@
+// <copyright file="Short2.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp
+{
+    using System;
+    using System.Numerics;
+
+    /// <summary>
+    /// Packed pixel type containing two 16-bit signed integer values.
+    /// </summary>
+    public struct Short2 : IPackedPixel<uint>, IEquatable<Short2>
+    {
+        /// <summary>
+        /// The maximum byte value.
+        /// </summary>
+        private static readonly Vector4 MaxBytes = new Vector4(255);
+
+        /// <summary>
+        /// The half the maximum byte value.
+        /// </summary>
+        private static readonly Vector2 Half = new Vector2(127);
+
+        /// <summary>
+        /// The vector value used for rounding.
+        /// </summary>
+        private static readonly Vector2 Round = new Vector2(.5F);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Short2"/> struct.
+        /// </summary>
+        /// <param name="vector">The vector containing the component values.</param>
+        public Short2(Vector2 vector)
+        {
+            this.PackedValue = Pack(vector.X, vector.Y);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Short2"/> struct.
+        /// </summary>
+        /// <param name="x">The x-component.</param>
+        /// <param name="y">The y-component.</param>
+        public Short2(float x, float y)
+        {
+            this.PackedValue = Pack(x, y);
+        }
+
+        /// <inheritdoc />
+        public uint PackedValue { get; set; }
+
+        /// <summary>
+        /// Compares two <see cref="Short2"/> objects for equality.
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="Short2"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="Short2"/> on the right side of the operand.
+        /// </param>
+        /// <returns>
+        /// True if the <paramref name="left"/> parameter is equal to the <paramref name="right"/> parameter; otherwise, false.
+        /// </returns>
+        public static bool operator ==(Short2 left, Short2 right)
+        {
+            return left.PackedValue == right.PackedValue;
+        }
+
+        /// <summary>
+        /// Compares two <see cref="Short2"/> objects for equality.
+        /// </summary>
+        /// <param name="left">
+        /// The <see cref="Short2"/> on the left side of the operand.
+        /// </param>
+        /// <param name="right">
+        /// The <see cref="Short2"/> on the right side of the operand.
+        /// </param>
+        /// <returns>
+        /// True if the <paramref name="left"/> parameter is not equal to the <paramref name="right"/> parameter; otherwise, false.
+        /// </returns>
+        public static bool operator !=(Short2 left, Short2 right)
+        {
+            return left.PackedValue != right.PackedValue;
+        }
+
+        /// <inheritdoc />
+        public void PackFromVector4(Vector4 vector)
+        {
+            this.PackedValue = Pack(vector.X, vector.Y);
+        }
+
+        /// <inheritdoc />
+        public Vector4 ToVector4()
+        {
+            return new Vector4((short)(this.PackedValue & 0xFFFF), (short)(this.PackedValue >> 0x10), 0, 1);
+        }
+
+        /// <inheritdoc />
+        public void PackFromBytes(byte x, byte y, byte z, byte w)
+        {
+            Vector2 vector = new Vector2(x, y) / 255;
+            vector *= 65534;
+            vector -= new Vector2(32767);
+            this.PackedValue = Pack(vector.X, vector.Y);
+        }
+
+        /// <inheritdoc />
+        public void ToBytes(byte[] bytes, int startIndex, ComponentOrder componentOrder)
+        {
+            Vector2 vector = this.ToVector2();
+            vector /= 65534;
+            vector *= 255;
+            vector += Half;
+            vector += Round;
+
+            switch (componentOrder)
+            {
+                case ComponentOrder.ZYX:
+                    bytes[startIndex] = 0;
+                    bytes[startIndex + 1] = (byte)(float)Math.Round(vector.Y);
+                    bytes[startIndex + 2] = (byte)(float)Math.Round(vector.X);
+                    break;
+                case ComponentOrder.ZYXW:
+                    bytes[startIndex] = 0;
+                    bytes[startIndex + 1] = (byte)(float)Math.Round(vector.Y);
+                    bytes[startIndex + 2] = (byte)(float)Math.Round(vector.X);
+                    bytes[startIndex + 3] = 255;
+                    break;
+                case ComponentOrder.XYZ:
+                    bytes[startIndex] = (byte)(float)Math.Round(vector.X);
+                    bytes[startIndex + 1] = (byte)(float)Math.Round(vector.Y);
+                    bytes[startIndex + 2] = 0;
+                    break;
+                case ComponentOrder.XYZW:
+                    bytes[startIndex] = (byte)(float)Math.Round(vector.X);
+                    bytes[startIndex + 1] = (byte)(float)Math.Round(vector.Y);
+                    bytes[startIndex + 2] = 0;
+                    bytes[startIndex + 3] = 255;
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        /// <summary>
+        /// Expands the packed representation into a <see cref="Vector2"/>.
+        /// The vector components are typically expanded in least to greatest significance order.
+        /// </summary>
+        /// <returns>The <see cref="Vector2"/>.</returns>
+        public Vector2 ToVector2()
+        {
+            return new Vector2((short)(this.PackedValue & 0xFFFF), (short)(this.PackedValue >> 0x10));
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+        {
+            return (obj is Short2) && this.Equals((Short2)obj);
+        }
+
+        /// <inheritdoc />
+        public bool Equals(Short2 other)
+        {
+            return this == other;
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            return this.PackedValue.GetHashCode();
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return this.PackedValue.ToString("x8");
+        }
+
+        /// <summary>
+        /// Packs the <see cref="float"/> components into a <see cref="uint"/>.
+        /// </summary>
+        /// <param name="x">The x-component</param>
+        /// <param name="y">The y-component</param>
+        /// <returns>The <see cref="uint"/> containing the packed values.</returns>
+        private static uint Pack(float x, float y)
+        {
+            // Largest two byte positive number 0xFFFF >> 1;
+            const float MaxPos = 0x7FFF;
+            const float MinNeg = ~(int)MaxPos;
+
+            // Clamp the value between min and max values
+            uint word2 = (uint)Math.Round(x.Clamp(MinNeg, MaxPos)) & 0xFFFF;
+            uint word1 = ((uint)Math.Round(y.Clamp(MinNeg, MaxPos)) & 0xFFFF) << 0x10;
+
+            return word2 | word1;
+        }
+    }
+}

tests/ImageSharp.Tests/Colors/PackedPixelTests.cs

@@ -705,6 +705,55 @@ namespace ImageSharp.Tests.Colors
             Assert.Equal(rgba, new byte[] { 20, 38, 76, 115 });
         }
 
+        [Fact]
+        public void Short2()
+        {
+            // Test the limits.
+            Assert.Equal((uint)0x0, new Short2(Vector2.Zero).PackedValue);
+            Assert.Equal((uint)0x7FFF7FFF, new Short2(Vector2.One * 0x7FFF).PackedValue);
+            Assert.Equal(0x80008000, new Short2(Vector2.One * -0x8000).PackedValue);
+
+            // Test ToVector2.
+            Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 0x7FFF).ToVector2()));
+            Assert.True(Equal(Vector2.Zero, new Short2(Vector2.Zero).ToVector2()));
+            Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -0x8000).ToVector2()));
+            Assert.True(Equal(Vector2.UnitX * 0x7FFF, new Short2(Vector2.UnitX * 0x7FFF).ToVector2()));
+            Assert.True(Equal(Vector2.UnitY * 0x7FFF, new Short2(Vector2.UnitY * 0x7FFF).ToVector2()));
+
+            // Test clamping.
+            Assert.True(Equal(Vector2.One * 0x7FFF, new Short2(Vector2.One * 1234567.0f).ToVector2()));
+            Assert.True(Equal(Vector2.One * -0x8000, new Short2(Vector2.One * -1234567.0f).ToVector2()));
+
+            // Test ToVector4.
+            Assert.True(Equal(new Vector4(0x7FFF, 0x7FFF, 0, 1), (new Short2(Vector2.One * 0x7FFF)).ToVector4()));
+            Assert.True(Equal(new Vector4(0, 0, 0, 1), (new Short2(Vector2.Zero)).ToVector4()));
+            Assert.True(Equal(new Vector4(-0x8000, -0x8000, 0, 1), (new Short2(Vector2.One * -0x8000)).ToVector4()));
+
+            // Test ordering
+            float x = 0x2db1;
+            float y = 0x361d;
+            Assert.Equal((uint)0x361d2db1, new Short2(x, y).PackedValue);
+            x = 127.5f;
+            y = -5.3f;
+            Assert.Equal(4294639744, new Short2(x, y).PackedValue);
+
+            byte[] rgb = new byte[3];
+            byte[] rgba = new byte[4];
+            byte[] bgr = new byte[3];
+            byte[] bgra = new byte[4];
+
+            new Short2(x, y).ToBytes(rgb, 0, ComponentOrder.XYZ);
+
+            new Short2(x, y).ToBytes(rgba, 0, ComponentOrder.XYZW);
+
+            new Short2(x, y).ToBytes(bgr, 0, ComponentOrder.ZYX);
+
+            new Short2(x, y).ToBytes(bgra, 0, ComponentOrder.ZYXW);
+
+            Short2 r = new Short2();
+            r.ToBytes(rgba, 0, ComponentOrder.XYZW);
+        }
+
         // Comparison helpers with small tolerance to allow for floating point rounding during computations.
         public static bool Equal(float a, float b)
         {

tests/ImageSharp.Tests/Formats/GeneralFormatTests.cs

@@ -70,6 +70,8 @@ namespace ImageSharp.Tests
                 // Image<NormalizedByte4, uint> image = file.CreateImage().To<NormalizedByte4, uint>(v => (2F * v) - Vector4.One);
                 // Image<NormalizedShort2, uint> image = file.CreateImage().To<NormalizedShort2, uint>(v => (2F * v) - Vector4.One);
                 // Image<NormalizedShort4, ulong> image = file.CreateImage().To<NormalizedShort4, ulong>(v => (2F * v) - Vector4.One);
+                // Image<Short2, uint> image = file.CreateImage().To<Short2, uint>(v => (65534 * v) - new Vector4(32767));
+
                 using (FileStream output = File.OpenWrite($"{path}/{file.FileName}"))
                 {
                     image.Save(output);