Skip to content

Commit cdc63ad

Browse files
JimBobSquarePantsJimBobSquarePants
authored
Merge pull request #603 from brianpopow/feature/refactorPacketPixelTests
Refactor packet pixel tests
2 parents 8a8202c + 03faf82 commit cdc63ad

26 files changed

+3546
-1406
lines changed

‎.travis.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ matrix:
66
- os: linux # Ubuntu 14.04
77
dist: trusty
88
sudo: required
9-
dotnet: 2.1.300-rc1-008673
9+
dotnet: 2.1.300
1010
mono: latest
1111
# - os: osx # OSX 10.11
1212
# osx_image: xcode7.3.1

‎src/ImageSharp/PixelFormats/Rgba64.cs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -221,10 +221,10 @@ public override int GetHashCode()
221221
[MethodImpl(MethodImplOptions.AggressiveInlining)]
222222
private static ulong Pack(float x, float y, float z, float w)
223223
{
224-
return (ulong)Math.Round(x.Clamp(0, 1) * 65535F) |
225-
((ulong)Math.Round(y.Clamp(0, 1) * 65535F) << 16) |
226-
((ulong)Math.Round(z.Clamp(0, 1) * 65535F) << 32) |
227-
((ulong)Math.Round(w.Clamp(0, 1) * 65535F) << 48);
224+
return (ulong)MathF.Round(x.Clamp(0, 1) * 65535F) |
225+
((ulong)MathF.Round(y.Clamp(0, 1) * 65535F) << 16) |
226+
((ulong)MathF.Round(z.Clamp(0, 1) * 65535F) << 32) |
227+
((ulong)MathF.Round(w.Clamp(0, 1) * 65535F) << 48);
228228
}
229229
}
230230
}

‎tests/ImageSharp.Tests/Issues/Issue594.cs‎

