From db878e8596b95b99790408a334e18162f44cc1bb Mon Sep 17 00:00:00 2001
From: Martin <mautner@vrvis.at>
Date: Fri, 21 Jun 2024 13:13:20 +0200
Subject: [PATCH] [Tests] Add tests for PixImage type conversions

---
 .../Images/PixImageTests.cs                   | 311 ++++++++++++++----
 .../Images/PixVolumeTests.cs                  | 299 +++++++++++++----
 2 files changed, 478 insertions(+), 132 deletions(-)

diff --git a/src/Tests/Aardvark.Base.Tests/Images/PixImageTests.cs b/src/Tests/Aardvark.Base.Tests/Images/PixImageTests.cs
index 1624182b..c26dce65 100644
--- a/src/Tests/Aardvark.Base.Tests/Images/PixImageTests.cs
+++ b/src/Tests/Aardvark.Base.Tests/Images/PixImageTests.cs
@@ -1,6 +1,8 @@
 using NUnit.Framework;
 using System;
+using System.Collections.Generic;
 using Aardvark.Base;
+using float16 = Aardvark.Base.Half;
 
 namespace Aardvark.Tests.Images
 {
@@ -91,29 +93,41 @@ public void MipMapCreate57x11()
 
         #region Format Conversions
 
-        private static byte[] GetArray(PixImage<byte> pi, V2l coord)
+        internal static readonly Dictionary<Type, Func<RandomSystem, object>> s_randomValues = new ()
         {
-            var arr = new byte[pi.ChannelCount];
+            { typeof(byte), rnd => (byte)rnd.UniformInt(256) },
+            { typeof(ushort), rnd => (ushort)rnd.UniformInt(Col.Info<ushort>.MaxValue + 1) },
+            { typeof(uint), rnd => rnd.UniformUInt() },
+            { typeof(float16), rnd => (float16)rnd.UniformFloat() },
+            { typeof(float), rnd => rnd.UniformFloat() },
+            { typeof(double), rnd => rnd.UniformDouble() },
+        };
+
+        private static T[] GetArray<T>(PixImage<T> pi, V2l coord)
+        {
+            var arr = new T[pi.ChannelCount];
             arr.SetByIndex(i => pi.Volume[new V3l(coord, i)]);
             return arr;
         }
 
-        private static T GetColor<T>(PixImage<byte> pi, V2l coord)
-            => pi.GetMatrix<T>()[coord];
+        private static Tc GetColor<T, Tc>(PixImage<T> pi, V2l coord)
+            => pi.GetMatrix<Tc>()[coord];
 
-        private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat,
-                                                     Func<PixImage<byte>, V2l, T1> getInput,
-                                                     Func<PixImage<byte>, V2l, T2> getActual,
-                                                     Func<T1, T2> expectedConversion,
-                                                     bool subImageWindow)
+        private static void FormatConversion<T1, T2, Tc1, Tc2>(Col.Format sourceFormat, Col.Format targetFormat,
+                                                               Func<PixImage<T1>, V2l, Tc1> getInput,
+                                                               Func<PixImage<T2>, V2l, Tc2> getActual,
+                                                               Func<Tc1, Tc2> expectedConversion,
+                                                               bool subImageWindow)
         {
-            var src = new PixImage<byte>(sourceFormat, 43, 81);
-            src.Volume.Data.SetByIndex((_) => (byte)rnd.UniformInt(256));
+
+            var getRandom = s_randomValues[typeof(T1)];
+            var src = new PixImage<T1>(sourceFormat, 43, 81);
+            src.Volume.Data.SetByIndex((_) => (T1)getRandom(rnd));
 
             if (subImageWindow)
-                src = new PixImage<byte>(sourceFormat, src.Volume.SubImageWindow(2, 3, 33, 67));
+                src = new PixImage<T1>(sourceFormat, src.Volume.SubImageWindow(2, 3, 33, 67));
 
-            var dst = src.ToFormat(targetFormat);
+            var dst = new PixImage<T2>(targetFormat, src);
 
             src.GetChannel(0L).ForeachCoord((coord) =>
             {
@@ -123,47 +137,47 @@ private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format
             });
         }
 
-        private static void FormatConversionArrays(Col.Format sourceFormat, Col.Format targetFormat, Func<byte[], byte[]> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetArray, GetArray, expectedConversion, subImageWindow);
+        private static void FormatConversionArrays<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1[], T2[]> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, T1[], T2[]>(sourceFormat, targetFormat, GetArray, GetArray, expectedConversion, subImageWindow);
 
-        private static void FormatConversionFromArray<T>(Col.Format sourceFormat, Col.Format targetFormat, Func<byte[], T> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetArray, GetColor<T>, expectedConversion, subImageWindow);
+        private static void FormatConversionFromArray<T1, T2, Tc2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1[], Tc2> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, T1[], Tc2>(sourceFormat, targetFormat, GetArray, GetColor<T2, Tc2>, expectedConversion, subImageWindow);
 
