1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
{
Copyright 2011-2017 Michalis Kamburelis.
This file is part of "Castle Game Engine".
"Castle Game Engine" is free software; see the file COPYING.txt,
included in this distribution, for details about the copyright.
"Castle Game Engine" is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
----------------------------------------------------------------------------
}
unit TestCastleColors;
{$I castleconf.inc}
{ $define SPEED_TESTS}
interface
uses
Classes, SysUtils, fpcunit, testutils, testregistry,
CastleBaseTestCase, CastleVectors, CastleColors;
type
TTestCastleColors = class(TCastleBaseTestCase)
published
procedure TestHSV;
procedure TestLerpInHsv;
end;
implementation
uses CastleUtils, CastleStringUtils, CastleTimeUtils;
procedure TTestCastleColors.TestHSV;
var
RGB: TVector3Byte;
HSV: TVector3;
R, G, B: Integer;
{$ifdef SPEED_TESTS}
Operations: Integer;
Time: Double;
{$endif}
begin
{$ifdef SPEED_TESTS}
ProcessTimerBegin;
{$endif}
for R := 0 to 255 div 5 do
for G := 0 to 255 div 5 do
for B := 0 to 255 div 5 do
begin
RGB[0] := R * 5;
RGB[1] := G * 5;
RGB[2] := B * 5;
HSV := RgbToHsv(RGB);
{ test trip to HSV and back returns the same }
AssertTrue(TVector3Byte.Equals(RGB, HsvToRgbByte(HSV)));
{ test HSV components are in appropriate ranges }
AssertTrue(Between(HSV[0], 0, 6));
AssertTrue(Between(HSV[1], 0, 1));
AssertTrue(Between(HSV[2], 0, 1));
end;
{$ifdef SPEED_TESTS}
Operations := 255 div 5 + 1;
Operations := Sqr(Operations) * Operations;
Time := ProcessTimerEnd;
{ With FPC 2.4.4, speed is quite amazing:
with -dRELEASE:
HSV trip (RGB and back): average time is 0.00 secs per 1 operation (total 0.00 secs for 140608 operations)
with -dDEBUG:
HSV trip (RGB and back): average time is 0.00 secs per 1 operation (total 0.03 secs for 140608 operations)
}
Writeln(Format('HSV trip (RGB and back): average time is %f secs per 1 operation (total %f secs for %d operations)', [Time / Operations, Time, Operations]));
{$endif}
end;
procedure TTestCastleColors.TestLerpInHsv;
const
PureRed: TVector3 = (Data: (1, 0, 0));
PureBlue: TVector3 = (Data: (0, 0, 1));
var
I: Integer;
C: TVector3;
H: Single;
begin
for I := 1 to 10 do
begin
C := LerpRgbInHsv(I / 10, BlackRGB, PureBlue);
{ interpolating from pure black to blue,
all colors along the way should keep hue = blue }
H := RgbToHsv(C)[0];
AssertTrue(RgbToHsv(PureBlue)[0] = H);
// Writeln(C.ToString, ' ', VectorToNiceStr(RgbToHsv(C)));
end;
for I := 0 to 10 do
begin
C := LerpRgbInHsv(I / 10, PureRed, PureBlue);
{ interpolate from hue 0 to hue 4 --- go down through 0 }
H := RgbToHsv(C)[0];
AssertTrue((H = 0.0) or Between(H, 4, 6));
// Writeln(C.ToString, ' ', VectorToNiceStr(RgbToHsv(C)));
end;
for I := 0 to 10 do
begin
C := LerpRgbInHsv(I / 10, PureBlue, PureRed);
{ interpolate from hue 4 to hue 0 --- go up through 6 }
H := RgbToHsv(C)[0];
AssertTrue((H = 0.0) or Between(H, 4, 6));
// Writeln(C.ToString, ' ', VectorToNiceStr(RgbToHsv(C)));
end;
AssertVectorEquals(LerpRgbInHsv(0, PureBlue, PureRed), PureBlue);
AssertVectorEquals(LerpRgbInHsv(1, PureBlue, PureRed), PureRed);
AssertVectorEquals(LerpRgbInHsv(0, PureRed, PureBlue), PureRed);
AssertVectorEquals(LerpRgbInHsv(1, PureRed, PureBlue), PureBlue);
AssertVectorEquals(LerpRgbInHsv(0, BlackRGB, PureRed), BlackRGB);
AssertVectorEquals(LerpRgbInHsv(1, BlackRGB, PureRed), PureRed);
end;
initialization
RegisterTest(TTestCastleColors);
end.
|
