tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #384 from SixLabors/js/remove-pixelconversion-extensions 

Remove PixelConversionExtensions
af/merge-core
James Jackson-South 8 years ago
committed by GitHub
parent
08eae8a5e5 5313a6ea9a
commit
62d697bc7e
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 408 additions and 453 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/ImageSharp/Dithering/Ordered/IOrderedDither.cs
  2. 28
      src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs
  3. 10
      src/ImageSharp/Formats/Gif/GifEncoderCore.cs
  4. 20
      src/ImageSharp/Formats/Png/PngEncoderCore.cs
  5. 79
      src/ImageSharp/PixelFormats/PixelConversionExtensions.cs
  6. 4
      src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs
  7. 34
      src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs
  8. 7
      tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs
  9. 8
      tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs
  10. 519
      tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
  11. 26
      tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs
  12. 76
      tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
  13. 10
      tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs
  14. 16
      tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
  15. 20
      tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs

4
src/ImageSharp/Dithering/Ordered/IOrderedDither.cs
View File

@ -17,12 +17,12 @@ namespace SixLabors.ImageSharp.Dithering
/// <param name="source">The source pixel</param>
/// <param name="upper">The color to apply to the pixels above the threshold.</param>
/// <param name="lower">The color to apply to the pixels below the threshold.</param>
/// <param name="bytes">The byte array to pack/unpack to. Must have a length of 4. Bytes are unpacked to Xyzw order.</param>
/// <param name="rgba">The <see cref="Rgba32"/> to pack/unpack to.</param>
/// <param name="index">The component index to test the threshold against. Must range from 0 to 3.</param>
/// <param name="x">The column index.</param>
/// <param name="y">The row index.</param>
/// <typeparam name="TPixel">The pixel format.</typeparam>
void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, byte[] bytes, int index, int x, int y)
void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, ref Rgba32 rgba, int index, int x, int y)
where TPixel : struct, IPixel<TPixel>;
}
}

28
src/ImageSharp/Dithering/Ordered/OrderedDitherBase.cs
View File

@ -1,13 +1,14 @@
// Copyright (c) Six Labors and contributors.
// Licensed under the Apache License, Version 2.0.
using System;
using SixLabors.ImageSharp.Memory;
using SixLabors.ImageSharp.PixelFormats;
namespace SixLabors.ImageSharp.Dithering.Base
{
/// <summary>
/// The base class for performing ordered ditheroing using a 4x4 matrix.
/// The base class for performing ordered dithering using a 4x4 matrix.
/// </summary>
public abstract class OrderedDitherBase : IOrderedDither
{
@ -26,14 +27,27 @@ namespace SixLabors.ImageSharp.Dithering.Base
}
/// <inheritdoc />
public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, byte[] bytes, int index, int x, int y)
public void Dither<TPixel>(ImageFrame<TPixel> image, TPixel source, TPixel upper, TPixel lower, ref Rgba32 rgba, int index, int x, int y)
where TPixel : struct, IPixel<TPixel>
{
// TODO: This doesn't really cut it for me.
// I'd rather be using float but we need to add some sort of normalization vector methods to all IPixel implementations
// before we can do that as the vectors all cover different ranges.
source.ToXyzwBytes(bytes, 0);
image[x, y] = this.matrix[y % 3, x % 3] >= bytes[index] ? lower : upper;
source.ToRgba32(ref rgba);
switch (index)
{
case 0:
image[x, y] = this.matrix[y % 3, x % 3] >= rgba.R ? lower : upper;
return;
case 1:
image[x, y] = this.matrix[y % 3, x % 3] >= rgba.G ? lower : upper;
return;
case 2:
image[x, y] = this.matrix[y % 3, x % 3] >= rgba.B ? lower : upper;
return;
case 3:
image[x, y] = this.matrix[y % 3, x % 3] >= rgba.A ? lower : upper;
return;
}
throw new ArgumentOutOfRangeException(nameof(index), "Index should be between 0 and 3 inclusive.");
}
}
}

10
src/ImageSharp/Formats/Gif/GifEncoderCore.cs
View File