-        private static void FormatConversionToArray<T>(Col.Format sourceFormat, Col.Format targetFormat, Func<T, byte[]> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetColor<T>, GetArray, expectedConversion, subImageWindow);
+        private static void FormatConversionToArray<T1, T2, Tc1>(Col.Format sourceFormat, Col.Format targetFormat, Func<Tc1, T2[]> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, Tc1, T2[]>(sourceFormat, targetFormat, GetColor<T1, Tc1>, GetArray, expectedConversion, subImageWindow);
 
-        private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1, T2> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetColor<T1>, GetColor<T2>, expectedConversion, subImageWindow);
+        private static void FormatConversion<T1, T2, Tc1, Tc2>(Col.Format sourceFormat, Col.Format targetFormat, Func<Tc1, Tc2> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, Tc1, Tc2>(sourceFormat, targetFormat, GetColor<T1, Tc1>, GetColor<T2, Tc2>, expectedConversion, subImageWindow);
 
         #region From Gray
 
         [Test]
         public void FormatConversionGrayToGrayAlpha()
-            => FormatConversionToArray<byte>(Col.Format.Gray, Col.Format.GrayAlpha, gray => new byte[] { gray, 255 });
+            => FormatConversionToArray<byte, byte, byte>(Col.Format.Gray, Col.Format.GrayAlpha, gray => new byte[] { gray, 255 });
 
         [Test]
         public void FormatConversionGrayToAlpha()
-            => FormatConversion<byte, byte>(Col.Format.Gray, Col.Format.Alpha, gray => 255);
+            => FormatConversion<byte, byte, byte, byte>(Col.Format.Gray, Col.Format.Alpha, gray => 255);
 
         [Test]
         public void FormatConversionGrayToRGB()
-            => FormatConversion<byte, C3b>(Col.Format.Gray, Col.Format.RGB, gray => new C3b(gray));
+            => FormatConversion<byte, byte, byte, C3b>(Col.Format.Gray, Col.Format.RGB, gray => new C3b(gray));
 
         [Test]
         public void FormatConversionGrayToBGR()
-            => FormatConversion<byte, C3b>(Col.Format.Gray, Col.Format.BGR, gray => new C3b(gray));
+            => FormatConversion<byte, byte, byte, C3b>(Col.Format.Gray, Col.Format.BGR, gray => new C3b(gray));
 
         [Test]
         public void FormatConversionGrayToRGBA()
-            => FormatConversion<byte, C4b>(Col.Format.Gray, Col.Format.RGBA, gray => new C4b(gray));
+            => FormatConversion<byte, byte, byte, C4b>(Col.Format.Gray, Col.Format.RGBA, gray => new C4b(gray));
 
         [Test]
         public void FormatConversionGrayToBGRA()
-            => FormatConversion<byte, C4b>(Col.Format.Gray, Col.Format.BGRA, gray => new C4b(gray));
+            => FormatConversion<byte, byte, byte, C4b>(Col.Format.Gray, Col.Format.BGRA, gray => new C4b(gray));
 
         [Test]
         public void FormatConversionGrayToRG()
-            => FormatConversionToArray<byte>(Col.Format.Gray, Col.Format.RG, gray => new byte[] { gray, gray });
+            => FormatConversionToArray<byte, byte, byte>(Col.Format.Gray, Col.Format.RG, gray => new byte[] { gray, gray });
 
         #endregion
 
@@ -171,31 +185,31 @@ public void FormatConversionGrayToRG()
 
         [Test]
         public void FormatConversionGrayAlphaToGray()
-            => FormatConversionFromArray<byte>(Col.Format.GrayAlpha, Col.Format.Gray, gray => gray[0]);
+            => FormatConversionFromArray<byte, byte, byte>(Col.Format.GrayAlpha, Col.Format.Gray, gray => gray[0]);
 
         [Test]
         public void FormatConversionGrayAlphaToAlpha()
-            => FormatConversionFromArray<byte>(Col.Format.GrayAlpha, Col.Format.Alpha, gray => gray[1]);
+            => FormatConversionFromArray<byte, byte, byte>(Col.Format.GrayAlpha, Col.Format.Alpha, gray => gray[1]);
 
         [Test]
         public void FormatConversionGrayAlphaToRGB()
-            => FormatConversionFromArray<C3b>(Col.Format.GrayAlpha, Col.Format.RGB, gray => new C3b(gray[0]));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.GrayAlpha, Col.Format.RGB, gray => new C3b(gray[0]));
 
         [Test]
         public void FormatConversionGrayAlphaToBGR()
-            => FormatConversionFromArray<C3b>(Col.Format.GrayAlpha, Col.Format.BGR, gray => new C3b(gray[0]));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.GrayAlpha, Col.Format.BGR, gray => new C3b(gray[0]));
 
         [Test]
         public void FormatConversionGrayAlphaToRGBA()
-            => FormatConversionFromArray<C4b>(Col.Format.GrayAlpha, Col.Format.RGBA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.GrayAlpha, Col.Format.RGBA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
 
         [Test]
         public void FormatConversionGrayAlphaToBGRA()
-            => FormatConversionFromArray<C4b>(Col.Format.GrayAlpha, Col.Format.BGRA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.GrayAlpha, Col.Format.BGRA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
 
         [Test]
         public void FormatConversionGrayAlphaToRG()
-            => FormatConversionArrays(Col.Format.GrayAlpha, Col.Format.RG, gray => new byte[] { gray[0], gray[0] });
+            => FormatConversionArrays<byte, byte>(Col.Format.GrayAlpha, Col.Format.RG, gray => new byte[] { gray[0], gray[0] });
 
         #endregion
 
@@ -203,39 +217,204 @@ public void FormatConversionGrayAlphaToRG()
 
         [Test]
         public void FormatConversionRGBAToRGBA()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, (color => color));
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, (c => c));
 
         [Test]
         public void FormatConversionRGBAToRGBAWindow()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, (color => color), true);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, (c => c), true);
 
         [Test]
         public void FormatConversionRGBAToBGRA()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, color => color);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c);
 
         [Test]
         public void FormatConversionRGBAToBGRAWindow()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, (color => color), true);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, (c => c), true);
 
         [Test]
         public void FormatConversionRGBAToRGB()