Lines changed: 263 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,263 @@
1+
using System;
2+
using System.Numerics;
3+
using SixLabors.ImageSharp.PixelFormats;
4+
using Xunit;
5+
6+
namespace SixLabors.ImageSharp.Tests.Issues
7+
{
8+
public class Issue594
9+
{
10+
// This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
11+
// see https://github.com/SixLabors/ImageSharp/issues/594
12+
[Fact(Skip = "Skipped because of issue #594")]
13+
public void NormalizedByte4()
14+
{
15+
// Test PackedValue
16+
Assert.Equal((uint)0x0, new NormalizedByte4(Vector4.Zero).PackedValue);
17+
Assert.Equal((uint)0x7F7F7F7F, new NormalizedByte4(Vector4.One).PackedValue);
18+
Assert.Equal(0x81818181, new NormalizedByte4(-Vector4.One).PackedValue);
19+
20+
// Test ToVector4
21+
Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One).ToVector4()));
22+
Assert.True(Equal(Vector4.Zero, new NormalizedByte4(Vector4.Zero).ToVector4()));
23+
Assert.True(Equal(-Vector4.One, new NormalizedByte4(-Vector4.One).ToVector4()));
24+
Assert.True(Equal(Vector4.One, new NormalizedByte4(Vector4.One * 1234.0f).ToVector4()));
25+
Assert.True(Equal(-Vector4.One, new NormalizedByte4(Vector4.One * -1234.0f).ToVector4()));
26+
27+
// Test ToScaledVector4.
28+
Vector4 scaled = new NormalizedByte4(-Vector4.One).ToScaledVector4();
29+
Assert.Equal(0, scaled.X);
30+
Assert.Equal(0, scaled.Y);
31+
Assert.Equal(0, scaled.Z);
32+
Assert.Equal(0, scaled.W);
33+
34+
// Test PackFromScaledVector4.
35+
var pixel = default(NormalizedByte4);
36+
pixel.PackFromScaledVector4(scaled);
37+
Assert.Equal(0x81818181, pixel.PackedValue);
38+
39+
// Test Ordering
40+
float x = 0.1f;
41+
float y = -0.3f;
42+
float z = 0.5f;
43+
float w = -0.7f;
44+
Assert.Equal(0xA740DA0D, new NormalizedByte4(x, y, z, w).PackedValue);
45+
var n = default(NormalizedByte4);
46+
n.PackFromRgba32(new Rgba32(141, 90, 192, 39));
47+
Assert.Equal(0xA740DA0D, n.PackedValue);
48+
49+
Assert.Equal((uint)958796544, new NormalizedByte4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
50+
51+
var rgb = default(Rgb24);
52+
var rgba = default(Rgba32);
53+
var bgr = default(Bgr24);
54+
var bgra = default(Bgra32);
55+
var argb = default(Argb32);
56+
57+
new NormalizedByte4(x, y, z, w).ToRgb24(ref rgb);
58+
Assert.Equal(rgb, new Rgb24(141, 90, 192));
59+
60+
new NormalizedByte4(x, y, z, w).ToRgba32(ref rgba);
61+
Assert.Equal(rgba, new Rgba32(141, 90, 192, 39));
62+
63+
new NormalizedByte4(x, y, z, w).ToBgr24(ref bgr);
64+
Assert.Equal(bgr, new Bgr24(141, 90, 192));
65+
66+
new NormalizedByte4(x, y, z, w).ToBgra32(ref bgra);
67+
Assert.Equal(bgra, new Bgra32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594)
68+
69+
new NormalizedByte4(x, y, z, w).ToArgb32(ref argb);
70+
Assert.Equal(argb, new Argb32(141, 90, 192, 39));
71+
72+
// http://community.monogame.net/t/normalizedbyte4-texture2d-gives-different-results-from-xna/8012/8
73+
var r = default(NormalizedByte4);
74+
r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
75+
r.ToRgba32(ref rgba);
76+
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
77+
78+
r.PackedValue = 0xff4af389;
79+
r.ToRgba32(ref rgba);
80+
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
81+
82+
r = default(NormalizedByte4);
83+
r.PackFromArgb32(new Argb32(9, 115, 202, 127));
84+
r.ToArgb32(ref argb);
85+
Assert.Equal(argb, new Argb32(9, 115, 202, 127));
86+
87+
r = default(NormalizedByte4);
88+
r.PackFromBgra32(new Bgra32(9, 115, 202, 127));
89+
r.ToBgra32(ref bgra);
90+
Assert.Equal(bgra, new Bgra32(9, 115, 202, 127));
91+
}
92+
93+
// This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
94+
// see https://github.com/SixLabors/ImageSharp/issues/594
95+
[Fact(Skip = "Skipped because of issue #594")]
96+
public void NormalizedShort4()
97+
{
98+
// Test PackedValue
99+
Assert.Equal((ulong)0x0, new NormalizedShort4(Vector4.Zero).PackedValue);
100+
Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new NormalizedShort4(Vector4.One).PackedValue);
101+
Assert.Equal(0x8001800180018001, new NormalizedShort4(-Vector4.One).PackedValue);
102+
103+
// Test ToVector4
104+
Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One).ToVector4()));
105+
Assert.True(Equal(Vector4.Zero, new NormalizedShort4(Vector4.Zero).ToVector4()));
106+
Assert.True(Equal(-Vector4.One, new NormalizedShort4(-Vector4.One).ToVector4()));
107+
Assert.True(Equal(Vector4.One, new NormalizedShort4(Vector4.One * 1234.0f).ToVector4()));
108+
Assert.True(Equal(-Vector4.One, new NormalizedShort4(Vector4.One * -1234.0f).ToVector4()));
109+
110+
// Test ToScaledVector4.
111+
Vector4 scaled = new NormalizedShort4(Vector4.One).ToScaledVector4();
112+
Assert.Equal(1, scaled.X);
113+
Assert.Equal(1, scaled.Y);
114+
Assert.Equal(1, scaled.Z);
115+
Assert.Equal(1, scaled.W);
116+
117+
// Test PackFromScaledVector4.
118+
var pixel = default(NormalizedShort4);
119+
pixel.PackFromScaledVector4(scaled);
120+
Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue);
121+
122+
// Test Ordering
123+
float x = 0.1f;
124+
float y = -0.3f;
125+
float z = 0.5f;
126+
float w = -0.7f;
127+
Assert.Equal(0xa6674000d99a0ccd, new NormalizedShort4(x, y, z, w).PackedValue);
128+
Assert.Equal((ulong)4150390751449251866, new NormalizedShort4(0.0008f, 0.15f, 0.30f, 0.45f).PackedValue);
129+
130+
var rgb = default(Rgb24);
131+
var rgba = default(Rgba32);
132+
var bgr = default(Bgr24);
133+
var bgra = default(Bgra32);
134+
var argb = default(Argb32);
135+
136+
new NormalizedShort4(x, y, z, w).ToRgb24(ref rgb);
137+
Assert.Equal(rgb, new Rgb24(141, 90, 192));
138+
139+
new NormalizedShort4(x, y, z, w).ToRgba32(ref rgba);
140+
Assert.Equal(rgba, new Rgba32(141, 90, 192, 39)); // this assert fails in Release build on linux (#594)
141+
142+
new NormalizedShort4(x, y, z, w).ToBgr24(ref bgr);
143+
Assert.Equal(bgr, new Bgr24(141, 90, 192));
144+
145+
new NormalizedShort4(x, y, z, w).ToBgra32(ref bgra);
146+
Assert.Equal(bgra, new Bgra32(141, 90, 192, 39));
147+
148+
new NormalizedShort4(x, y, z, w).ToArgb32(ref argb);
149+
Assert.Equal(argb, new Argb32(141, 90, 192, 39));
150+
151+
var r = default(NormalizedShort4);
152+
r.PackFromRgba32(new Rgba32(9, 115, 202, 127));
153+
r.ToRgba32(ref rgba);
154+
Assert.Equal(rgba, new Rgba32(9, 115, 202, 127));
155+
156+
r = default(NormalizedShort4);
157+
r.PackFromBgra32(new Bgra32(9, 115, 202, 127));
158+
r.ToBgra32(ref bgra);
159+
Assert.Equal(bgra, new Bgra32(9, 115, 202, 127));
160+
161+
r = default(NormalizedShort4);
162+
r.PackFromArgb32(new Argb32(9, 115, 202, 127));
163+
r.ToArgb32(ref argb);
164+
Assert.Equal(argb, new Argb32(9, 115, 202, 127));
165+
}
166+
167+
// This test fails for unknown reason in Release mode on linux and is meant to help reproducing the issue
168+
// see https://github.com/SixLabors/ImageSharp/issues/594
169+
[Fact(Skip = "Skipped because of issue #594")]
170+
public void Short4()
171+
{
172+
// Test the limits.
173+
Assert.Equal((ulong)0x0, new Short4(Vector4.Zero).PackedValue);
174+
Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, new Short4(Vector4.One * 0x7FFF).PackedValue);
175+
Assert.Equal(0x8000800080008000, new Short4(Vector4.One * -0x8000).PackedValue);
176+
177+
// Test ToVector4.
178+
Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 0x7FFF).ToVector4());
179+
Assert.Equal(Vector4.Zero, new Short4(Vector4.Zero).ToVector4());
180+
Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -0x8000).ToVector4());
181+
Assert.Equal(Vector4.UnitX * 0x7FFF, new Short4(Vector4.UnitX * 0x7FFF).ToVector4());
182+
Assert.Equal(Vector4.UnitY * 0x7FFF, new Short4(Vector4.UnitY * 0x7FFF).ToVector4());
183+
Assert.Equal(Vector4.UnitZ * 0x7FFF, new Short4(Vector4.UnitZ * 0x7FFF).ToVector4());
184+
Assert.Equal(Vector4.UnitW * 0x7FFF, new Short4(Vector4.UnitW * 0x7FFF).ToVector4());
185+
186+
// Test ToScaledVector4.
187+
Vector4 scaled = new Short4(Vector4.One * 0x7FFF).ToScaledVector4();
188+
Assert.Equal(1, scaled.X);
189+
Assert.Equal(1, scaled.Y);
190+
Assert.Equal(1, scaled.Z);
191+
Assert.Equal(1, scaled.W);
192+
193+
// Test PackFromScaledVector4.
194+
var pixel = default(Short4);
195+
pixel.PackFromScaledVector4(scaled);
196+
Assert.Equal((ulong)0x7FFF7FFF7FFF7FFF, pixel.PackedValue);
197+
198+
// Test clamping.
199+
Assert.Equal(Vector4.One * 0x7FFF, new Short4(Vector4.One * 1234567.0f).ToVector4());
200+
Assert.Equal(Vector4.One * -0x8000, new Short4(Vector4.One * -1234567.0f).ToVector4());
201+
202+
// Test Ordering
203+
float x = 0.1f;
204+
float y = -0.3f;
205+
float z = 0.5f;
206+
float w = -0.7f;
207+
Assert.Equal(18446462598732840960, new Short4(x, y, z, w).PackedValue);
208+
209+
x = 11547;
210+
y = 12653;
211+
z = 29623;
212+
w = 193;
213+
Assert.Equal((ulong)0x00c173b7316d2d1b, new Short4(x, y, z, w).PackedValue);
214+
215+
var rgb = default(Rgb24);
216+
var rgba = default(Rgba32);
217+
var bgr = default(Bgr24);
218+
var bgra = default(Bgra32);
219+
var argb = default(Argb32);
220+
221+
new Short4(x, y, z, w).ToRgb24(ref rgb);
222+
Assert.Equal(rgb, new Rgb24(172, 177, 243)); // this assert fails in Release build on linux (#594)
223+
224+
new Short4(x, y, z, w).ToRgba32(ref rgba);
225+
Assert.Equal(rgba, new Rgba32(172, 177, 243, 128));
226+
227+
new Short4(x, y, z, w).ToBgr24(ref bgr);
228+
Assert.Equal(bgr, new Bgr24(172, 177, 243));
229+
230+
new Short4(x, y, z, w).ToBgra32(ref bgra);
231+
Assert.Equal(bgra, new Bgra32(172, 177, 243, 128));
232+
233+
new Short4(x, y, z, w).ToArgb32(ref argb);
234+
Assert.Equal(argb, new Argb32(172, 177, 243, 128));
235+
236+
var r = default(Short4);
237+
r.PackFromRgba32(new Rgba32(20, 38, 0, 255));
238+
r.ToRgba32(ref rgba);
239+
Assert.Equal(rgba, new Rgba32(20, 38, 0, 255));
240+
241+
r = default(Short4);
242+
r.PackFromBgra32(new Bgra32(20, 38, 0, 255));
243+
r.ToBgra32(ref bgra);
244+
Assert.Equal(bgra, new Bgra32(20, 38, 0, 255));
245+
246+
r = default(Short4);
247+
r.PackFromArgb32(new Argb32(20, 38, 0, 255));
248+
r.ToArgb32(ref argb);
249+
Assert.Equal(argb, new Argb32(20, 38, 0, 255));
250+
}
251+
252+
// Comparison helpers with small tolerance to allow for floating point rounding during computations.
253+
public static bool Equal(float a, float b)
254+
{
255+
return Math.Abs(a - b) < 1e-5;
256+
}
257+
258+
public static bool Equal(Vector4 a, Vector4 b)
259+
{
260+
return Equal(a.X, b.X) && Equal(a.Y, b.Y) && Equal(a.Z, b.Z) && Equal(a.W, b.W);
261+
}
262+
}
263+
}

0 commit comments

Comments
 (0)