public void Test_ReadOnlyMemory2DT_Slice_2() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); ReadOnlyMemory2D <int> slice1 = memory2d.Slice(0, 0, 2, 2); Assert.AreEqual(slice1.Length, 4); Assert.AreEqual(slice1.Height, 2); Assert.AreEqual(slice1.Width, 2); Assert.AreEqual(slice1.Span[0, 0], 1); Assert.AreEqual(slice1.Span[1, 1], 5); ReadOnlyMemory2D <int> slice2 = slice1.Slice(1, 0, 1, 2); Assert.AreEqual(slice2.Length, 2); Assert.AreEqual(slice2.Height, 1); Assert.AreEqual(slice2.Width, 2); Assert.AreEqual(slice2.Span[0, 0], 4); Assert.AreEqual(slice2.Span[0, 1], 5); ReadOnlyMemory2D <int> slice3 = slice2.Slice(0, 1, 1, 1); Assert.AreEqual(slice3.Length, 1); Assert.AreEqual(slice3.Height, 1); Assert.AreEqual(slice3.Width, 1); Assert.AreEqual(slice3.Span[0, 0], 5); }
public void Test_ReadOnlyMemory2DT_Array1DConstructor() { int[] array = { 1, 2, 3, 4, 5, 6 }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 1, 2, 2, 1); Assert.IsFalse(memory2d.IsEmpty); Assert.AreEqual(memory2d.Length, 4); Assert.AreEqual(memory2d.Width, 2); Assert.AreEqual(memory2d.Height, 2); Assert.AreEqual(memory2d.Span[0, 0], 2); Assert.AreEqual(memory2d.Span[1, 1], 6); // Here we check to ensure a covariant array conversion is allowed for ReadOnlyMemory2D<T> _ = new ReadOnlyMemory2D <object>(new string[1], 1, 1); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, -99, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, -10, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, 1, 1, -1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, 1, -100, 1)); Assert.ThrowsException <ArgumentException>(() => new ReadOnlyMemory2D <int>(array, 0, 2, 4, 0)); Assert.ThrowsException <ArgumentException>(() => new ReadOnlyMemory2D <int>(array, 0, 3, 3, 0)); Assert.ThrowsException <ArgumentException>(() => new ReadOnlyMemory2D <int>(array, 1, 2, 3, 0)); Assert.ThrowsException <ArgumentException>(() => new ReadOnlyMemory2D <int>(array, 0, 10, 1, 120)); }
public void Test_ReadOnlyMemory2DT_ReadOnlyMemoryConstructor() { ReadOnlyMemory <int> memory = new[] { 1, 2, 3, 4, 5, 6 }; ReadOnlyMemory2D <int> memory2d = memory.AsMemory2D(1, 2, 2, 1); Assert.IsFalse(memory2d.IsEmpty); Assert.AreEqual(memory2d.Length, 4); Assert.AreEqual(memory2d.Width, 2); Assert.AreEqual(memory2d.Height, 2); Assert.AreEqual(memory2d.Span[0, 0], 2); Assert.AreEqual(memory2d.Span[1, 1], 6); Assert.ThrowsException <ArgumentOutOfRangeException>(() => memory.AsMemory2D(-99, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => memory.AsMemory2D(0, -10, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => memory.AsMemory2D(0, 1, 1, -1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => memory.AsMemory2D(0, 1, -100, 1)); Assert.ThrowsException <ArgumentException>(() => memory.AsMemory2D(0, 2, 4, 0)); Assert.ThrowsException <ArgumentException>(() => memory.AsMemory2D(0, 3, 3, 0)); Assert.ThrowsException <ArgumentException>(() => memory.AsMemory2D(1, 2, 3, 0)); Assert.ThrowsException <ArgumentException>(() => memory.AsMemory2D(0, 10, 1, 120)); }
public void Test_ReadOnlyMemory2DT_Array3DConstructor_2() { int[,,] array = { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 10, 20, 30 }, { 40, 50, 60 } } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 1, 0, 1, 2, 2); Assert.IsFalse(memory2d.IsEmpty); Assert.AreEqual(memory2d.Length, 4); Assert.AreEqual(memory2d.Width, 2); Assert.AreEqual(memory2d.Height, 2); Assert.AreEqual(memory2d.Span[0, 0], 20); Assert.AreEqual(memory2d.Span[1, 1], 60); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, -1, 1, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 1, -1, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 1, 1, -1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 1, 1, 1, -1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 1, 1, 1, 1, -1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 2, 0, 0, 2, 3)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, 0, 1, 2, 3)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, 0, 0, 2, 4)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array, 0, 0, 0, 3, 3)); }
public NaiveHPQuadtree(ReadOnlyMemory2D <byte> data) { Debug.Assert(CeilToNextPowerOfTwo(data.Height) == data.Height); Debug.Assert(CeilToNextPowerOfTwo(data.Width) == data.Width); Debug.Assert(data.Width == data.Height); Data = data; if (data.Length == 1) { _leafs = default; return; } var span = data.Span; var start = span[0, 0]; foreach (var val in span) { if (val == start) { continue; } // split var halfWidth = Data.Width / 2; var halfHeight = Data.Height / 2; var width = Data.Width; var height = Data.Height; _leafs = new[]
static GoodHPQuadtree[] Split(ReadOnlyMemory2D <byte> data) { var halfWidth = data.Width / 2; var halfHeight = data.Height / 2; var width = data.Width; var height = data.Height; return(new[]
public unsafe void Test_ReadOnlyMemory2DT_Pin_2() { int[] array = { 1, 2, 3, 4 }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 2, 2); using var pin = memory2d.Pin(); Assert.AreEqual(((int *)pin.Pointer)[0], 1); Assert.AreEqual(((int *)pin.Pointer)[3], 4); }
public void Test_ReadOnlyMemory2DT_TryGetReadOnlyMemory_2() { int[] array = { 1, 2, 3, 4 }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 2, 2); bool success = memory2d.TryGetMemory(out ReadOnlyMemory <int> memory); Assert.IsTrue(success); Assert.AreEqual(memory.Length, array.Length); Assert.AreEqual(memory.Span[2], 3); }
public GoodHPQuadtree(ReadOnlyMemory2D <byte> data) { Debug.Assert(CeilToNextPowerOfTwo(data.Height) == data.Height); Debug.Assert(CeilToNextPowerOfTwo(data.Width) == data.Width); Debug.Assert(data.Width == data.Height); Data = data; if (data.Length == (nint)1) { _leafs = default; return; }
public void Test_ReadOnlyMemory2DT_TryGetReadOnlyMemory_3() { ReadOnlyMemory <int> data = new[] { 1, 2, 3, 4 }; ReadOnlyMemory2D <int> memory2d = data.AsMemory2D(2, 2); bool success = memory2d.TryGetMemory(out ReadOnlyMemory <int> memory); Assert.IsTrue(success); Assert.AreEqual(memory.Length, data.Length); Assert.AreEqual(memory.Span[2], 3); }
public void Test_ReadOnlyMemory2DT_Empty() { ReadOnlyMemory2D <int> empty1 = default; Assert.IsTrue(empty1.IsEmpty); Assert.AreEqual(empty1.Length, 0); Assert.AreEqual(empty1.Width, 0); Assert.AreEqual(empty1.Height, 0); ReadOnlyMemory2D <string> empty2 = ReadOnlyMemory2D <string> .Empty; Assert.IsTrue(empty2.IsEmpty); Assert.AreEqual(empty2.Length, 0); Assert.AreEqual(empty2.Width, 0); Assert.AreEqual(empty2.Height, 0); }
public void Test_ReadOnlyMemory2DT_ToString() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); string text = memory2d.ToString(); const string expected = "Microsoft.Toolkit.HighPerformance.Memory.ReadOnlyMemory2D<System.Int32>[2, 3]"; Assert.AreEqual(text, expected); }
public void Test_ReadOnlyMemory2DT_ToArray_1() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); int[,] copy = memory2d.ToArray(); Assert.AreEqual(copy.GetLength(0), array.GetLength(0)); Assert.AreEqual(copy.GetLength(1), array.GetLength(1)); CollectionAssert.AreEqual(array, copy); }
public void Test_ReadOnlyMemory2DT_Array2DConstructor_1() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); Assert.IsFalse(memory2d.IsEmpty); Assert.AreEqual(memory2d.Length, 6); Assert.AreEqual(memory2d.Width, 3); Assert.AreEqual(memory2d.Height, 2); Assert.AreEqual(memory2d.Span[0, 1], 2); Assert.AreEqual(memory2d.Span[1, 2], 6); _ = new ReadOnlyMemory2D <object>(new string[1, 2]); }
public void Test_ReadOnlyMemory2DT_GetHashCode() { Assert.AreEqual(ReadOnlyMemory2D <int> .Empty.GetHashCode(), 0); int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); int a = memory2d.GetHashCode(), b = memory2d.GetHashCode(); Assert.AreEqual(a, b); int c = new ReadOnlyMemory2D <int>(array, 0, 1, 2, 2).GetHashCode(); Assert.AreNotEqual(a, c); }
public void Test_ReadOnlyMemory2DT_Equals() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> readOnlyMemory2D = new ReadOnlyMemory2D <int>(array); Assert.IsFalse(readOnlyMemory2D.Equals(null)); Assert.IsFalse(readOnlyMemory2D.Equals(new ReadOnlyMemory2D <int>(array, 0, 1, 2, 2))); Assert.IsTrue(readOnlyMemory2D.Equals(new ReadOnlyMemory2D <int>(array))); Assert.IsTrue(readOnlyMemory2D.Equals(readOnlyMemory2D)); Memory2D <int> memory2d = array; Assert.IsTrue(readOnlyMemory2D.Equals((object)memory2d)); Assert.IsFalse(readOnlyMemory2D.Equals((object)memory2d.Slice(0, 1, 2, 2))); }
public void Test_ReadOnlyMemory2DT_Array2DConstructor_2() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 0, 1, 2, 2); Assert.IsFalse(memory2d.IsEmpty); Assert.AreEqual(memory2d.Length, 4); Assert.AreEqual(memory2d.Width, 2); Assert.AreEqual(memory2d.Height, 2); Assert.AreEqual(memory2d.Span[0, 0], 2); Assert.AreEqual(memory2d.Span[1, 1], 6); _ = new ReadOnlyMemory2D <object>(new string[1, 2]); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <object>(new string[1, 2], 0, 0, 2, 2)); }
public void Test_ReadOnlyMemory2DT_TryGetReadOnlyMemory_1() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); bool success = memory2d.TryGetMemory(out ReadOnlyMemory <int> memory); #if WINDOWS_UWP Assert.IsFalse(success); Assert.IsTrue(memory.IsEmpty); #else Assert.IsTrue(success); Assert.AreEqual(memory.Length, array.Length); Assert.IsTrue(Unsafe.AreSame(ref array[0, 0], ref Unsafe.AsRef(memory.Span[0]))); #endif }
public void Test_ReadOnlyMemory2DT_Slice_1() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array); ReadOnlyMemory2D <int> slice1 = memory2d.Slice(1, 1, 1, 2); Assert.AreEqual(slice1.Length, 2); Assert.AreEqual(slice1.Height, 1); Assert.AreEqual(slice1.Width, 2); Assert.AreEqual(slice1.Span[0, 0], 5); Assert.AreEqual(slice1.Span[0, 1], 6); ReadOnlyMemory2D <int> slice2 = memory2d.Slice(0, 1, 2, 2); Assert.AreEqual(slice2.Length, 4); Assert.AreEqual(slice2.Height, 2); Assert.AreEqual(slice2.Width, 2); Assert.AreEqual(slice2.Span[0, 0], 2); Assert.AreEqual(slice2.Span[1, 0], 5); Assert.AreEqual(slice2.Span[1, 1], 6); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(-1, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, -1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, 1, 1, -1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, 1, -1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(10, 1, 1, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, 12, 1, 12)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, 1, 55, 1)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(0, 0, 2, 4)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(0, 0, 3, 3)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(0, 1, 2, 3)); Assert.ThrowsException <ArgumentOutOfRangeException>(() => new ReadOnlyMemory2D <int>(array).Slice(1, 0, 2, 3)); }
public void Test_Memory2DT_Equals() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; // Here we want to verify that the Memory2D<T>.Equals method works correctly. This is true // when the wrapped instance is the same, and the various internal offsets and sizes match. Memory2D <int> memory2d = new Memory2D <int>(array); Assert.IsFalse(memory2d.Equals(null)); Assert.IsFalse(memory2d.Equals(new Memory2D <int>(array, 0, 1, 2, 2))); Assert.IsTrue(memory2d.Equals(new Memory2D <int>(array))); Assert.IsTrue(memory2d.Equals(memory2d)); // This should work also when casting to a ReadOnlyMemory2D<T> instance ReadOnlyMemory2D <int> readOnlyMemory2d = memory2d; Assert.IsTrue(memory2d.Equals(readOnlyMemory2d)); Assert.IsFalse(memory2d.Equals(readOnlyMemory2d.Slice(0, 1, 2, 2))); }
public void Test_ReadOnlyMemory2DT_ToArray_2() { int[,] array = { { 1, 2, 3 }, { 4, 5, 6 } }; ReadOnlyMemory2D <int> memory2d = new ReadOnlyMemory2D <int>(array, 0, 0, 2, 2); int[,] copy = memory2d.ToArray(); Assert.AreEqual(copy.GetLength(0), 2); Assert.AreEqual(copy.GetLength(1), 2); int[,] expected = { { 1, 2 }, { 4, 5 } }; CollectionAssert.AreEqual(expected, copy); }
/// <summary> /// Executes a specified action in an optimized parallel loop over the input data. /// </summary> /// <typeparam name="TItem">The type of items to iterate over.</typeparam> /// <typeparam name="TAction">The type of action (implementing <see cref="IInAction{T}"/> of <typeparamref name="TItem"/>) to invoke over each item.</typeparam> /// <param name="memory">The input <see cref="ReadOnlyMemory2D{T}"/> representing the data to process.</param> /// <param name="action">The <typeparamref name="TAction"/> instance representing the action to invoke.</param> /// <param name="minimumActionsPerThread"> /// The minimum number of actions to run per individual thread. Set to 1 if all invocations /// should be parallelized, or to a greater number if each individual invocation is fast /// enough that it is more efficient to set a lower bound per each running thread. /// </param> public static void ForEach <TItem, TAction>(ReadOnlyMemory2D <TItem> memory, in TAction action, int minimumActionsPerThread)
public static void ForEach <TItem, TAction>(ReadOnlyMemory2D <TItem> memory, in TAction action)
public static void ForEach <TItem, TAction>(ReadOnlyMemory2D <TItem> memory, int minimumActionsPerThread) where TAction : struct, IInAction <TItem> { ForEach(memory, default(TAction), minimumActionsPerThread); }
public static void ForEach <TItem, TAction>(ReadOnlyMemory2D <TItem> memory) where TAction : struct, IInAction <TItem> { ForEach(memory, default(TAction), 1); }
static BetterHPQuadtree[] Split(ReadOnlyMemory2D <byte> data) { var halfWidth = data.Width / 2; var halfHeight = data.Height / 2; return(new[]
/// <summary> /// Initializes a new instance of the <see cref="MemoryDebugView2D{T}"/> class with the specified parameters. /// </summary> /// <param name="memory">The input <see cref="ReadOnlyMemory2D{T}"/> instance with the items to display.</param> public MemoryDebugView2D(ReadOnlyMemory2D <T> memory) { this.Items = memory.ToArray(); }
public static void WritePAA(BinaryWriterEx writer, ReadOnlyMemory2D <ColorRgba32> image, ColorRgba32 max, ColorRgba32 avg, PAAType type = PAAType.DXT5, PAAFlags flags = PAAFlags.InterpolatedAlpha) { if (type != PAAType.DXT5 && type != PAAType.DXT1) { throw new NotSupportedException(); } var enc = new BCnEncoder.Encoder.BcEncoder(type == PAAType.DXT5 ? CompressionFormat.Bc3 : CompressionFormat.Bc1); var mipmaps = new List <MipmapEncoder>(); var width = image.Width; var height = image.Width; var offset = type == PAAType.DXT5 ? 128 : 112; foreach (var mipmap in enc.EncodeToRawBytes(image)) { if (width > 2 || height > 2) { var menc = new MipmapEncoder(mipmap, width, height, offset); offset += menc.MipmapEntrySize; mipmaps.Add(menc); width = width / 2; height = height / 2; } } writer.Write(type == PAAType.DXT5 ? (ushort)0xff05 : (ushort)0xff01); writer.WriteAscii("GGATCGVA", 8); writer.Write((uint)4); writer.Write(avg.r); writer.Write(avg.g); writer.Write(avg.b); writer.Write(avg.a); writer.WriteAscii("GGATCXAM", 8); writer.Write((uint)4); writer.Write(max.r); writer.Write(max.g); writer.Write(max.b); writer.Write(max.a); if (type == PAAType.DXT5) { writer.WriteAscii("GGATGALF", 8); writer.Write((uint)4); writer.Write((uint)flags); } writer.WriteAscii("GGATSFFO", 8); writer.Write(16 * 4); for (int i = 0; i < 16; ++i) { if (i < mipmaps.Count) { writer.Write((uint)mipmaps[i].Offset); } else { writer.Write((uint)0); } } writer.Write((ushort)0x0000); int index = 0; foreach (var mipmap in mipmaps) { if (writer.Position != mipmap.Offset) { throw new Exception($"Wrong offset @{mipmap.Width} : {writer.Position} != { mipmap.Offset}"); } writer.Write(mipmap.WidthEncoded); writer.Write(mipmap.Height); writer.WriteUInt24((uint)mipmap.PaaData.Length); writer.Write(mipmap.PaaData); index++; width = width / 2; height = height / 2; } writer.Write((uint)0x0000); writer.Write((ushort)0x0000); }