-            => FormatConversion<C4b, C3b>(Col.Format.RGBA, Col.Format.RGB, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.RGBA, Col.Format.RGB, c => c.RGB);
 
         [Test]
         public void FormatConversionRGBAToBGR()
-            => FormatConversion<C4b, C3b>(Col.Format.RGBA, Col.Format.BGR, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.RGBA, Col.Format.BGR, c => c.RGB);
 
         [Test]
         public void FormatConversionRGBAToGray()
-            => FormatConversion<C4b, byte>(Col.Format.RGBA, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C4b, byte>(Col.Format.RGBA, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionRGBAToGrayAlpha()
-            => FormatConversionToArray<C4b>(Col.Format.RGBA, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), color.A });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.RGBA, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), c.A });
 
         [Test]
         public void FormatConversionRGBAToRG()
-            => FormatConversionToArray<C4b>(Col.Format.RGBA, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.RGBA, Col.Format.RG, c => new byte[] { c.R, c.G });
+
+        #region Byte to BGRA (other types)
+
+        [Test]
+        public void TypeConversionByteToUShort()
+            => FormatConversion<byte, ushort, C4b, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionByteToUInt()
+            => FormatConversion<byte, uint, C4b, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionByteToHalf()
+            => FormatConversionToArray<byte, float16, C4b>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.ByteToHalf(), c.G.ByteToHalf(), c.R.ByteToHalf(), c.A.ByteToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionByteToFloat()
+            => FormatConversion<byte, float, C4b, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionByteToDouble()
+            => FormatConversion<byte, double, C4b, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region UShort to BGRA (other types)
+
+        [Test]
+        public void TypeConversionUShortToByte()
+            => FormatConversion<ushort, byte, C4us, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionUShortToUInt()
+            => FormatConversion<ushort, uint, C4us, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionUShortToHalf()
+            => FormatConversionToArray<ushort, float16, C4us>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.UShortToHalf(), c.G.UShortToHalf(), c.R.UShortToHalf(), c.A.UShortToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionUShortToFloat()
+            => FormatConversion<ushort, float, C4us, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionUShortToDouble()
+            => FormatConversion<ushort, double, C4us, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region UInt to BGRA (other types)
+
+        [Test]
+        public void TypeConversionUIntToByte()
+            => FormatConversion<uint, byte, C4ui, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionUIntToUShort()
+            => FormatConversion<uint, ushort, C4ui, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionUIntToHalf()
+            => FormatConversionToArray<uint, float16, C4ui>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.UIntToHalf(), c.G.UIntToHalf(), c.R.UIntToHalf(), c.A.UIntToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionUIntToFloat()
+            => FormatConversion<uint, float, C4ui, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionUIntToDouble()
+            => FormatConversion<uint, double, C4ui, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region Half to BGRA (other types)
+
+        [Test]
+        public void TypeConversionHalfToByte()
+            => FormatConversionFromArray<float16, byte, C4b>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4b(c[0].HalfToByte(), c[1].HalfToByte(), c[2].HalfToByte(), c[3].HalfToByte())
+            );
+
+        [Test]
+        public void TypeConversionHalfToUShort()
+            => FormatConversionFromArray<float16, ushort, C4us>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4us(c[0].HalfToUShort(), c[1].HalfToUShort(), c[2].HalfToUShort(), c[3].HalfToUShort())
+            );
+
+        [Test]
+        public void TypeConversionHalfToUInt()
+            => FormatConversionFromArray<float16, uint, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4ui(c[0].HalfToUInt(), c[1].HalfToUInt(), c[2].HalfToUInt(), c[3].HalfToUInt())
+            );
+
+        [Test]
+        public void TypeConversionHalfToFloat()
+            => FormatConversionFromArray<float16, float, C4f>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4f(c[0], c[1], c[2], c[3])
+            );
+
+        [Test]
+        public void TypeConversionHalfToDouble()
+            => FormatConversionFromArray<float16, double, C4d>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4d(c[0], c[1], c[2], c[3])
+            );
+
+        #endregion
+
+        #region Float to BGRA (other types)
+
+        [Test]
+        public void TypeConversionFloatToByte()
+            => FormatConversion<float, byte, C4f, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionFloatToUShort()
+            => FormatConversion<float, ushort, C4f, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionFloatToUInt()
+            => FormatConversion<float, uint, C4f, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionFloatToHalf()
+            => FormatConversionToArray<float, float16, C4f>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.FloatToHalf(), c.G.FloatToHalf(), c.R.FloatToHalf(), c.A.FloatToHalf() }
+            );
+
+
+        [Test]
+        public void TypeConversionFloatToDouble()
+            => FormatConversion<float, double, C4f, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region Double to BGRA (other types)
+
+        [Test]
+        public void TypeConversionDoubleToByte()
+            => FormatConversion<double, byte, C4d, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionDoubleToUShort()
+            => FormatConversion<double, ushort, C4d, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionDoubleToUInt()
+            => FormatConversion<double, uint, C4d, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionDoubleToHalf()
+            => FormatConversionToArray<double, float16, C4d>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.DoubleToHalf(), c.G.DoubleToHalf(), c.R.DoubleToHalf(), c.A.DoubleToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionDoubleToFloat()
+            => FormatConversion<double, float, C4f, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
 
         #endregion
 
