source: tags/ms_r16q2/SL/ITEM_SHADER/ValueTuple.cxx

Last change on this file was 15017, checked in by westram, 8 years ago
  • ensure mapping is symmetric (value [0 .. 1] to offset [0 .. RANGE_SIZE[ )
File size: 22.9 KB
Line 
1// ============================================================ //
2//                                                              //
3//   File      : ValueTuple.cxx                                 //
4//   Purpose   : Abstract value usable for shading items        //
5//                                                              //
6//   Coded by Ralf Westram (coder@reallysoft.de) in June 2016   //
7//   http://www.arb-home.de/                                    //
8//                                                              //
9// ============================================================ //
10
11#include "item_shader.h"
12
13// --------------------------------------------------------------------------------
14
15#ifdef UNIT_TESTS
16#ifndef TEST_UNIT_H
17#include <test_unit.h>
18#endif
19
20void TEST_shaded_values() {
21    // -------------------------------
22    //      NoTuple (basic test):
23
24    ShadedValue undef = ValueTuple::undefined();
25    TEST_REJECT(undef->is_defined());
26    TEST_REJECT(undef->clone()->is_defined());
27    TEST_EXPECT_EQUAL(undef->inspect(), "<undef>");
28
29    // -----------------------------------
30    //      LinearTuple (basic test):
31
32    {
33        ShadedValue val0 = ValueTuple::make(0.0);
34        TEST_EXPECT(val0->is_defined());
35        TEST_EXPECT(val0->clone()->is_defined());
36        TEST_EXPECT_EQUAL(val0->inspect(), "(0.000)");
37
38        ShadedValue val1 = ValueTuple::make(1.0);
39        TEST_EXPECT_EQUAL(val1->inspect(), "(1.000)");
40
41        // LinearTuple (mix):
42        ShadedValue half = val0->mix(0.50, *val1);
43        TEST_EXPECT_EQUAL(half->inspect(), "(0.500)");
44
45        TEST_EXPECT_EQUAL(val0->mix(0.25, *val1)->inspect(), "(0.750)");
46        TEST_EXPECT_EQUAL(val0->mix(0.60, *val1)->inspect(), "(0.400)");
47
48        TEST_EXPECT_EQUAL(half->mix(0.25, *val1)->inspect(), "(0.875)");
49        TEST_EXPECT_EQUAL(half->mix(0.50, *val1)->inspect(), "(0.750)");
50        TEST_EXPECT_EQUAL(half->mix(0.75, *val1)->inspect(), "(0.625)");
51
52        // mix LinearTuple with NoTuple:
53        TEST_EXPECT_EQUAL(undef->mix(INFINITY, *half)->inspect(), "(0.500)");
54        TEST_EXPECT_EQUAL(undef->mix(INFINITY, *half)->inspect(), "(0.500)");
55        TEST_EXPECT_EQUAL(half->mix(INFINITY, *undef)->inspect(), "(0.500)");
56    }
57
58    // -----------------------------------
59    //      PlanarTuple (basic test):
60
61    {
62        ShadedValue pval0 = ValueTuple::make(0, 0);
63        TEST_EXPECT(pval0->is_defined());
64        TEST_EXPECT(pval0->clone()->is_defined());
65        TEST_EXPECT_EQUAL(pval0->inspect(), "(0.000,0.000)");
66
67        // PlanarTuple (mixing):
68        ShadedValue px = ValueTuple::make(1, 0);
69        ShadedValue py = ValueTuple::make(0, 1);
70
71        TEST_EXPECT_EQUAL(px->mix(INFINITY, *undef)->inspect(), "(1.000,0.000)");
72        TEST_EXPECT_EQUAL(undef->mix(INFINITY, *px)->inspect(), "(1.000,0.000)");
73        TEST_EXPECT_EQUAL(px->mix(0.5, *py)->inspect(), "(0.500,0.500)");
74
75        // PlanarTuple (partially defined):
76        ShadedValue PonlyX = ValueTuple::make(0.5, NAN);
77        ShadedValue PonlyY = ValueTuple::make(NAN, 0.5);
78
79        TEST_EXPECT(PonlyX->is_defined());
80        TEST_EXPECT(PonlyY->is_defined());
81
82        TEST_EXPECT_EQUAL(PonlyX->inspect(), "(0.500,nan)");
83        TEST_EXPECT_EQUAL(PonlyY->inspect(), "(nan,0.500)");
84
85        TEST_EXPECT_EQUAL(PonlyX->mix(INFINITY, *PonlyY)->inspect(), "(0.500,0.500)"); // mixed without using ratio
86        TEST_EXPECT_EQUAL(PonlyX->mix(0.5, *px)->inspect(), "(0.750,0.000)");
87        TEST_EXPECT_EQUAL(PonlyY->mix(0.5, *py)->inspect(), "(0.000,0.750)");
88        TEST_EXPECT_EQUAL(PonlyX->mix(0.5, *py)->inspect(), "(0.250,1.000)");
89        TEST_EXPECT_EQUAL(PonlyY->mix(0.5, *px)->inspect(), "(1.000,0.250)");
90        TEST_EXPECT_EQUAL(PonlyY->mix(0.25,*px)->inspect(), "(1.000,0.125)"); // ratio only affects y-coord (x-coord is undef in PonlyY!)
91        TEST_EXPECT_EQUAL(PonlyY->mix(0.75,*px)->inspect(), "(1.000,0.375)");
92    }
93
94    // ------------------------------------
95    //      SpatialTuple (basic test):
96
97    {
98        ShadedValue sval0 = ValueTuple::make(0, 0, 0);
99        TEST_EXPECT(sval0->is_defined());
100        TEST_EXPECT(sval0->clone()->is_defined());
101        TEST_EXPECT_EQUAL(sval0->inspect(), "(0.000,0.000,0.000)");
102
103        // SpatialTuple (mixing):
104        ShadedValue px = ValueTuple::make(1, 0, 0);
105        ShadedValue py = ValueTuple::make(0, 1, 0);
106        ShadedValue pz = ValueTuple::make(0, 0, 1);
107
108        TEST_EXPECT_EQUAL(px->mix(INFINITY, *undef)->inspect(), "(1.000,0.000,0.000)");
109        TEST_EXPECT_EQUAL(undef->mix(INFINITY, *px)->inspect(), "(1.000,0.000,0.000)");
110        TEST_EXPECT_EQUAL(px->mix(0.5, *py)->inspect(), "(0.500,0.500,0.000)");
111        TEST_EXPECT_EQUAL(px->mix(0.5, *py)->mix(2/3.0, *pz)->inspect(), "(0.333,0.333,0.333)");
112
113        // SpatialTuple (partially defined):
114        ShadedValue PonlyX = ValueTuple::make(0.5, NAN, NAN);
115        ShadedValue PonlyY = ValueTuple::make(NAN, 0.5, NAN);
116        ShadedValue PonlyZ = ValueTuple::make(NAN, NAN, 0.5);
117
118        TEST_EXPECT(PonlyX->is_defined());
119        TEST_EXPECT(PonlyY->is_defined());
120        TEST_EXPECT(PonlyZ->is_defined());
121
122        TEST_EXPECT_EQUAL(PonlyX->inspect(), "(0.500,nan,nan)");
123        TEST_EXPECT_EQUAL(PonlyY->inspect(), "(nan,0.500,nan)");
124        TEST_EXPECT_EQUAL(PonlyZ->inspect(), "(nan,nan,0.500)");
125
126        ShadedValue pxy = PonlyX->mix(INFINITY, *PonlyY); // mixed without using ratio
127        ShadedValue pyz = PonlyY->mix(INFINITY, *PonlyZ);
128        ShadedValue pzx = PonlyZ->mix(INFINITY, *PonlyX);
129
130        TEST_EXPECT_EQUAL(pxy->inspect(), "(0.500,0.500,nan)");
131        TEST_EXPECT_EQUAL(pyz->inspect(), "(nan,0.500,0.500)");
132        TEST_EXPECT_EQUAL(pzx->inspect(), "(0.500,nan,0.500)");
133
134        TEST_EXPECT_EQUAL(pxy->mix(INFINITY, *PonlyZ)->inspect(), "(0.500,0.500,0.500)");
135        TEST_EXPECT_EQUAL(pyz->mix(INFINITY, *PonlyX)->inspect(), "(0.500,0.500,0.500)");
136        TEST_EXPECT_EQUAL(pzx->mix(INFINITY, *PonlyY)->inspect(), "(0.500,0.500,0.500)");
137
138        TEST_EXPECT_EQUAL(pxy->mix(0.5, *pyz)->inspect(), "(0.500,0.500,0.500)");
139        TEST_EXPECT_EQUAL(pyz->mix(0.5, *pzx)->inspect(), "(0.500,0.500,0.500)");
140        TEST_EXPECT_EQUAL(pzx->mix(0.5, *pxy)->inspect(), "(0.500,0.500,0.500)");
141
142        TEST_EXPECT_EQUAL(pxy->mix(0.5, *px)->inspect(), "(0.750,0.250,0.000)");
143        TEST_EXPECT_EQUAL(pyz->mix(0.5, *px)->inspect(), "(1.000,0.250,0.250)");
144        TEST_EXPECT_EQUAL(pzx->mix(0.5, *px)->inspect(), "(0.750,0.000,0.250)");
145
146        TEST_EXPECT_EQUAL(pxy->mix(0.5, *py)->inspect(), "(0.250,0.750,0.000)");
147        TEST_EXPECT_EQUAL(pyz->mix(0.5, *py)->inspect(), "(0.000,0.750,0.250)");
148        TEST_EXPECT_EQUAL(pzx->mix(0.5, *py)->inspect(), "(0.250,1.000,0.250)");
149
150        TEST_EXPECT_EQUAL(pxy->mix(0.5, *pz)->inspect(), "(0.250,0.250,1.000)");
151        TEST_EXPECT_EQUAL(pyz->mix(0.5, *pz)->inspect(), "(0.000,0.250,0.750)");
152        TEST_EXPECT_EQUAL(pzx->mix(0.5, *pz)->inspect(), "(0.250,0.000,0.750)");
153
154        TEST_EXPECT_EQUAL(pxy->mix(0.25, *pz)->inspect(), "(0.125,0.125,1.000)"); // ratio does not affect z-coord (only defined in pz)
155        TEST_EXPECT_EQUAL(pyz->mix(0.25, *pz)->inspect(), "(0.000,0.125,0.875)");
156        TEST_EXPECT_EQUAL(pzx->mix(0.25, *pz)->inspect(), "(0.125,0.000,0.875)");
157    }
158
159    // --------------------------------------
160    //      test NAN leads to undefined:
161
162    ShadedValue novalue = ValueTuple::make(NAN);
163    TEST_REJECT(novalue->is_defined());
164
165    ShadedValue noValuePair = ValueTuple::make(NAN, NAN);
166    TEST_REJECT(noValuePair->is_defined());
167
168    ShadedValue noValueTriple = ValueTuple::make(NAN, NAN, NAN);
169    TEST_REJECT(noValueTriple->is_defined());
170}
171
172void TEST_value_color_mapping() {
173    // tests mapping from ShadedValue into range_offset (with different phasing)
174
175    const float NOSHIFT = 0.0;
176
177    Phaser dontPhase;
178
179    Phaser halfPhase           (0.5, false, NOSHIFT, NOSHIFT);
180    Phaser halfPhasePreShiftPos(0.5, false, +0.25,   NOSHIFT);
181    Phaser halfPhasePreShiftNeg(0.5, false, +0.75,   NOSHIFT); // +75% should act like -25%
182    Phaser halfPhasePstShiftPos(0.5, false, NOSHIFT, +0.25);
183    Phaser halfPhasePstShiftNeg(0.5, false, NOSHIFT, +0.75);
184
185    Phaser twoPhase (2.0, false, NOSHIFT, NOSHIFT);
186    Phaser alt3Phase(3.0, true,  NOSHIFT, NOSHIFT);
187    Phaser alt4Phase(4.0, true,  NOSHIFT, NOSHIFT);
188
189    {
190        ShadedValue val0 = ValueTuple::make(0.0);
191        ShadedValue half = ValueTuple::make(0.5);
192        ShadedValue val1 = ValueTuple::make(1.0);
193
194        TEST_EXPECT_EQUAL(val0->range_offset(dontPhase),            0);
195        TEST_EXPECT_EQUAL(val0->range_offset(halfPhase),            0);
196        TEST_EXPECT_EQUAL(val0->range_offset(halfPhasePreShiftPos), AW_RANGE_COLORS*3/8);
197        TEST_EXPECT_EQUAL(val0->range_offset(halfPhasePreShiftNeg), AW_RANGE_COLORS*1/8);
198        TEST_EXPECT_EQUAL(val0->range_offset(halfPhasePstShiftPos), AW_RANGE_COLORS*1/4);
199        TEST_EXPECT_EQUAL(val0->range_offset(halfPhasePstShiftNeg), AW_RANGE_COLORS*3/4);
200
201        TEST_EXPECT_EQUAL(val1->range_offset(dontPhase),            AW_RANGE_COLORS-1);
202        TEST_EXPECT_EQUAL(val1->range_offset(halfPhase),            AW_RANGE_COLORS/2);
203        TEST_EXPECT_EQUAL(val1->range_offset(halfPhasePreShiftPos), AW_RANGE_COLORS*3/8);
204        TEST_EXPECT_EQUAL(val1->range_offset(halfPhasePreShiftNeg), AW_RANGE_COLORS*1/8);
205        TEST_EXPECT_EQUAL(val1->range_offset(halfPhasePstShiftPos), AW_RANGE_COLORS*3/4);
206        TEST_EXPECT_EQUAL(val1->range_offset(halfPhasePstShiftNeg), AW_RANGE_COLORS*1/4);
207
208        TEST_EXPECT_EQUAL(half->range_offset(dontPhase),            AW_RANGE_COLORS/2);
209        TEST_EXPECT_EQUAL(half->range_offset(twoPhase),             AW_RANGE_COLORS-1);
210        TEST_EXPECT_EQUAL(half->range_offset(alt3Phase),            AW_RANGE_COLORS/2);
211        TEST_EXPECT_EQUAL(half->range_offset(alt4Phase),            0);
212        TEST_EXPECT_EQUAL(half->range_offset(halfPhase),            AW_RANGE_COLORS/4);
213        TEST_EXPECT_EQUAL(half->range_offset(halfPhasePreShiftPos), AW_RANGE_COLORS*1/8);
214        TEST_EXPECT_EQUAL(half->range_offset(halfPhasePreShiftNeg), AW_RANGE_COLORS*3/8);
215        TEST_EXPECT_EQUAL(half->range_offset(halfPhasePstShiftPos), AW_RANGE_COLORS*2/4);
216        TEST_EXPECT_EQUAL(half->range_offset(halfPhasePstShiftNeg), AW_RANGE_COLORS*4/4 - 1);
217    }
218
219#define PQS(c)                    (AW_PLANAR_COLORS*(c)/4)
220#define PLANAR_QUARTER_SHIFT(x,y) (PQS(x)*AW_PLANAR_COLORS + PQS(y))
221
222#if 0
223    // document results of PLANAR_QUARTER_SHIFT:
224#define DOCQS(x,y,res) TEST_EXPECT_EQUAL(PLANAR_QUARTER_SHIFT(x,y), res)
225
226    DOCQS(0,0,0);  DOCQS(1,0,1024); DOCQS(2,0,2048); DOCQS(3,0,3072); DOCQS(4,0,4096);
227    DOCQS(0,1,16); DOCQS(1,1,1040); DOCQS(2,1,2064); DOCQS(3,1,3088); DOCQS(4,1,4112);
228    DOCQS(0,2,32); DOCQS(1,2,1056); DOCQS(2,2,2080); DOCQS(3,2,3104); DOCQS(4,2,4128);
229    DOCQS(0,3,48); DOCQS(1,3,1072); DOCQS(2,3,2096); DOCQS(3,3,3120); DOCQS(4,3,4144);
230    DOCQS(0,4,64); DOCQS(1,4,1088); DOCQS(2,4,2112); DOCQS(3,4,3136); DOCQS(4,4,4160);
231
232#endif
233
234    {
235        ShadedValue pval0  = ValueTuple::make(0, 0);
236        ShadedValue px     = ValueTuple::make(1, 0);
237        ShadedValue py     = ValueTuple::make(0, 1);
238        ShadedValue PonlyX = ValueTuple::make(0.5, NAN);
239        ShadedValue PonlyY = ValueTuple::make(NAN, 0.5);
240
241        TEST_EXPECT_EQUAL(pval0->range_offset(dontPhase), 0);
242        TEST_EXPECT_EQUAL(pval0->range_offset(twoPhase),  0);
243        TEST_EXPECT_EQUAL(pval0->range_offset(alt3Phase), 0);
244        TEST_EXPECT_EQUAL(pval0->range_offset(alt4Phase), 0);
245
246        TEST_EXPECT_EQUAL(px->range_offset(dontPhase), (AW_PLANAR_COLORS-1)*AW_PLANAR_COLORS);
247        TEST_EXPECT_EQUAL(py->range_offset(dontPhase),  AW_PLANAR_COLORS-1);
248
249        // partly undefined values produce a valid range-offset:
250        TEST_EXPECT_EQUAL(PonlyX->range_offset(dontPhase), (AW_PLANAR_COLORS*AW_PLANAR_COLORS)/2);
251        TEST_EXPECT_EQUAL(PonlyY->range_offset(dontPhase), AW_PLANAR_COLORS/2);
252
253        // test 2-dim-phase-scale and -shift:
254        TEST_EXPECT_EQUAL(px->range_offset(twoPhase),             PLANAR_QUARTER_SHIFT(4, 0)  - AW_PLANAR_COLORS); // -1*AW_PLANAR_COLORS due to limited range!
255        TEST_EXPECT_EQUAL(px->range_offset(halfPhase),            PLANAR_QUARTER_SHIFT(2, 0));
256        TEST_EXPECT_EQUAL(px->range_offset(halfPhasePreShiftPos), PLANAR_QUARTER_SHIFT(3, 3)/2);
257        TEST_EXPECT_EQUAL(px->range_offset(halfPhasePreShiftNeg), PLANAR_QUARTER_SHIFT(1, 1)/2);
258        TEST_EXPECT_EQUAL(px->range_offset(halfPhasePstShiftPos), PLANAR_QUARTER_SHIFT(3, 1));
259        TEST_EXPECT_EQUAL(px->range_offset(halfPhasePstShiftNeg), PLANAR_QUARTER_SHIFT(1, 3));
260
261        TEST_EXPECT_EQUAL(py->range_offset(twoPhase),             PLANAR_QUARTER_SHIFT(0, 4)  - 1); // -1 due to limited range!
262        TEST_EXPECT_EQUAL(py->range_offset(halfPhase),            PLANAR_QUARTER_SHIFT(0, 2));
263        TEST_EXPECT_EQUAL(py->range_offset(halfPhasePreShiftPos), PLANAR_QUARTER_SHIFT(3, 3)/2);
264        TEST_EXPECT_EQUAL(py->range_offset(halfPhasePreShiftNeg), PLANAR_QUARTER_SHIFT(1, 1)/2);
265        TEST_EXPECT_EQUAL(py->range_offset(halfPhasePstShiftPos), PLANAR_QUARTER_SHIFT(1, 3));
266        TEST_EXPECT_EQUAL(py->range_offset(halfPhasePstShiftNeg), PLANAR_QUARTER_SHIFT(3, 1));
267
268        // test 2-dim-phase-scale and -shift (nan-content):
269        TEST_EXPECT_EQUAL(PonlyX->range_offset(twoPhase),             PLANAR_QUARTER_SHIFT(4,-4)); // = PLANAR_QUARTER_SHIFT(4, 0) - AW_PLANAR_COLORS
270        TEST_EXPECT_EQUAL(PonlyX->range_offset(halfPhase),            PLANAR_QUARTER_SHIFT(1, 0));
271        TEST_EXPECT_EQUAL(PonlyX->range_offset(halfPhasePreShiftPos), PLANAR_QUARTER_SHIFT(1, 0)/2);
272        TEST_EXPECT_EQUAL(PonlyX->range_offset(halfPhasePreShiftNeg), PLANAR_QUARTER_SHIFT(3, 0)/2);
273        TEST_EXPECT_EQUAL(PonlyX->range_offset(halfPhasePstShiftPos), PLANAR_QUARTER_SHIFT(2, 0));
274        TEST_EXPECT_EQUAL(PonlyX->range_offset(halfPhasePstShiftNeg), PLANAR_QUARTER_SHIFT(4,-4));
275
276        TEST_EXPECT_EQUAL(PonlyY->range_offset(twoPhase),             PLANAR_QUARTER_SHIFT(0, 4) - 1);
277        TEST_EXPECT_EQUAL(PonlyY->range_offset(halfPhase),            PLANAR_QUARTER_SHIFT(0, 1));
278        TEST_EXPECT_EQUAL(PonlyY->range_offset(halfPhasePreShiftPos), PLANAR_QUARTER_SHIFT(0, 1)/2);
279        TEST_EXPECT_EQUAL(PonlyY->range_offset(halfPhasePreShiftNeg), PLANAR_QUARTER_SHIFT(0, 3)/2);
280        TEST_EXPECT_EQUAL(PonlyY->range_offset(halfPhasePstShiftPos), PLANAR_QUARTER_SHIFT(0, 2));
281        TEST_EXPECT_EQUAL(PonlyY->range_offset(halfPhasePstShiftNeg), PLANAR_QUARTER_SHIFT(0, 4) - 1);
282    }
283
284    {
285        ShadedValue sval0 = ValueTuple::make(0, 0, 0);
286
287        ShadedValue px = ValueTuple::make(1, 0, 0);
288        ShadedValue py = ValueTuple::make(0, 1, 0);
289        ShadedValue pz = ValueTuple::make(0, 0, 1);
290
291        ShadedValue PonlyX = ValueTuple::make(0.5, NAN, NAN);
292        ShadedValue PonlyY = ValueTuple::make(NAN, 0.5, NAN);
293        ShadedValue PonlyZ = ValueTuple::make(NAN, NAN, 0.5);
294
295        TEST_EXPECT_EQUAL(sval0->range_offset(dontPhase), 0);
296
297        TEST_EXPECT_EQUAL(px->range_offset(dontPhase), (AW_SPATIAL_COLORS-1)*AW_SPATIAL_COLORS*AW_SPATIAL_COLORS);
298        TEST_EXPECT_EQUAL(py->range_offset(dontPhase), (AW_SPATIAL_COLORS-1)*AW_SPATIAL_COLORS);
299        TEST_EXPECT_EQUAL(pz->range_offset(dontPhase),  AW_SPATIAL_COLORS-1);
300
301        // partly undefined values produce a valid range-offset:
302        TEST_EXPECT_EQUAL(PonlyX->range_offset(dontPhase), (AW_SPATIAL_COLORS*AW_SPATIAL_COLORS*AW_SPATIAL_COLORS)/2);
303        TEST_EXPECT_EQUAL(PonlyY->range_offset(dontPhase), (AW_SPATIAL_COLORS*AW_SPATIAL_COLORS)/2);
304        TEST_EXPECT_EQUAL(PonlyZ->range_offset(dontPhase), AW_SPATIAL_COLORS/2);
305
306        // skipping tests for phasing SpatialTuple (hardly can understand test-results for PlanarTuple)
307    }
308}
309
310#endif // UNIT_TESTS
311
312// --------------------------------------------------------------------------------
313
314inline int CHECKED_RANGE_OFFSET(int off) {
315    is_assert(off>=0 && off<AW_RANGE_COLORS);
316    return off;
317}
318
319template<int RANGE_SIZE>
320inline int fixed_range_offset(float val) {
321    is_assert(val>=0.0 && val<=1.0); // val is output of Phaser
322    int off = val>=1.0 ? RANGE_SIZE-1 : val*RANGE_SIZE;
323    is_assert(off>=0 && off<RANGE_SIZE);
324    return off;
325}
326
327// --------------------------------------------------------------------------------
328
329#ifdef UNIT_TESTS
330#ifndef TEST_UNIT_H
331#include <test_unit.h>
332#endif
333
334void TEST_range_mapping() {
335    TEST_EXPECT_EQUAL(fixed_range_offset<4>(1.00), 3);
336    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.75), 3);
337    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.74), 2);
338    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.50), 2);
339    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.49), 1);
340    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.25), 1);
341    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.24), 0);
342    TEST_EXPECT_EQUAL(fixed_range_offset<4>(0.00), 0);
343
344    TEST_EXPECT_EQUAL(fixed_range_offset<3>(1.0),  2);
345    TEST_EXPECT_EQUAL(fixed_range_offset<3>(0.67), 2);
346    TEST_EXPECT_EQUAL(fixed_range_offset<3>(0.66), 1);
347    TEST_EXPECT_EQUAL(fixed_range_offset<3>(0.34), 1);
348    TEST_EXPECT_EQUAL(fixed_range_offset<3>(0.33), 0);
349    TEST_EXPECT_EQUAL(fixed_range_offset<3>(0.0),  0);
350}
351
352#endif // UNIT_TESTS
353
354// --------------------------------------------------------------------------------
355
356
357class NoTuple: public ValueTuple {
358public:
359    NoTuple() {}
360    ~NoTuple() OVERRIDE {}
361
362    bool is_defined() const OVERRIDE { return false; }
363    ValueTuple *clone() const OVERRIDE { return new NoTuple; }
364    int range_offset(const Phaser&) const OVERRIDE { is_assert(0); return -9999999; } // defines no range offset
365
366#if defined(UNIT_TESTS)
367    const char *inspect() const OVERRIDE { return "<undef>"; }
368#endif
369
370    // mixer:
371    ValueTuple *reverse_mix(float, const LinearTuple& other) const OVERRIDE;
372    ValueTuple *reverse_mix(float, const PlanarTuple& other) const OVERRIDE;
373    ValueTuple *reverse_mix(float, const SpatialTuple& other) const OVERRIDE;
374    ValueTuple *mix(float, const ValueTuple& other) const OVERRIDE { return other.clone(); }
375};
376
377class LinearTuple: public ValueTuple {
378    float val;
379
380public:
381    LinearTuple(float val_) : val(val_) {
382        is_assert(!is_nan_or_inf(val));
383    }
384    ~LinearTuple() OVERRIDE {}
385
386    bool is_defined() const OVERRIDE { return true; }
387    ValueTuple *clone() const OVERRIDE { return new LinearTuple(val); }
388    int range_offset(const Phaser& phaser) const OVERRIDE {  // returns int-offset into range [0 .. AW_RANGE_COLORS[
389        return CHECKED_RANGE_OFFSET(fixed_range_offset<AW_RANGE_COLORS>(phaser.rephase(val)));
390    }
391
392#if defined(UNIT_TESTS)
393    const char *inspect() const OVERRIDE {
394        static SmartCharPtr buf;
395        buf = GBS_global_string_copy("(%.3f)", val);
396        return &*buf;
397    }
398#endif
399
400    // mixer:
401    ValueTuple *reverse_mix(float other_ratio, const LinearTuple& other) const OVERRIDE {
402        return new LinearTuple(other_ratio*other.val + (1-other_ratio)*val);
403    }
404    ValueTuple *mix(float my_ratio, const ValueTuple& other) const OVERRIDE { return other.reverse_mix(my_ratio, *this); }
405};
406
407inline float mix_floats(float me, float my_ratio, float other) {
408    if (is_nan(me)) return other;
409    if (is_nan(other)) return me;
410    return my_ratio*me + (1-my_ratio)*other;
411}
412
413class PlanarTuple: public ValueTuple {
414    float val1, val2;
415
416public:
417    PlanarTuple(float val1_, float val2_) :
418        val1(val1_),
419        val2(val2_)
420    {
421        is_assert(!is_inf(val1));
422        is_assert(!is_inf(val2));
423        is_assert(!(is_nan(val1) && is_nan(val2))); // only NAN is unwanted
424    }
425    ~PlanarTuple() OVERRIDE {}
426
427    bool is_defined() const OVERRIDE { return true; }
428    ValueTuple *clone() const OVERRIDE { return new PlanarTuple(val1, val2); }
429    int range_offset(const Phaser& phaser) const OVERRIDE { // returns int-offset into range [0 .. AW_RANGE_COLORS[
430        int c1 = is_nan(val1) ? 0 : fixed_range_offset<AW_PLANAR_COLORS>(phaser.rephase(val1));
431        int c2 = is_nan(val2) ? 0 : fixed_range_offset<AW_PLANAR_COLORS>(phaser.rephase(val2));
432        return CHECKED_RANGE_OFFSET(c1*AW_PLANAR_COLORS + c2);
433    }
434
435#if defined(UNIT_TESTS)
436    const char *inspect() const OVERRIDE {
437        static SmartCharPtr buf;
438        buf = GBS_global_string_copy("(%.3f,%.3f)", val1, val2);
439        return &*buf;
440    }
441#endif
442
443    // mixer:
444    ValueTuple *reverse_mix(float other_ratio, const PlanarTuple& other) const OVERRIDE {
445        return new PlanarTuple(mix_floats(other.val1, other_ratio, val1),
446                               mix_floats(other.val2, other_ratio, val2));
447    }
448    ValueTuple *mix(float my_ratio, const ValueTuple& other) const OVERRIDE { return other.reverse_mix(my_ratio, *this); }
449};
450
451class SpatialTuple: public ValueTuple {
452    float val1, val2, val3;
453
454public:
455    SpatialTuple(float val1_, float val2_, float val3_) :
456        val1(val1_),
457        val2(val2_),
458        val3(val3_)
459    {
460        is_assert(!is_inf(val1));
461        is_assert(!is_inf(val2));
462        is_assert(!is_inf(val3));
463        is_assert(!(is_nan(val1) && is_nan(val2) && is_nan(val3))); // only NAN is unwanted
464    }
465    ~SpatialTuple() OVERRIDE {}
466
467    bool is_defined() const OVERRIDE { return true; }
468    ValueTuple *clone() const OVERRIDE { return new SpatialTuple(val1, val2, val3); }
469    int range_offset(const Phaser& phaser) const OVERRIDE { // returns int-offset into range [0 .. AW_RANGE_COLORS[
470        int c1 = is_nan(val1) ? 0 : fixed_range_offset<AW_SPATIAL_COLORS>(phaser.rephase(val1));
471        int c2 = is_nan(val2) ? 0 : fixed_range_offset<AW_SPATIAL_COLORS>(phaser.rephase(val2));
472        int c3 = is_nan(val3) ? 0 : fixed_range_offset<AW_SPATIAL_COLORS>(phaser.rephase(val3));
473        return CHECKED_RANGE_OFFSET((c1*AW_SPATIAL_COLORS + c2)*AW_SPATIAL_COLORS + c3);
474    }
475
476#if defined(UNIT_TESTS)
477    const char *inspect() const OVERRIDE {
478        static SmartCharPtr buf;
479        buf = GBS_global_string_copy("(%.3f,%.3f,%.3f)", val1, val2, val3);
480        return &*buf;
481    }
482#endif
483
484    // mixer:
485    ValueTuple *reverse_mix(float other_ratio, const SpatialTuple& other) const OVERRIDE {
486        return new SpatialTuple(mix_floats(other.val1, other_ratio, val1),
487                                mix_floats(other.val2, other_ratio, val2),
488                                mix_floats(other.val3, other_ratio, val3));
489    }
490    ValueTuple *mix(float my_ratio, const ValueTuple& other) const OVERRIDE { return other.reverse_mix(my_ratio, *this); }
491};
492
493
494// ---------------------------------
495//      mixer (late definition)
496
497ValueTuple *NoTuple::reverse_mix(float, const LinearTuple&  other) const { return other.clone(); }
498ValueTuple *NoTuple::reverse_mix(float, const PlanarTuple&  other) const { return other.clone(); }
499ValueTuple *NoTuple::reverse_mix(float, const SpatialTuple& other) const { return other.clone(); }
500
501// -----------------
502//      factory
503
504ValueTuple *ValueTuple::undefined() {
505    return new NoTuple;
506}
507ValueTuple *ValueTuple::make(float f) {
508    return is_nan(f) ? undefined() : new LinearTuple(f);
509}
510ValueTuple *ValueTuple::make(float f1, float f2) {
511    return (is_nan(f1) && is_nan(f2)) ? undefined() : new PlanarTuple(f1, f2);
512}
513ValueTuple *ValueTuple::make(float f1, float f2, float f3) {
514    return (is_nan(f1) && is_nan(f2) && is_nan(f3)) ? undefined() : new SpatialTuple(f1, f2, f3);
515}
516
Note: See TracBrowser for help on using the repository browser.