@ -351,16 +351,16 @@ namespace SixLabors.ImageSharp.Formats.Gif
// Get max colors for bit depth.
int colorTableLength = (int)Math.Pow(2, this.bitDepth) * 3;
byte[] colorTable = ArrayPool<byte>.Shared.Rent(colorTableLength);
var rgb = default(Rgb24);
try
{
for (int i = 0; i < pixelCount; i++)
{
int offset = i * 3;
image.Palette[i].ToXyzBytes(this.buffer, 0);
colorTable[offset] = this.buffer[0];
colorTable[offset + 1] = this.buffer[1];
colorTable[offset + 2] = this.buffer[2];
image.Palette[i].ToRgb24(ref rgb);
colorTable[offset] = rgb.R;
colorTable[offset + 1] = rgb.G;
colorTable[offset + 2] = rgb.B;
}
writer.Write(colorTable, 0, colorTableLength);

20
src/ImageSharp/Formats/Png/PngEncoderCore.cs
View File

@ -318,6 +318,7 @@ namespace SixLabors.ImageSharp.Formats.Png
where TPixel : struct, IPixel<TPixel>
{
byte[] rawScanlineArray = this.rawScanline.Array;
var rgba = default(Rgba32);
// Copy the pixels across from the image.
// Reuse the chunk type buffer.
@ -326,8 +327,8 @@ namespace SixLabors.ImageSharp.Formats.Png
// Convert the color to YCbCr and store the luminance
// Optionally store the original color alpha.
int offset = x * this.bytesPerPixel;
rowSpan[x].ToXyzwBytes(this.chunkTypeBuffer, 0);
byte luminance = (byte)((0.299F * this.chunkTypeBuffer[0]) + (0.587F * this.chunkTypeBuffer[1]) + (0.114F * this.chunkTypeBuffer[2]));
rowSpan[x].ToRgba32(ref rgba);
byte luminance = (byte)((0.299F * rgba.R) + (0.587F * rgba.G) + (0.114F * rgba.B));
for (int i = 0; i < this.bytesPerPixel; i++)
{
@ -337,7 +338,7 @@ namespace SixLabors.ImageSharp.Formats.Png
}
else
{
rawScanlineArray[offset + i] = this.chunkTypeBuffer[3];
rawScanlineArray[offset + i] = rgba.A;
}
}
}
@ -518,7 +519,7 @@ namespace SixLabors.ImageSharp.Formats.Png
int colorTableLength = (int)Math.Pow(2, header.BitDepth) * 3;
byte[] colorTable = ArrayPool<byte>.Shared.Rent(colorTableLength);
byte[] alphaTable = ArrayPool<byte>.Shared.Rent(pixelCount);
byte[] bytes = ArrayPool<byte>.Shared.Rent(4);
var rgba = default(Rgba32);
bool anyAlpha = false;
try
{
@ -527,13 +528,13 @@ namespace SixLabors.ImageSharp.Formats.Png
if (quantized.Pixels.Contains(i))
{
int offset = i * 3;
palette[i].ToXyzwBytes(bytes, 0);
palette[i].ToRgba32(ref rgba);
byte alpha = bytes[3];
byte alpha = rgba.A;
colorTable[offset] = bytes[0];
colorTable[offset + 1] = bytes[1];
colorTable[offset + 2] = bytes[2];
colorTable[offset] = rgba.R;
colorTable[offset + 1] = rgba.G;
colorTable[offset + 2] = rgba.B;
if (alpha > this.threshold)
{
@ -557,7 +558,6 @@ namespace SixLabors.ImageSharp.Formats.Png
{
ArrayPool<byte>.Shared.Return(colorTable);
ArrayPool<byte>.Shared.Return(alphaTable);
ArrayPool<byte>.Shared.Return(bytes);
}
return quantized;

79
src/ImageSharp/PixelFormats/PixelConversionExtensions.cs
View File

@ -1,79 +0,0 @@
// Copyright (c) Six Labors and contributors.
// Licensed under the Apache License, Version 2.0.
using System;
using System.Runtime.CompilerServices;
namespace SixLabors.ImageSharp.PixelFormats
{
/// <summary>
/// Extension methods for copying single pixel data into byte Spans.
/// TODO: This utility class exists for legacy reasons. Need to do a lot of chore work to remove it (mostly in test classes).
/// </summary>
internal static class PixelConversionExtensions
{
/// <summary>
/// Expands the packed representation into a given byte array.
/// Output is expanded to X-> Y-> Z order. Equivalent to R-> G-> B in <see cref="Rgb24"/>
/// </summary>
/// <typeparam name="TPixel">The pixel type.</typeparam>
/// <param name="pixel">The pixel to copy the data from.</param>
/// <param name="bytes">The bytes to set the color in.</param>
/// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ToXyzBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
where TPixel : struct, IPixel<TPixel>
{
ref Rgb24 dest = ref bytes.GetRgb24(startIndex);
pixel.ToRgb24(ref dest);
}
/// <summary>
/// Expands the packed representation into a given byte array.
/// Output is expanded to X-> Y-> Z-> W order. Equivalent to R-> G-> B-> A in <see cref="Rgba32"/>
/// </summary>
/// <typeparam name="TPixel">The pixel type.</typeparam>
/// <param name="pixel">The pixel to copy the data from.</param>
/// <param name="bytes">The bytes to set the color in.</param>
/// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ToXyzwBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
where TPixel : struct, IPixel<TPixel>
{
ref Rgba32 dest = ref Unsafe.As<byte, Rgba32>(ref bytes[startIndex]);
pixel.ToRgba32(ref dest);
}
/// <summary>
/// Expands the packed representation into a given byte array.
/// Output is expanded to Z-> Y-> X order. Equivalent to B-> G-> R in <see cref="Bgr24"/>
/// </summary>
/// <typeparam name="TPixel">The pixel type.</typeparam>
/// <param name="pixel">The pixel to copy the data from.</param>
/// <param name="bytes">The bytes to set the color in.</param>
/// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ToZyxBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
where TPixel : struct, IPixel<TPixel>
{
ref Bgr24 dest = ref Unsafe.As<byte, Bgr24>(ref bytes[startIndex]);
pixel.ToBgr24(ref dest);
}
/// <summary>
/// Expands the packed representation into a given byte array.
/// Output is expanded to Z-> Y-> X-> W order. Equivalent to B-> G-> R-> A in <see cref="Bgra32"/>
/// </summary>
/// <typeparam name="TPixel">The pixel type.</typeparam>
/// <param name="pixel">The pixel to copy the data from.</param>
/// <param name="bytes">The bytes to set the color in.</param>
/// <param name="startIndex">The starting index of the <paramref name="bytes"/>.</param>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void ToZyxwBytes<TPixel>(this TPixel pixel, Span<byte> bytes, int startIndex)
where TPixel : struct, IPixel<TPixel>
{
ref Bgra32 dest = ref Unsafe.As<byte, Bgra32>(ref bytes[startIndex]);
pixel.ToBgra32(ref dest);
}
}
}

4
src/ImageSharp/Processing/Processors/Binarization/OrderedDitherProcessor.cs
View File

@ -77,7 +77,7 @@ namespace SixLabors.ImageSharp.Processing.Processors
int startX = interest.X;
int endX = interest.Right;
byte[] bytes = new byte[4];
var rgba = default(Rgba32);
for (int y = startY; y < endY; y++)
{
Span<TPixel> row = source.GetPixelRowSpan(y);
@ -85,7 +85,7 @@ namespace SixLabors.ImageSharp.Processing.Processors
for (int x = startX; x < endX; x++)
{
TPixel sourceColor = row[x];
this.Dither.Dither(source, sourceColor, this.UpperColor, this.LowerColor, bytes, this.Index, x, y);
this.Dither.Dither(source, sourceColor, this.UpperColor, this.LowerColor, ref rgba, this.Index, x, y);
}
}
}

34
src/ImageSharp/Quantizers/WuQuantizer{TPixel}.cs
View File

@ -60,11 +60,6 @@ namespace SixLabors.ImageSharp.Quantizers
/// </summary>
private const int TableLength = IndexCount * IndexCount * IndexCount * IndexAlphaCount;
/// <summary>
/// A buffer for storing pixels
/// </summary>
private readonly byte[] rgbaBuffer = new byte[4];
/// <summary>
/// A lookup table for colors
/// </summary>
@ -199,19 +194,15 @@ namespace SixLabors.ImageSharp.Quantizers
{
// Add the color to a 3-D color histogram.
// Colors are expected in r->g->b->a format
pixel.ToXyzwBytes(this.rgbaBuffer, 0);
byte r = this.rgbaBuffer[0];
byte g = this.rgbaBuffer[1];
byte b = this.rgbaBuffer[2];
byte a = this.rgbaBuffer[3];
var rgba = default(Rgba32);
pixel.ToRgba32(ref rgba);
int inr = r >> (8 - IndexBits);
int ing = g >> (8 - IndexBits);
int inb = b >> (8 - IndexBits);
int ina = a >> (8 - IndexAlphaBits);
int r = rgba.R >> 2; // 8 - IndexBits
int g = rgba.G >> 2;
int b = rgba.B >> 2;
int a = rgba.A >> 5; // 8 - IndexAlphaBits
int ind = GetPaletteIndex(inr + 1, ing + 1, inb + 1, ina + 1);
int ind = GetPaletteIndex(r + 1, g + 1, b + 1, a + 1);
this.vwt[ind]++;
this.vmr[ind] += r;
@ -840,12 +831,13 @@ namespace SixLabors.ImageSharp.Quantizers
}
// Expected order r->g->b->a
pixel.ToXyzwBytes(this.rgbaBuffer, 0);
var rgba = default(Rgba32);
pixel.ToRgba32(ref rgba);
int r = this.rgbaBuffer[0] >> (8 - IndexBits);
int g = this.rgbaBuffer[1] >> (8 - IndexBits);
int b = this.rgbaBuffer[2] >> (8 - IndexBits);
int a = this.rgbaBuffer[3] >> (8 - IndexAlphaBits);
int r = rgba.R >> (8 - IndexBits);
int g = rgba.G >> (8 - IndexBits);
int b = rgba.B >> (8 - IndexBits);
int a = rgba.A >> (8 - IndexAlphaBits);
return this.tag[GetPaletteIndex(r + 1, g + 1, b + 1, a + 1)];
}

7
tests/ImageSharp.Benchmarks/Color/Bulk/ToXyz.cs
View File

@ -35,11 +35,16 @@ namespace SixLabors.ImageSharp.Benchmarks.Color.Bulk
{
TPixel[] s = this.source.Array;
byte[] d = this.destination.Array;
var rgb = default(Rgb24);
for (int i = 0; i < this.Count; i++)
{
TPixel c = s[i];
c.ToXyzBytes(d, i * 4);
int i3 = i * 3;
c.ToRgb24(ref rgb);
d[i3] = rgb.R;
d[i3 + 1] = rgb.G;
d[i3 + 2] = rgb.B;
}
}

8
tests/ImageSharp.Benchmarks/Color/Bulk/ToXyzw.cs
View File

@ -40,11 +40,17 @@ namespace SixLabors.ImageSharp.Benchmarks.Color.Bulk
{
TPixel[] s = this.source.Array;
byte[] d = this.destination.Array;
var rgba = default(Rgba32);
for (int i = 0; i < this.Count; i++)
{
TPixel c = s[i];
c.ToXyzwBytes(d, i * 4);
int i4 = i * 4;
c.ToRgba32(ref rgba);
d[i4] = rgba.R;
d[i4 + 1] = rgba.G;
d[i4 + 2] = rgba.B;
d[i4 + 3] = rgba.A;
}
}

519
tests/ImageSharp.Tests/PixelFormats/PackedPixelTests.cs
View File

@ -2,7 +2,6 @@
// Licensed under the Apache License, Version 2.0.
using System;
using System.Diagnostics;
using System.Numerics;
using SixLabors.ImageSharp.PixelFormats;
using Xunit;
@ -34,29 +33,29 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal(26, new Alpha8(0.1F).PackedValue);
// Test ordering
Vector4 vector = new Alpha8(.5F).ToVector4();
var vector = new Alpha8(.5F).ToVector4();
Assert.Equal(0, vector.X);
Assert.Equal(0, vector.Y);
Assert.Equal(0, vector.Z);
Assert.Equal(.5F, vector.W, 2);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Alpha8(.5F).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 0, 0, 0 });
new Alpha8(.5F).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(0, 0, 0));
new Alpha8(.5F).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 0, 0, 0, 128 });
new Alpha8(.5F).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(0, 0, 0, 128));
new Alpha8(.5F).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 0, 0 });
new Alpha8(.5F).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(0, 0, 0));
new Alpha8(.5F).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 0, 0, 128 });
new Alpha8(.5F).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(0, 0, 0, 128));
}
[Fact]
@ -82,26 +81,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
float y = -0.3f;
float z = +0.5f;
float w = -0.7f;
Argb32 argb = new Argb32(x, y, z, w);
var argb = new Argb32(x, y, z, w);
Assert.Equal(0x001a0080u, argb.PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
argb.ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 0x1a, 0, 0x80 });
argb.ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80));
argb.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 0x1a, 0, 0x80, 0 });
argb.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0));
argb.ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0x80, 0, 0x1a });
argb.ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80));
argb.ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0x80, 0, 0x1a, 0 });
argb.ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0));
}
[Fact]
@ -133,22 +132,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal(6160, new Bgr565(x, y, z).PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Bgr565(x, y, z).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 25, 0, 132 });
new Bgr565(x, y, z).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(25, 0, 132));
new Bgr565(x, y, z).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 25, 0, 132, 255 });
new Bgr565(x, y, z).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(25, 0, 132, 255));
new Bgr565(x, y, z).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 132, 0, 25 });
new Bgr565(x, y, z).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(25, 0, 132));
new Bgr565(x, y, z).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 132, 0, 25, 255 });
new Bgr565(x, y, z).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(25, 0, 132, 255));
}
[Fact]
@ -183,22 +182,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal(520, new Bgra4444(x, y, z, w).PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Bgra4444(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 34, 0, 136 });
new Bgra4444(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(34, 0, 136));
new Bgra4444(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 34, 0, 136, 0 });
new Bgra4444(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(34, 0, 136, 0));
new Bgra4444(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 136, 0, 34 });
new Bgra4444(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(34, 0, 136));
new Bgra4444(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 136, 0, 34, 0 });
new Bgra4444(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(34, 0, 136, 0));
}
[Fact]
@ -229,22 +228,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal(3088, new Bgra5551(x, y, z, w).PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Bgra5551(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 24, 0, 131 });
new Bgra5551(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(24, 0, 131));
new Bgra5551(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 24, 0, 131, 0 });
new Bgra5551(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(24, 0, 131, 0));
new Bgra5551(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 131, 0, 24 });
new Bgra5551(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(24, 0, 131));
new Bgra5551(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 131, 0, 24, 0 });
new Bgra5551(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(24, 0, 131, 0));
}
[Fact]
@ -280,27 +279,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal((uint)128, new Byte4(x, y, z, w).PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Byte4(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 128, 0, 0 });
new Byte4(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(128, 0, 0));
new Byte4(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 128, 0, 0, 0 });
new Byte4(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(128, 0, 0, 0));
new Byte4(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 0, 128 });
new Byte4(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(128, 0, 0));
new Byte4(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 0, 128, 0 });
new Byte4(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(128, 0, 0, 0));
Byte4 r = new Byte4();
var r = new Byte4();
r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
}
[Fact]
@ -319,22 +318,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
float x = .5F;
Assert.True(Equal(new Vector4(x, 0, 0, 1), new HalfSingle(x).ToVector4()));
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new HalfSingle(x).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 128, 0, 0 });
new HalfSingle(x).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(128, 0, 0));
new HalfSingle(x).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 128, 0, 0, 255 });
new HalfSingle(x).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(128, 0, 0, 255));
new HalfSingle(x).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 0, 128 });
new HalfSingle(x).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(128, 0, 0));
new HalfSingle(x).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 0, 128, 255 });
new HalfSingle(x).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(128, 0, 0, 255));
}
[Fact]
@ -356,22 +355,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
float y = .25F;
Assert.True(Equal(new Vector4(x, y, 0, 1), new HalfVector2(x, y).ToVector4()));
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new HalfVector2(x, y).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 128, 64, 0 });
new HalfVector2(x, y).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(128, 64, 0));
new HalfVector2(x, y).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 128, 64, 0, 255 });
new HalfVector2(x, y).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(128, 64, 0, 255));
new HalfVector2(x, y).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 64, 128 });
new HalfVector2(x, y).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(128, 64, 0));
new HalfVector2(x, y).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 64, 128, 255 });
new HalfVector2(x, y).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(128, 64, 0, 255));
}
[Fact]
@ -402,22 +401,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
float z = .75F;
float w = 1F;
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new HalfVector4(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 64, 128, 191 });
new HalfVector4(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(64, 128, 191));
new HalfVector4(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 64, 128, 191, 255 });
new HalfVector4(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(64, 128, 191, 255));
new HalfVector4(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 191, 128, 64 });
new HalfVector4(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(64, 128, 191));
new HalfVector4(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 191, 128, 64, 255 });
new HalfVector4(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(64, 128, 191, 255));
}
[Fact]
@ -443,26 +442,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
float x = 0.1f;
float y = -0.3f;
Assert.Equal(0xda0d, new NormalizedByte2(x, y).PackedValue);
NormalizedByte2 n = new NormalizedByte2();
var n = new NormalizedByte2();
n.PackFromRgba32(new Rgba32(141, 90, 0, 0));
Assert.Equal(0xda0d, n.PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new NormalizedByte2(x, y).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 141, 90, 0 });
new NormalizedByte2(x, y).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(141, 90, 0));
new NormalizedByte2(x, y).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 141, 90, 0, 255 });
new NormalizedByte2(x, y).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(141, 90, 0, 255));
new NormalizedByte2(x, y).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 90, 141 });
new NormalizedByte2(x, y).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(141, 90, 0));
new NormalizedByte2(x, y).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 90, 141, 255 });
new NormalizedByte2(x, y).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(141, 90, 0, 255));
}
[Fact]
@ -486,38 +485,38 @@ namespace SixLabors.ImageSharp.Tests.Colors
float z = 0.5f;
float w = -0.7f;
Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue);
NormalizedByte4 n = new NormalizedByte4();
var n = new NormalizedByte4();
n.PackFromRgba32(new Rgba32(141, 90, 192, 39));
Assert.Equal(0xA740DA0D, n.PackedValue);
Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new NormalizedByte4(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 141, 90, 192 });
new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(141, 90, 192));
new NormalizedByte4(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 141, 90, 192, 39 });
new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
new NormalizedByte4(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 192, 90, 141 });
new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(141, 90, 192));
new NormalizedByte4(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 192, 90, 141, 39 });
new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
// http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8
NormalizedByte4 r = new NormalizedByte4();
var r = new NormalizedByte4();
r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
r.PackedValue = 0xff4af389;
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
}
[Fact]
@ -544,30 +543,30 @@ namespace SixLabors.ImageSharp.Tests.Colors
y = -0.3f;
Assert.Equal(3650751693, new NormalizedShort2(x, y).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
NormalizedShort2 n = new NormalizedShort2();
var n = new NormalizedShort2();
n.PackFromRgba32(new Rgba32(141, 90, 0, 0));
n.ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 141, 90, 0 });
n.ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(141, 90, 0));
// TODO: I don't think this can ever pass since the bytes are already truncated.
// Assert.Equal(3650751693, n.PackedValue);
new NormalizedShort2(x, y).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 141, 90, 0 });
new NormalizedShort2(x, y).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(141, 90, 0));
new NormalizedShort2(x, y).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 141, 90, 0, 255 });
new NormalizedShort2(x, y).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(141, 90, 0, 255));
new NormalizedShort2(x, y).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 90, 141 });
new NormalizedShort2(x, y).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(141, 90, 0));
new NormalizedShort2(x, y).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 90, 141, 255 });
new NormalizedShort2(x, y).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(141, 90, 0, 255));
}
[Fact]
@ -593,27 +592,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new NormalizedShort4(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 141, 90, 192 });
new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(141, 90, 192));
new NormalizedShort4(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 141, 90, 192, 39 });
new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
new NormalizedShort4(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 192, 90, 141 });
new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(141, 90, 192));
new NormalizedShort4(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 192, 90, 141, 39 });
new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
NormalizedShort4 r = new NormalizedShort4();
var r = new NormalizedShort4();
r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 9, 115, 202, 127 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
}
[Fact]
@ -640,22 +639,22 @@ namespace SixLabors.ImageSharp.Tests.Colors
Assert.Equal((uint)6554, new Rg32(x, y).PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Rg32(x, y).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 25, 0, 0 });
new Rg32(x, y).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(25, 0, 0));
new Rg32(x, y).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 25, 0, 0, 255 });
new Rg32(x, y).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(25, 0, 0, 255));
new Rg32(x, y).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 0, 25 });
new Rg32(x, y).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(25, 0, 0));
new Rg32(x, y).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 0, 25, 255 });
new Rg32(x, y).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(25, 0, 0, 255));
}
[Fact]
@ -685,28 +684,28 @@ namespace SixLabors.ImageSharp.Tests.Colors
w = -0.7f;
Assert.Equal((uint)536871014, new Rgba1010102(x, y, z, w).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Rgba1010102(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 25, 0, 128 });
new Rgba1010102(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(25, 0, 128));
new Rgba1010102(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 25, 0, 128, 0 });
new Rgba1010102(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(25, 0, 128, 0));
new Rgba1010102(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 128, 0, 25 });
new Rgba1010102(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(25, 0, 128));
new Rgba1010102(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 128, 0, 25, 0 });
new Rgba1010102(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(25, 0, 128, 0));
// Alpha component accuracy will be awful.
Rgba1010102 r = new Rgba1010102();
var r = new Rgba1010102();
r.PackFromRgba32(new Rgba32(25, 0, 128, 0));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 25, 0, 128, 0 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(25, 0, 128, 0));
}
[Fact]
@ -732,26 +731,26 @@ namespace SixLabors.ImageSharp.Tests.Colors
float y = -0.3f;
float z = +0.5f;
float w = -0.7f;
Rgba32 rgba32 = new Rgba32(x, y, z, w);
var rgba32 = new Rgba32(x, y, z, w);
Assert.Equal(0x80001Au, rgba32.PackedValue);
// Test ordering
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
rgba32.ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 0x1a, 0, 0x80 });
rgba32.ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(0x1a, 0, 0x80));
rgba32.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 0x1a, 0, 0x80, 0 });
rgba32.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(0x1a, 0, 0x80, 0));
rgba32.ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0x80, 0, 0x1a });
rgba32.ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(0x1a, 0, 0x80));
rgba32.ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0x80, 0, 0x1a, 0 });
rgba32.ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(0x1a, 0, 0x80, 0));
}
[Fact]
@ -779,27 +778,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
float w = 0.45f;
Assert.Equal((ulong)0x73334CCC2666147B, new Rgba64(x, y, z, w).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Rgba64(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 20, 38, 76 });
new Rgba64(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(20, 38, 76));
new Rgba64(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 20, 38, 76, 115 });
new Rgba64(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(20, 38, 76, 115));
new Rgba64(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 76, 38, 20 });
new Rgba64(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(20, 38, 76));
new Rgba64(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 76, 38, 20, 115 });
new Rgba64(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(20, 38, 76, 115));
Rgba64 r = new Rgba64();
var r = new Rgba64();
r.PackFromRgba32(new Rgba32(20, 38, 76, 115));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 20, 38, 76, 115 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(20, 38, 76, 115));
}
[Fact]
@ -834,27 +833,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
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];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Short2(x, y).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 128, 127, 0 });
new Short2(x, y).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(128, 127, 0));
new Short2(x, y).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 128, 127, 0, 255 });
new Short2(x, y).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(128, 127, 0, 255));
new Short2(x, y).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 0, 127, 128 });
new Short2(x, y).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(128, 127, 0));
new Short2(x, y).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 0, 127, 128, 255 });
new Short2(x, y).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(128, 127, 0, 255));
Short2 r = new Short2();
var r = new Short2();
r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
}
[Fact]
@ -891,27 +890,27 @@ namespace SixLabors.ImageSharp.Tests.Colors
w = 193;
Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue);
byte[] rgb = new byte[3];
byte[] rgba = new byte[4];
byte[] bgr = new byte[3];
byte[] bgra = new byte[4];
var rgb = default(Rgb24);
var rgba = default(Rgba32);
var bgr = default(Bgr24);
var bgra = default(Bgra32);
new Short4(x, y, z, w).ToXyzBytes(rgb, 0);
Assert.Equal(rgb, new byte[] { 172, 177, 243 });
new Short4(x, y, z, w).ToRgb24(ref rgb);
Assert.Equal(rgb, new Rgb24(172, 177, 243));
new Short4(x, y, z, w).ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 172, 177, 243, 128 });
new Short4(x, y, z, w).ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(172, 177, 243, 128));
new Short4(x, y, z, w).ToZyxBytes(bgr, 0);
Assert.Equal(bgr, new byte[] { 243, 177, 172 });
new Short4(x, y, z, w).ToBgr24(ref bgr);
Assert.Equal(bgr, new Bgr24(172, 177, 243));
new Short4(x, y, z, w).ToZyxwBytes(bgra, 0);
Assert.Equal(bgra, new byte[] { 243, 177, 172, 128 });
new Short4(x, y, z, w).ToBgra32(ref bgra);
Assert.Equal(bgra, new Bgra32(172, 177, 243, 128));
Short4 r = new Short4();
var r = new Short4();
r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
r.ToXyzwBytes(rgba, 0);
Assert.Equal(rgba, new byte[] { 20, 38, 0, 255 });
r.ToRgba32(ref rgba);
Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
}
// Comparison helpers with small tolerance to allow for floating point rounding during computations.