@@ -243,27 +422,27 @@ public void FormatConversionRGBAToRG()
 
         [Test]
         public void FormatConversionBGRAToRGBA()
-            => FormatConversion<C4b, C4b>(Col.Format.BGRA, Col.Format.RGBA, color => color);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.BGRA, Col.Format.RGBA, c => c);
 
         [Test]
         public void FormatConversionBGRAToRGB()
-            => FormatConversion<C4b, C3b>(Col.Format.BGRA, Col.Format.RGB, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.BGRA, Col.Format.RGB, c => c.RGB);
 
         [Test]
         public void FormatConversionBGRAToBGR()
-            => FormatConversion<C4b, C3b>(Col.Format.BGRA, Col.Format.BGR, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.BGRA, Col.Format.BGR, c => c.RGB);
 
         [Test]
         public void FormatConversionBGRAToGray()
-            => FormatConversion<C4b, byte>(Col.Format.BGRA, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C4b, byte>(Col.Format.BGRA, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionBGRAToGrayAlpha()
-            => FormatConversionToArray<C4b>(Col.Format.BGRA, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), color.A });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.BGRA, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), c.A });
 
         [Test]
         public void FormatConversionBGRAToRG()
-            => FormatConversionToArray<C4b>(Col.Format.BGRA, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.BGRA, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -271,27 +450,27 @@ public void FormatConversionBGRAToRG()
 
         [Test]
         public void FormatConversionRGBToBGRA()
-            => FormatConversion<C3b, C4b>(Col.Format.RGB, Col.Format.BGRA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.RGB, Col.Format.BGRA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionRGBToRGBA()
-            => FormatConversion<C3b, C4b>(Col.Format.RGB, Col.Format.RGBA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.RGB, Col.Format.RGBA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionRGBToBGR()
-            => FormatConversion<C3b, C3b>(Col.Format.RGB, Col.Format.BGR, color => color);
+            => FormatConversion<byte, byte, C3b, C3b>(Col.Format.RGB, Col.Format.BGR, c => c);
 
         [Test]
         public void FormatConversionRGBToGray()
-            => FormatConversion<C3b, byte>(Col.Format.RGB, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C3b, byte>(Col.Format.RGB, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionRGBToGrayAlpha()
-            => FormatConversionToArray<C3b>(Col.Format.RGB, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), 255 });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.RGB, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), 255 });
 
         [Test]
         public void FormatConversionRGBToRG()
-            => FormatConversionToArray<C3b>(Col.Format.RGB, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.RGB, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -299,27 +478,27 @@ public void FormatConversionRGBToRG()
 
         [Test]
         public void FormatConversionBGRToBGRA()
-            => FormatConversion<C3b, C4b>(Col.Format.BGR, Col.Format.BGRA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.BGR, Col.Format.BGRA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionBGRToRGBA()
-            => FormatConversion<C3b, C4b>(Col.Format.BGR, Col.Format.RGBA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.BGR, Col.Format.RGBA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionBGRToRGB()
-            => FormatConversion<C3b, C3b>(Col.Format.BGR, Col.Format.RGB, color => color);
+            => FormatConversion<byte, byte, C3b, C3b>(Col.Format.BGR, Col.Format.RGB, c => c);
 
         [Test]
         public void FormatConversionBGRToGray()
-            => FormatConversion<C3b, byte>(Col.Format.BGR, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C3b, byte>(Col.Format.BGR, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionBGRToGrayAlpha()
-            => FormatConversionToArray<C3b>(Col.Format.BGR, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), 255 });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.BGR, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), 255 });
 
         [Test]
         public void FormatConversionBGRToRG()
-            => FormatConversionToArray<C3b>(Col.Format.BGR, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.BGR, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -327,19 +506,19 @@ public void FormatConversionBGRToRG()
 
         [Test]
         public void FormatConversionRGToBGRA()
-            => FormatConversionFromArray<C4b>(Col.Format.RG, Col.Format.BGRA, color => new C4b(color[0], color[1], (byte)0, (byte)255));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.RG, Col.Format.BGRA, c => new C4b(c[0], c[1], (byte)0, (byte)255));
 
         [Test]
         public void FormatConversionRGToRGBA()
-            => FormatConversionFromArray<C4b>(Col.Format.RG, Col.Format.RGBA, color => new C4b(color[0], color[1], (byte)0, (byte)255));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.RG, Col.Format.RGBA, c => new C4b(c[0], c[1], (byte)0, (byte)255));
 
         [Test]
         public void FormatConversionRGToRGB()
-            => FormatConversionFromArray<C3b>(Col.Format.RG, Col.Format.RGB, color => new C3b(color[0], color[1], (byte)0));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.RG, Col.Format.RGB, c => new C3b(c[0], c[1], (byte)0));
 
         [Test]
         public void FormatConversionRGToBGR()
-            => FormatConversionFromArray<C3b>(Col.Format.RG, Col.Format.BGR, color => new C3b(color[0], color[1], (byte)0));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.RG, Col.Format.BGR, c => new C3b(c[0], c[1], (byte)0));
 
         #endregion
 
diff --git a/src/Tests/Aardvark.Base.Tests/Images/PixVolumeTests.cs b/src/Tests/Aardvark.Base.Tests/Images/PixVolumeTests.cs
index 3bfcc260..cb4f924c 100644
--- a/src/Tests/Aardvark.Base.Tests/Images/PixVolumeTests.cs
+++ b/src/Tests/Aardvark.Base.Tests/Images/PixVolumeTests.cs
@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using System;
 using Aardvark.Base;
