implemented the rest of pixel conversion methods

src/ImageSharp/PixelFormats/Bgr24.cs

@@ -71,27 +71,35 @@
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromRgba32(Rgba32 source)
         {
-            throw new NotImplementedException();
+            this = source.Bgr;
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromVector4(Vector4 vector)
         {
-            throw new NotImplementedException();
+            var rgba = default(Rgba32);
+            rgba.PackFromVector4(vector);
+            this.PackFromRgba32(rgba);
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector4 ToVector4()
         {
-            throw new NotImplementedException();
+            return new Rgba32(this.R, this.G, this.B, 255).ToVector4();
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
         }
 
         /// <inheritdoc/>
@@ -107,13 +115,16 @@
         /// <inheritdoc/>
         public void ToBgr24(ref Bgr24 dest)
         {
-            throw new NotImplementedException();
+            dest = this;
         }
 
         /// <inheritdoc/>
         public void ToBgra32(ref Bgra32 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
+            dest.A = 255;
         }
     }
 }

src/ImageSharp/PixelFormats/Bgra32.cs

@@ -1,12 +1,10 @@
-namespace ImageSharp
+namespace ImageSharp.PixelFormats
 {
     using System;
     using System.Numerics;
     using System.Runtime.CompilerServices;
     using System.Runtime.InteropServices;
 
-    using ImageSharp.PixelFormats;
-
     /// <summary>
     /// Packed pixel type containing four 8-bit unsigned normalized values ranging from 0 to 255.
     /// The color components are stored in blue, green, red, and alpha order.
@@ -116,45 +114,62 @@
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromVector4(Vector4 vector)
         {
-            throw new NotImplementedException();
+            var rgba = default(Rgba32);
+            rgba.PackFromVector4(vector);
+            this.PackFromRgba32(rgba);
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector4 ToVector4()
         {
-            throw new NotImplementedException();
+            return this.ToRgba32().ToVector4();
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromRgba32(Rgba32 source)
         {
-            throw new NotImplementedException();
+            this.R = source.R;
+            this.G = source.G;
+            this.B = source.B;
+            this.A = source.A;
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgba32(ref Rgba32 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
+            dest.A = this.A;
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToBgr24(ref Bgr24 dest)
         {
-            throw new NotImplementedException();
+            dest = Unsafe.As<Bgra32, Bgr24>(ref this);
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToBgra32(ref Bgra32 dest)
         {
-            throw new NotImplementedException();
+            dest = this;
         }
 
         /// <summary>

src/ImageSharp/PixelFormats/Rgb24.cs

@@ -71,45 +71,57 @@ namespace ImageSharp.PixelFormats
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromRgba32(Rgba32 source)
         {
-            throw new NotImplementedException();
+            this = Unsafe.As<Rgba32, Rgb24>(ref source);
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void PackFromVector4(Vector4 vector)
         {
-            throw new NotImplementedException();
+            var rgba = default(Rgba32);
+            rgba.PackFromVector4(vector);
+            this.PackFromRgba32(rgba);
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector4 ToVector4()
         {
-            throw new NotImplementedException();
+            return new Rgba32(this.R, this.G, this.B, 255).ToVector4();
         }
 
         /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ToRgb24(ref Rgb24 dest)
         {
-            throw new NotImplementedException();
+            dest = this;
         }
 
         /// <inheritdoc/>
         public void ToRgba32(ref Rgba32 dest)
         {
-            throw new NotImplementedException();
+            dest.Rgb = this;
+            dest.A = 255;
         }
 
         /// <inheritdoc/>
         public void ToBgr24(ref Bgr24 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
         }
 
         /// <inheritdoc/>
         public void ToBgra32(ref Bgra32 dest)
         {
-            throw new NotImplementedException();
+            dest.R = this.R;
+            dest.G = this.G;
+            dest.B = this.B;
+            dest.A = 255;
         }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Bgr24Tests.cs

@@ -1,6 +1,8 @@
 // ReSharper disable InconsistentNaming
 namespace ImageSharp.Tests
 {
+    using System.Numerics;
+
     using ImageSharp.PixelFormats;
 
     using Xunit;
@@ -36,8 +38,8 @@ namespace ImageSharp.Tests
         [MemberData(nameof(ColorData))]
         public void Equals_WhenTrue(byte r, byte g, byte b)
         {
-            var x = new Rgb24(r, g, b);
+            var x = new Bgr24(r, g, b);
-            var y = new Rgb24(r, g, b);
+            var y = new Bgr24(r, g, b);
 
             Assert.True(x.Equals(y));
             Assert.True(x.Equals((object)y));
@@ -50,11 +52,92 @@ namespace ImageSharp.Tests
         [InlineData(1, 255, 0, 0, 255, 0)]
         public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
         {
-            var a = new Rgb24(r1, g1, b1);
+            var a = new Bgr24(r1, g1, b1);
-            var b = new Rgb24(r2, g2, b2);
+            var b = new Bgr24(r2, g2, b2);
 
             Assert.False(a.Equals(b));
             Assert.False(a.Equals((object)b));
         }
+
+
+        [Fact]
+        public void PackFromRgba32()
+        {
+            var rgb = default(Bgr24);
+            rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4));
+
+            Assert.Equal(1, rgb.R);
+            Assert.Equal(2, rgb.G);
+            Assert.Equal(3, rgb.B);
+        }
+
+        private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+            r / 255f,
+            g / 255f,
+            b / 255f,
+            a / 255f);
+
+        [Fact]
+        public void PackFromVector4()
+        {
+            var rgb = default(Bgr24);
+            rgb.PackFromVector4(Vec(1, 2, 3, 4));
+
+            Assert.Equal(1, rgb.R);
+            Assert.Equal(2, rgb.G);
+            Assert.Equal(3, rgb.B);
+        }
+
+        [Fact]
+        public void ToVector4()
+        {
+            var rgb = new Bgr24(1, 2, 3);
+
+            Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
+        }
+
+        [Fact]
+        public void ToRgb24()
+        {
+            var rgb = new Bgr24(1, 2, 3);
+            var dest = default(Rgb24);
+
+            rgb.ToRgb24(ref dest);
+
+            Assert.Equal(new Rgb24(1, 2, 3), dest);
+        }
+
+        [Fact]
+        public void ToRgba32()
+        {
+            var rgb = new Bgr24(1, 2, 3);
+            var rgba = default(Rgba32);
+
+            rgb.ToRgba32(ref rgba);
+
+            Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
+        }
+
+        [Fact]
+        public void ToBgr24()
+        {
+            var rgb = new Bgr24(1, 2, 3);
+            var bgr = default(Bgr24);
+
+            rgb.ToBgr24(ref bgr);
+
+            Assert.Equal(new Bgr24(1, 2, 3), bgr);
+        }
+
+        [Fact]
+        public void ToBgra32()
+        {
+            var rgb = new Bgr24(1, 2, 3);
+            var bgra = default(Bgra32);
+
+            rgb.ToBgra32(ref bgra);
+
+            Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Bgra32Tests.cs

@@ -1,6 +1,8 @@
 // ReSharper disable InconsistentNaming
 namespace ImageSharp.Tests
 {
+    using System.Numerics;
+
     using ImageSharp.PixelFormats;
 
     using Xunit;
@@ -62,5 +64,87 @@ namespace ImageSharp.Tests
             Assert.False(x.Equals(y));
             Assert.False(x.Equals((object)y));
         }
+
+
+        [Fact]
+        public void PackFromRgba32()
+        {
+            var rgb = default(Rgb24);
+            rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4));
+
+            Assert.Equal(1, rgb.R);
+            Assert.Equal(2, rgb.G);
+            Assert.Equal(3, rgb.B);
+        }
+
+        private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+            r / 255f,
+            g / 255f,
+            b / 255f,
+            a / 255f);
+
+        [Fact]
+        public void PackFromVector4()
+        {
+            var c = default(Bgra32);
+            c.PackFromVector4(Vec(1, 2, 3, 4));
+
+            Assert.Equal(1, c.R);
+            Assert.Equal(2, c.G);
+            Assert.Equal(3, c.B);
+            Assert.Equal(4, c.A);
+        }
+
+        [Fact]
+        public void ToVector4()
+        {
+            var rgb = new Bgra32(1, 2, 3, 4);
+
+            Assert.Equal(Vec(1, 2, 3, 4), rgb.ToVector4());
+        }
+
+        [Fact]
+        public void ToRgb24()
+        {
+            var c = new Bgra32(1, 2, 3, 4);
+            var dest = default(Rgb24);
+
+            c.ToRgb24(ref dest);
+
+            Assert.Equal(new Rgb24(1, 2, 3), dest);
+        }
+
+        [Fact]
+        public void ToRgba32()
+        {
+            var c = new Bgra32(1, 2, 3, 4);
+            var rgba = default(Rgba32);
+
+            c.ToRgba32(ref rgba);
+
+            Assert.Equal(new Rgba32(1, 2, 3, 4), rgba);
+        }
+
+        [Fact]
+        public void ToBgr24()
+        {
+            var rgb = new Bgra32(1, 2, 3, 4);
+            var bgr = default(Bgr24);
+
+            rgb.ToBgr24(ref bgr);
+
+            Assert.Equal(new Bgr24(1, 2, 3), bgr);
+        }
+
+        [Fact]
+        public void ToBgra32()
+        {
+            var rgb = new Bgra32(1, 2, 3, 4);
+            var bgra = default(Bgra32);
+
+            rgb.ToBgra32(ref bgra);
+
+            Assert.Equal(new Bgra32(1, 2, 3, 4), bgra);
+        }
     }
 }

tests/ImageSharp.Tests/PixelFormats/Rgb24Tests.cs

@@ -1,6 +1,9 @@
 // ReSharper disable InconsistentNaming
 namespace ImageSharp.Tests
 {
+    using System;
+    using System.Numerics;
+
     using ImageSharp.PixelFormats;
 
     using Xunit;
@@ -32,34 +35,109 @@ namespace ImageSharp.Tests
             Assert.Equal(3, ptr[2]);
         }
 
-        public class Equality
+        [Theory]
+        [MemberData(nameof(ColorData))]
+        public void Equals_WhenTrue(byte r, byte g, byte b)
+        {
+            var x = new Rgb24(r, g, b);
+            var y = new Rgb24(r, g, b);
+
+            Assert.True(x.Equals(y));
+            Assert.True(x.Equals((object)y));
+            Assert.Equal(x.GetHashCode(), y.GetHashCode());
+        }
+
+        [Theory]
+        [InlineData(1, 2, 3, 1, 2, 4)]
+        [InlineData(0, 255, 0, 0, 244, 0)]
+        [InlineData(1, 255, 0, 0, 255, 0)]
+        public void Equals_WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
+        {
+            var a = new Rgb24(r1, g1, b1);
+            var b = new Rgb24(r2, g2, b2);
+
+            Assert.False(a.Equals(b));
+            Assert.False(a.Equals((object)b));
+        }
+        
+        [Fact]
+        public void PackFromRgba32()
+        {
+            var rgb = default(Rgb24);
+            rgb.PackFromRgba32(new Rgba32(1, 2, 3, 4));
+
+            Assert.Equal(1, rgb.R);
+            Assert.Equal(2, rgb.G);
+            Assert.Equal(3, rgb.B);
+        }
+
+        private static Vector4 Vec(byte r, byte g, byte b, byte a = 255) => new Vector4(
+            r / 255f,
+            g / 255f,
+            b / 255f,
+            a / 255f);
+
+        [Fact]
+        public void PackFromVector4()
+        {
+            var rgb = default(Rgb24);
+            rgb.PackFromVector4(Vec(1, 2, 3, 4));
+
+            Assert.Equal(1, rgb.R);
+            Assert.Equal(2, rgb.G);
+            Assert.Equal(3, rgb.B);
+        }
+
+        [Fact]
+        public void ToVector4()
+        {
+            var rgb = new Rgb24(1, 2, 3);
+
+            Assert.Equal(Vec(1, 2, 3), rgb.ToVector4());
+        }
+
+        [Fact]
+        public void ToRgb24()
+        {
+            var rgb = new Rgb24(1, 2, 3);
+            var dest = default(Rgb24);
+
+            rgb.ToRgb24(ref dest);
+
+            Assert.Equal(rgb, dest);
+        }
+
+        [Fact]
+        public void ToRgba32()
+        {
+            var rgb = new Rgb24(1, 2, 3);
+            var rgba = default(Rgba32);
+
+            rgb.ToRgba32(ref rgba);
+
+            Assert.Equal(new Rgba32(1, 2, 3, 255), rgba);
+        }
+
+        [Fact]
+        public void ToBgr24()
+        {
+            var rgb = new Rgb24(1, 2, 3);
+            var bgr = default(Bgr24);
+
+            rgb.ToBgr24(ref bgr);
+
+            Assert.Equal(new Bgr24(1, 2, 3), bgr);
+        }
+
+        [Fact]
+        public void ToBgra32()
         {
-            public static TheoryData<byte, byte, byte> ColorData = Rgb24Tests.ColorData;
+            var rgb = new Rgb24(1, 2, 3);
-
+            var bgra = default(Bgra32);
-            [Theory]
+
-            [MemberData(nameof(ColorData))]
+            rgb.ToBgra32(ref bgra);
-            public void WhenTrue(byte r, byte g, byte b)
+
-            {
+            Assert.Equal(new Bgra32(1, 2, 3, 255), bgra);
-                var x = new Rgb24(r, g, b);
-                var y = new Rgb24(r, g, b);
-
-                Assert.True(x.Equals(y));
-                Assert.True(x.Equals((object)y));
-                Assert.Equal(x.GetHashCode(), y.GetHashCode());
-            }
-
-            [Theory]
-            [InlineData(1, 2, 3, 1, 2, 4)]
-            [InlineData(0, 255, 0, 0, 244, 0)]
-            [InlineData(1, 255, 0, 0, 255, 0)]
-            public void WhenFalse(byte r1, byte g1, byte b1, byte r2, byte g2, byte b2)
-            {
-                var a = new Rgb24(r1, g1, b1);
-                var b = new Rgb24(r2, g2, b2);
-
-                Assert.False(a.Equals(b));
-                Assert.False(a.Equals((object)b));
-            }
         }
     }
 }

tests/ImageSharp.Tests/TestUtilities/PixelTypes.cs

@@ -52,6 +52,12 @@ namespace ImageSharp.Tests
 
         Short4 = 1 << 17,
 
+        Rgb24 = 18,
+
+        Bgr24 = 19,
+
+        Bgra32 = 20,
+
         // TODO: Add multi-flag entries by rules defined in PackedPixelConverterHelper
 
         // "All" is handled as a separate, individual case instead of using bitwise OR