26
tests/ImageSharp.Tests/PixelFormats/PixelOperationsTests.cs
View File

@ -173,11 +173,15 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
{
TPixel[] source = CreatePixelTestData(count);
byte[] expected = new byte[count * 3];
var rgb = default(Rgb24);
for (int i = 0; i < count; i++)
{
int i3 = i * 3;
source[i].ToXyzBytes(expected, i3);
source[i].ToRgb24(ref rgb);
expected[i3] = rgb.R;
expected[i3 + 1] = rgb.G;
expected[i3 + 2] = rgb.B;
}
TestOperation(
@ -214,11 +218,16 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
{
TPixel[] source = CreatePixelTestData(count);
byte[] expected = new byte[count * 4];
var rgba = default(Rgba32);
for (int i = 0; i < count; i++)
{
int i4 = i * 4;
source[i].ToXyzwBytes(expected, i4);
source[i].ToRgba32(ref rgba);
expected[i4] = rgba.R;
expected[i4 + 1] = rgba.G;
expected[i4 + 2] = rgba.B;
expected[i4 + 3] = rgba.A;
}
TestOperation(
@ -255,11 +264,15 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
{
TPixel[] source = CreatePixelTestData(count);
byte[] expected = new byte[count * 3];
var bgr = default(Bgr24);
for (int i = 0; i < count; i++)
{
int i3 = i * 3;
source[i].ToZyxBytes(expected, i3);
source[i].ToBgr24(ref bgr);
expected[i3] = bgr.B;
expected[i3 + 1] = bgr.G;
expected[i3 + 2] = bgr.R;
}
TestOperation(
@ -296,11 +309,16 @@ namespace SixLabors.ImageSharp.Tests.PixelFormats
{
TPixel[] source = CreatePixelTestData(count);
byte[] expected = new byte[count * 4];
var bgra = default(Bgra32);
for (int i = 0; i < count; i++)
{
int i4 = i * 4;
source[i].ToZyxwBytes(expected, i4);
source[i].ToBgra32(ref bgra);
expected[i4] = bgra.B;
expected[i4 + 1] = bgra.G;
expected[i4 + 2] = bgra.R;
expected[i4 + 3] = bgra.A;
}
TestOperation(

76
tests/ImageSharp.Tests/PixelFormats/UnPackedPixelTests.cs
View File

@ -12,8 +12,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_From_Bytes_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
@ -24,8 +24,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_From_Floats_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
RgbaVector colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
var color = new Rgba32(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
var colorVector = new RgbaVector(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F);
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
@ -36,8 +36,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_From_Vector4_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
RgbaVector colorVector = new RgbaVector(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
var color = new Rgba32(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
var colorVector = new RgbaVector(new Vector4(24 / 255F, 48 / 255F, 96 / 255F, 192 / 255F));
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
@ -48,8 +48,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_From_Vector3_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
RgbaVector colorVector = new RgbaVector(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
var color = new Rgba32(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
var colorVector = new RgbaVector(new Vector3(24 / 255F, 48 / 255F, 96 / 255F));
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
@ -60,8 +60,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_From_Hex_Produce_Equal_Scaled_Component_OutPut()
{
Rgba32 color = Rgba32.FromHex("183060C0");
RgbaVector colorVector = RgbaVector.FromHex("183060C0");
var color = Rgba32.FromHex("183060C0");
var colorVector = RgbaVector.FromHex("183060C0");
Assert.Equal(color.R, (byte)(colorVector.R * 255));
Assert.Equal(color.G, (byte)(colorVector.G * 255));
@ -72,8 +72,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_Vector4_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
Assert.Equal(color.ToVector4(), colorVector.ToVector4());
}
@ -81,14 +81,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_RgbBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
byte[] rgb = new byte[3];
byte[] rgbVector = new byte[3];
var rgb = default(Rgb24);
var rgbVector = default(Rgb24);
color.ToXyzBytes(rgb, 0);
colorVector.ToXyzBytes(rgbVector, 0);
color.ToRgb24(ref rgb);
colorVector.ToRgb24(ref rgbVector);
Assert.Equal(rgb, rgbVector);
}
@ -96,14 +96,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_RgbaBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
byte[] rgba = new byte[4];
byte[] rgbaVector = new byte[4];
var rgba = default(Rgba32);
var rgbaVector = default(Rgba32);
color.ToXyzwBytes(rgba, 0);
colorVector.ToXyzwBytes(rgbaVector, 0);
color.ToRgba32(ref rgba);
colorVector.ToRgba32(ref rgbaVector);
Assert.Equal(rgba, rgbaVector);
}
@ -111,14 +111,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_BgrBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
byte[] bgr = new byte[3];
byte[] bgrVector = new byte[3];
var bgr = default(Bgr24);
var bgrVector = default(Bgr24);
color.ToZyxBytes(bgr, 0);
colorVector.ToZyxBytes(bgrVector, 0);
color.ToBgr24(ref bgr);
colorVector.ToBgr24(ref bgrVector);
Assert.Equal(bgr, bgrVector);
}
@ -126,14 +126,14 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_BgraBytes_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
byte[] bgra = new byte[4];
byte[] bgraVector = new byte[4];
var bgra = default(Bgra32);
var bgraVector = default(Bgra32);
color.ToZyxwBytes(bgra, 0);
colorVector.ToZyxwBytes(bgraVector, 0);
color.ToBgra32(ref bgra);
colorVector.ToBgra32(ref bgraVector);
Assert.Equal(bgra, bgraVector);
}
@ -141,8 +141,8 @@ namespace SixLabors.ImageSharp.Tests.Colors
[Fact]
public void Color_Types_To_Hex_Produce_Equal_OutPut()
{
Rgba32 color = new Rgba32(24, 48, 96, 192);
RgbaVector colorVector = new RgbaVector(24, 48, 96, 192);
var color = new Rgba32(24, 48, 96, 192);
var colorVector = new RgbaVector(24, 48, 96, 192);
// 183060C0
Assert.Equal(color.ToHex(), colorVector.ToHex());

10
tests/ImageSharp.Tests/Processing/Processors/ColorMatrix/GrayscaleTest.cs
View File

@ -31,13 +31,13 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.ColorMatrix
using (Image<TPixel> image = provider.GetImage())
{
image.Mutate(x => x.Grayscale(value));
byte[] data = new byte[3];
var rgb = default(Rgb24);
System.Span<TPixel> span = image.Frames.RootFrame.GetPixelSpan();
for (int i = 0; i < span.Length; i++)
{
span[i].ToXyzBytes(data, 0);
Assert.Equal(data[0], data[1]);
Assert.Equal(data[1], data[2]);
span[i].ToRgb24(ref rgb);
Assert.Equal(rgb.R, rgb.B);
Assert.Equal(rgb.B, rgb.G);
}
image.DebugSave(provider, value.ToString());
@ -50,7 +50,7 @@ namespace SixLabors.ImageSharp.Tests.Processing.Processors.ColorMatrix
where TPixel : struct, IPixel<TPixel>
{
using (Image<TPixel> source = provider.GetImage())
using (var image = source.Clone())
using (Image<TPixel> image = source.Clone())
{
var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Mutate(x => x.Grayscale(value, bounds));

16
tests/ImageSharp.Tests/TestUtilities/TestUtils.cs
View File

@ -54,8 +54,8 @@ namespace SixLabors.ImageSharp.Tests
return false;
}
byte[] bytesA = new byte[3];
byte[] bytesB = new byte[3];
var rgb1 = default(Rgb24);
var rgb2 = default(Rgb24);
using (PixelAccessor<TPixel> pixA = a.Lock())
{
@ -77,12 +77,12 @@ namespace SixLabors.ImageSharp.Tests
}
else
{
ca.ToXyzBytes(bytesA, 0);
cb.ToXyzBytes(bytesB, 0);
ca.ToRgb24(ref rgb1);
cb.ToRgb24(ref rgb2);
if (bytesA[0] != bytesB[0] ||
bytesA[1] != bytesB[1] ||
bytesA[2] != bytesB[2])
if (rgb1.R != rgb2.R ||
rgb1.G != rgb2.G ||
rgb1.B != rgb2.B)
{
return false;
}
@ -109,7 +109,7 @@ namespace SixLabors.ImageSharp.Tests
/// <returns></returns>
public static PixelTypes GetPixelType(this Type colorStructClrType) => ClrTypes2PixelTypes[colorStructClrType];
public static IEnumerable<KeyValuePair<PixelTypes, Type>> ExpandAllTypes(this PixelTypes pixelTypes)
{

20
tests/ImageSharp.Tests/TestUtilities/Tests/TestImageProviderTests.cs
View File

@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp.Tests
{
Assert.Equal(expected, provider.PixelType);
}
[Theory]
[WithFile(TestImages.Bmp.Car, PixelTypes.All, 88)]
[WithFile(TestImages.Bmp.F, PixelTypes.All, 88)]
@ -96,7 +96,7 @@ namespace SixLabors.ImageSharp.Tests
}
internal static int GetInvocationCount(string callerName) => invocationCounts[callerName];
private static readonly object Monitor = new object();
public static void DoTestThreadSafe(Action action)
@ -156,7 +156,7 @@ namespace SixLabors.ImageSharp.Tests
}
internal static int GetInvocationCount(string callerName) => invocationCounts[callerName];
private static readonly object Monitor = new object();
public static void DoTestThreadSafe(Action action)
@ -234,7 +234,7 @@ namespace SixLabors.ImageSharp.Tests
Image<TPixel> image = provider.GetImage();
provider.Utility.SaveTestOutputFile(image, "png");
}
[Theory]
[WithSolidFilledImages(10, 20, 255, 100, 50, 200, PixelTypes.Rgba32 | PixelTypes.Argb32)]
public void Use_WithSolidFilledImagesAttribute<TPixel>(TestImageProvider<TPixel> provider)
@ -244,7 +244,7 @@ namespace SixLabors.ImageSharp.Tests
Assert.Equal(10, img.Width);
Assert.Equal(20, img.Height);
byte[] colors = new byte[4];
var rgba = default(Rgba32);
using (PixelAccessor<TPixel> pixels = img.Lock())
{
@ -252,12 +252,12 @@ namespace SixLabors.ImageSharp.Tests
{
for (int x = 0; x < pixels.Width; x++)
{
pixels[x, y].ToXyzwBytes(colors, 0);
pixels[x, y].ToRgba32(ref rgba);
Assert.Equal(255, colors[0]);
Assert.Equal(100, colors[1]);
Assert.Equal(50, colors[2]);
Assert.Equal(200, colors[3]);
Assert.Equal(255, rgba.R);
Assert.Equal(100, rgba.G);
Assert.Equal(50, rgba.B);
Assert.Equal(200, rgba.A);
}
}
}

Write Preview
Loading…
Cancel
Save