+using float16 = Aardvark.Base.Half;
 
 namespace Aardvark.Tests.Images
 {
@@ -11,29 +12,30 @@ class PixVolumeTests
 
         #region Format Conversions
 
-        private static byte[] GetArray(PixVolume<byte> pi, V3l coord)
+        private static T[] GetArray<T>(PixVolume<T> pi, V3l coord)
         {
-            var arr = new byte[pi.ChannelCount];
+            var arr = new T[pi.ChannelCount];
             arr.SetByIndex(i => pi.Tensor4[new V4l(coord, i)]);
             return arr;
         }
 
-        private static T GetColor<T>(PixVolume<byte> pi, V3l coord)
-            => pi.GetVolume<T>()[coord];
+        private static Tc GetColor<T, Tc>(PixVolume<T> pi, V3l coord)
+            => pi.GetVolume<Tc>()[coord];
 
-        private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat,
-                                                     Func<PixVolume<byte>, V3l, T1> getInput,
-                                                     Func<PixVolume<byte>, V3l, T2> getActual,
-                                                     Func<T1, T2> expectedConversion,
-                                                     bool subImageWindow)
+        private static void FormatConversion<T1, T2, Tc1, Tc2>(Col.Format sourceFormat, Col.Format targetFormat,
+                                                               Func<PixVolume<T1>, V3l, Tc1> getInput,
+                                                               Func<PixVolume<T2>, V3l, Tc2> getActual,
+                                                               Func<Tc1, Tc2> expectedConversion,
+                                                               bool subImageWindow)
         {
-            var src = new PixVolume<byte>(sourceFormat, 43, 31, 23);
-            src.Tensor4.Data.SetByIndex((_) => (byte)rnd.UniformInt(256));
+            var getRandom = PixImageTests.s_randomValues[typeof(T1)];
+            var src = new PixVolume<T1>(sourceFormat, 43, 31, 23);
+            src.Tensor4.Data.SetByIndex((_) => (T1)getRandom(rnd));
 
             if (subImageWindow)
-                src = new PixVolume<byte>(sourceFormat, src.Tensor4.SubImageWindow(11, 7, 3, 27, 13, 8));
+                src = new PixVolume<T1>(sourceFormat, src.Tensor4.SubImageWindow(11, 7, 3, 27, 13, 8));
 
-            var dst = src.ToFormat(targetFormat);
+            var dst = new PixVolume<T2>(targetFormat, src);
 
             src.GetChannel(0L).ForeachCoord((coord) =>
             {
@@ -43,47 +45,47 @@ private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format
             });
         }
 
-        private static void FormatConversionArrays(Col.Format sourceFormat, Col.Format targetFormat, Func<byte[], byte[]> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetArray, GetArray, expectedConversion, subImageWindow);
+        private static void FormatConversionArrays<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1[], T2[]> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, T1[], T2[]>(sourceFormat, targetFormat, GetArray, GetArray, expectedConversion, subImageWindow);
 
-        private static void FormatConversionFromArray<T>(Col.Format sourceFormat, Col.Format targetFormat, Func<byte[], T> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetArray, GetColor<T>, expectedConversion, subImageWindow);
+        private static void FormatConversionFromArray<T1, T2, Tc2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1[], Tc2> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, T1[], Tc2>(sourceFormat, targetFormat, GetArray, GetColor<T2, Tc2>, expectedConversion, subImageWindow);
 
-        private static void FormatConversionToArray<T>(Col.Format sourceFormat, Col.Format targetFormat, Func<T, byte[]> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetColor<T>, GetArray, expectedConversion, subImageWindow);
+        private static void FormatConversionToArray<T1, T2, Tc1>(Col.Format sourceFormat, Col.Format targetFormat, Func<Tc1, T2[]> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, Tc1, T2[]>(sourceFormat, targetFormat, GetColor<T1, Tc1>, GetArray, expectedConversion, subImageWindow);
 
-        private static void FormatConversion<T1, T2>(Col.Format sourceFormat, Col.Format targetFormat, Func<T1, T2> expectedConversion, bool subImageWindow = false)
-            => FormatConversion(sourceFormat, targetFormat, GetColor<T1>, GetColor<T2>, expectedConversion, subImageWindow);
+        private static void FormatConversion<T1, T2, Tc1, Tc2>(Col.Format sourceFormat, Col.Format targetFormat, Func<Tc1, Tc2> expectedConversion, bool subImageWindow = false)
+            => FormatConversion<T1, T2, Tc1, Tc2>(sourceFormat, targetFormat, GetColor<T1, Tc1>, GetColor<T2, Tc2>, expectedConversion, subImageWindow);
 
         #region From Gray
 
         [Test]
         public void FormatConversionGrayToGrayAlpha()
-            => FormatConversionToArray<byte>(Col.Format.Gray, Col.Format.GrayAlpha, gray => new byte[] { gray, 255 });
+            => FormatConversionToArray<byte, byte, byte>(Col.Format.Gray, Col.Format.GrayAlpha, gray => new byte[] { gray, 255 });
 
         [Test]
         public void FormatConversionGrayToAlpha()
-            => FormatConversion<byte, byte>(Col.Format.Gray, Col.Format.Alpha, gray => 255);
+            => FormatConversion<byte, byte, byte, byte>(Col.Format.Gray, Col.Format.Alpha, gray => 255);
 
         [Test]
         public void FormatConversionGrayToRGB()
-            => FormatConversion<byte, C3b>(Col.Format.Gray, Col.Format.RGB, gray => new C3b(gray));
+            => FormatConversion<byte, byte, byte, C3b>(Col.Format.Gray, Col.Format.RGB, gray => new C3b(gray));
 
         [Test]
         public void FormatConversionGrayToBGR()
-            => FormatConversion<byte, C3b>(Col.Format.Gray, Col.Format.BGR, gray => new C3b(gray));
+            => FormatConversion<byte, byte, byte, C3b>(Col.Format.Gray, Col.Format.BGR, gray => new C3b(gray));
 
         [Test]
         public void FormatConversionGrayToRGBA()
-            => FormatConversion<byte, C4b>(Col.Format.Gray, Col.Format.RGBA, gray => new C4b(gray));
+            => FormatConversion<byte, byte, byte, C4b>(Col.Format.Gray, Col.Format.RGBA, gray => new C4b(gray));
 
         [Test]
         public void FormatConversionGrayToBGRA()
-            => FormatConversion<byte, C4b>(Col.Format.Gray, Col.Format.BGRA, gray => new C4b(gray));
+            => FormatConversion<byte, byte, byte, C4b>(Col.Format.Gray, Col.Format.BGRA, gray => new C4b(gray));
 
         [Test]
         public void FormatConversionGrayToRG()
-            => FormatConversionToArray<byte>(Col.Format.Gray, Col.Format.RG, gray => new byte[] { gray, gray });
+            => FormatConversionToArray<byte, byte, byte>(Col.Format.Gray, Col.Format.RG, gray => new byte[] { gray, gray });
 
         #endregion
 
@@ -91,31 +93,31 @@ public void FormatConversionGrayToRG()
 
         [Test]
         public void FormatConversionGrayAlphaToGray()
-            => FormatConversionFromArray<byte>(Col.Format.GrayAlpha, Col.Format.Gray, gray => gray[0]);
+            => FormatConversionFromArray<byte, byte, byte>(Col.Format.GrayAlpha, Col.Format.Gray, gray => gray[0]);
 
         [Test]
         public void FormatConversionGrayAlphaToAlpha()
-            => FormatConversionFromArray<byte>(Col.Format.GrayAlpha, Col.Format.Alpha, gray => gray[1]);
+            => FormatConversionFromArray<byte, byte, byte>(Col.Format.GrayAlpha, Col.Format.Alpha, gray => gray[1]);
 
         [Test]
         public void FormatConversionGrayAlphaToRGB()
-            => FormatConversionFromArray<C3b>(Col.Format.GrayAlpha, Col.Format.RGB, gray => new C3b(gray[0]));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.GrayAlpha, Col.Format.RGB, gray => new C3b(gray[0]));
 
         [Test]
         public void FormatConversionGrayAlphaToBGR()
-            => FormatConversionFromArray<C3b>(Col.Format.GrayAlpha, Col.Format.BGR, gray => new C3b(gray[0]));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.GrayAlpha, Col.Format.BGR, gray => new C3b(gray[0]));
 
         [Test]
         public void FormatConversionGrayAlphaToRGBA()
-            => FormatConversionFromArray<C4b>(Col.Format.GrayAlpha, Col.Format.RGBA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.GrayAlpha, Col.Format.RGBA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
 
         [Test]
         public void FormatConversionGrayAlphaToBGRA()
-            => FormatConversionFromArray<C4b>(Col.Format.GrayAlpha, Col.Format.BGRA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.GrayAlpha, Col.Format.BGRA, gray => new C4b(gray[0], gray[0], gray[0], gray[1]));
 
         [Test]
         public void FormatConversionGrayAlphaToRG()
-            => FormatConversionArrays(Col.Format.GrayAlpha, Col.Format.RG, gray => new byte[] { gray[0], gray[0] });
+            => FormatConversionArrays<byte, byte>(Col.Format.GrayAlpha, Col.Format.RG, gray => new byte[] { gray[0], gray[0] });
 
         #endregion
 
@@ -123,39 +125,39 @@ public void FormatConversionGrayAlphaToRG()
 
         [Test]
         public void FormatConversionRGBAToRGBA()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, color => color);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, c => c);
 
         [Test]
         public void FormatConversionRGBAToRGBAWindow()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, color => color, true);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.RGBA, c => c, true);
 
         [Test]
         public void FormatConversionRGBAToBGRA()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, color => color);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c);
 
         [Test]
         public void FormatConversionRGBAToBGRAWindow()
-            => FormatConversion<C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, color => color, true);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c, true);
 
         [Test]
         public void FormatConversionRGBAToRGB()
-            => FormatConversion<C4b, C3b>(Col.Format.RGBA, Col.Format.RGB, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.RGBA, Col.Format.RGB, c => c.RGB);
 
         [Test]
         public void FormatConversionRGBAToBGR()
-            => FormatConversion<C4b, C3b>(Col.Format.RGBA, Col.Format.BGR, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.RGBA, Col.Format.BGR, c => c.RGB);
 
         [Test]
         public void FormatConversionRGBAToGray()
-            => FormatConversion<C4b, byte>(Col.Format.RGBA, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C4b, byte>(Col.Format.RGBA, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionRGBAToGrayAlpha()
-            => FormatConversionToArray<C4b>(Col.Format.RGBA, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), color.A });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.RGBA, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), c.A });
 
         [Test]
         public void FormatConversionRGBAToRG()
-            => FormatConversionToArray<C4b>(Col.Format.RGBA, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.RGBA, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -163,27 +165,192 @@ public void FormatConversionRGBAToRG()
 
         [Test]
         public void FormatConversionBGRAToRGBA()
-            => FormatConversion<C4b, C4b>(Col.Format.BGRA, Col.Format.RGBA, color => color);
+            => FormatConversion<byte, byte, C4b, C4b>(Col.Format.BGRA, Col.Format.RGBA, c => c);
 
         [Test]
         public void FormatConversionBGRAToRGB()
-            => FormatConversion<C4b, C3b>(Col.Format.BGRA, Col.Format.RGB, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.BGRA, Col.Format.RGB, c => c.RGB);
 
         [Test]
         public void FormatConversionBGRAToBGR()
-            => FormatConversion<C4b, C3b>(Col.Format.BGRA, Col.Format.BGR, color => color.RGB);
+            => FormatConversion<byte, byte, C4b, C3b>(Col.Format.BGRA, Col.Format.BGR, c => c.RGB);
 
         [Test]
         public void FormatConversionBGRAToGray()
-            => FormatConversion<C4b, byte>(Col.Format.BGRA, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C4b, byte>(Col.Format.BGRA, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionBGRAToGrayAlpha()
-            => FormatConversionToArray<C4b>(Col.Format.BGRA, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), color.A });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.BGRA, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), c.A });
 
         [Test]
         public void FormatConversionBGRAToRG()
-            => FormatConversionToArray<C4b>(Col.Format.BGRA, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C4b>(Col.Format.BGRA, Col.Format.RG, c => new byte[] { c.R, c.G });
+
+        #region Byte to BGRA (other types)
+
+        [Test]
+        public void TypeConversionByteToUShort()
+            => FormatConversion<byte, ushort, C4b, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionByteToUInt()
+            => FormatConversion<byte, uint, C4b, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionByteToHalf()
+            => FormatConversionToArray<byte, float16, C4b>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.ByteToHalf(), c.G.ByteToHalf(), c.R.ByteToHalf(), c.A.ByteToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionByteToFloat()
+            => FormatConversion<byte, float, C4b, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionByteToDouble()
+            => FormatConversion<byte, double, C4b, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region UShort to BGRA (other types)
+
+        [Test]
+        public void TypeConversionUShortToByte()
+            => FormatConversion<ushort, byte, C4us, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionUShortToUInt()
+            => FormatConversion<ushort, uint, C4us, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionUShortToHalf()
+            => FormatConversionToArray<ushort, float16, C4us>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.UShortToHalf(), c.G.UShortToHalf(), c.R.UShortToHalf(), c.A.UShortToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionUShortToFloat()
+            => FormatConversion<ushort, float, C4us, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionUShortToDouble()
+            => FormatConversion<ushort, double, C4us, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region UInt to BGRA (other types)
+
+        [Test]
+        public void TypeConversionUIntToByte()
+            => FormatConversion<uint, byte, C4ui, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionUIntToUShort()
+            => FormatConversion<uint, ushort, C4ui, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionUIntToHalf()
+            => FormatConversionToArray<uint, float16, C4ui>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.UIntToHalf(), c.G.UIntToHalf(), c.R.UIntToHalf(), c.A.UIntToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionUIntToFloat()
+            => FormatConversion<uint, float, C4ui, C4f>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4f());
+
+        [Test]
+        public void TypeConversionUIntToDouble()
+            => FormatConversion<uint, double, C4ui, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region Half to BGRA (other types)
+
+        [Test]
+        public void TypeConversionHalfToByte()
+            => FormatConversionFromArray<float16, byte, C4b>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4b(c[0].HalfToByte(), c[1].HalfToByte(), c[2].HalfToByte(), c[3].HalfToByte())
+            );
+
+        [Test]
+        public void TypeConversionHalfToUShort()
+            => FormatConversionFromArray<float16, ushort, C4us>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4us(c[0].HalfToUShort(), c[1].HalfToUShort(), c[2].HalfToUShort(), c[3].HalfToUShort())
+            );
+
+        [Test]
+        public void TypeConversionHalfToUInt()
+            => FormatConversionFromArray<float16, uint, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4ui(c[0].HalfToUInt(), c[1].HalfToUInt(), c[2].HalfToUInt(), c[3].HalfToUInt())
+            );
+
+        [Test]
+        public void TypeConversionHalfToFloat()
+            => FormatConversionFromArray<float16, float, C4f>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4f(c[0], c[1], c[2], c[3])
+            );
+
+        [Test]
+        public void TypeConversionHalfToDouble()
+            => FormatConversionFromArray<float16, double, C4d>(Col.Format.RGBA, Col.Format.BGRA, c =>
+                new C4d(c[0], c[1], c[2], c[3])
+            );
+
+        #endregion
+
+        #region Float to BGRA (other types)
+
+        [Test]
+        public void TypeConversionFloatToByte()
+            => FormatConversion<float, byte, C4f, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionFloatToUShort()
+            => FormatConversion<float, ushort, C4f, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionFloatToUInt()
+            => FormatConversion<float, uint, C4f, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionFloatToHalf()
+            => FormatConversionToArray<float, float16, C4f>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.FloatToHalf(), c.G.FloatToHalf(), c.R.FloatToHalf(), c.A.FloatToHalf() }
+            );
+
+
+        [Test]
+        public void TypeConversionFloatToDouble()
+            => FormatConversion<float, double, C4f, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
+
+        #region Double to BGRA (other types)
+
+        [Test]
+        public void TypeConversionDoubleToByte()
+            => FormatConversion<double, byte, C4d, C4b>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4b());
+
+        [Test]
+        public void TypeConversionDoubleToUShort()
+            => FormatConversion<double, ushort, C4d, C4us>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4us());
+
+        [Test]
+        public void TypeConversionDoubleToUInt()
+            => FormatConversion<double, uint, C4d, C4ui>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4ui());
+
+        [Test]
+        public void TypeConversionDoubleToHalf()
+            => FormatConversionToArray<double, float16, C4d>(Col.Format.RGBA, Col.Format.BGRA,
+                c => new float16[] { c.B.DoubleToHalf(), c.G.DoubleToHalf(), c.R.DoubleToHalf(), c.A.DoubleToHalf() }
+            );
+
+        [Test]
+        public void TypeConversionDoubleToFloat()
+            => FormatConversion<double, float, C4f, C4d>(Col.Format.RGBA, Col.Format.BGRA, c => c.ToC4d());
+
+        #endregion
 
         #endregion
 
@@ -191,27 +358,27 @@ public void FormatConversionBGRAToRG()
 
         [Test]
         public void FormatConversionRGBToBGRA()
-            => FormatConversion<C3b, C4b>(Col.Format.RGB, Col.Format.BGRA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.RGB, Col.Format.BGRA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionRGBToRGBA()
-            => FormatConversion<C3b, C4b>(Col.Format.RGB, Col.Format.RGBA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.RGB, Col.Format.RGBA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionRGBToBGR()
-            => FormatConversion<C3b, C3b>(Col.Format.RGB, Col.Format.BGR, color => color);
+            => FormatConversion<byte, byte, C3b, C3b>(Col.Format.RGB, Col.Format.BGR, c => c);
 
         [Test]
         public void FormatConversionRGBToGray()
-            => FormatConversion<C3b, byte>(Col.Format.RGB, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C3b, byte>(Col.Format.RGB, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionRGBToGrayAlpha()
-            => FormatConversionToArray<C3b>(Col.Format.RGB, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), 255 });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.RGB, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), 255 });
 
         [Test]
         public void FormatConversionRGBToRG()
-            => FormatConversionToArray<C3b>(Col.Format.RGB, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.RGB, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -219,27 +386,27 @@ public void FormatConversionRGBToRG()
 
         [Test]
         public void FormatConversionBGRToBGRA()
-            => FormatConversion<C3b, C4b>(Col.Format.BGR, Col.Format.BGRA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.BGR, Col.Format.BGRA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionBGRToRGBA()
-            => FormatConversion<C3b, C4b>(Col.Format.BGR, Col.Format.RGBA, color => color.ToC4b());
+            => FormatConversion<byte, byte, C3b, C4b>(Col.Format.BGR, Col.Format.RGBA, c => c.ToC4b());
 
         [Test]
         public void FormatConversionBGRToRGB()
-            => FormatConversion<C3b, C3b>(Col.Format.BGR, Col.Format.RGB, color => color);
+            => FormatConversion<byte, byte, C3b, C3b>(Col.Format.BGR, Col.Format.RGB, c => c);
 
         [Test]
         public void FormatConversionBGRToGray()
-            => FormatConversion<C3b, byte>(Col.Format.BGR, Col.Format.Gray, color => color.ToGrayByte());
+            => FormatConversion<byte, byte, C3b, byte>(Col.Format.BGR, Col.Format.Gray, c => c.ToGrayByte());
 
         [Test]
         public void FormatConversionBGRToGrayAlpha()
-            => FormatConversionToArray<C3b>(Col.Format.BGR, Col.Format.GrayAlpha, color => new byte[] { color.ToGrayByte(), 255 });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.BGR, Col.Format.GrayAlpha, c => new byte[] { c.ToGrayByte(), 255 });
 
         [Test]
         public void FormatConversionBGRToRG()
-            => FormatConversionToArray<C3b>(Col.Format.BGR, Col.Format.RG, color => new byte[] { color.R, color.G });
+            => FormatConversionToArray<byte, byte, C3b>(Col.Format.BGR, Col.Format.RG, c => new byte[] { c.R, c.G });
 
         #endregion
 
@@ -247,19 +414,19 @@ public void FormatConversionBGRToRG()
 
         [Test]
         public void FormatConversionRGToBGRA()
-            => FormatConversionFromArray<C4b>(Col.Format.RG, Col.Format.BGRA, color => new C4b(color[0], color[1], (byte)0, (byte)255));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.RG, Col.Format.BGRA, c => new C4b(c[0], c[1], (byte)0, (byte)255));
 
         [Test]
         public void FormatConversionRGToRGBA()
-            => FormatConversionFromArray<C4b>(Col.Format.RG, Col.Format.RGBA, color => new C4b(color[0], color[1], (byte)0, (byte)255));
+            => FormatConversionFromArray<byte, byte, C4b>(Col.Format.RG, Col.Format.RGBA, c => new C4b(c[0], c[1], (byte)0, (byte)255));
 
         [Test]
         public void FormatConversionRGToRGB()
-            => FormatConversionFromArray<C3b>(Col.Format.RG, Col.Format.RGB, color => new C3b(color[0], color[1], (byte)0));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.RG, Col.Format.RGB, c => new C3b(c[0], c[1], (byte)0));
 
         [Test]
         public void FormatConversionRGToBGR()
-            => FormatConversionFromArray<C3b>(Col.Format.RG, Col.Format.BGR, color => new C3b(color[0], color[1], (byte)0));
+            => FormatConversionFromArray<byte, byte, C3b>(Col.Format.RG, Col.Format.BGR, c => new C3b(c[0], c[1], (byte)0));
 
         #endregion