1 /*
2 * This file is a part of Luminance HDR package
3 * ----------------------------------------------------------------------
4 * Copyright (C) 2012 Davide Anastasia
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * ----------------------------------------------------------------------
20 */
21
22 #include <gtest/gtest.h>
23
24 #include <algorithm>
25 #include <numeric>
26 #include <boost/scoped_ptr.hpp>
27
28 #include "Libpfs/array2d.h"
29 #include "Libpfs/manip/shift.h"
30
31 #include "SeqInt.h"
32 #include "PrintArray2D.h"
33
34 using namespace pfs;
35
TEST(TestPfsShift,MinusMinus)36 TEST(TestPfsShift, MinusMinus)
37 {
38 const float ref[] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
39 0.f, 0.f, 0.f, 1.f, 2.f, 3.f,
40 0.f, 0.f, 6.f, 7.f, 8.f, 9.f,
41 0.f, 0.f, 12.f, 13.f, 14.f, 15.f,
42 0.f, 0.f, 18.f, 19.f, 20.f, 21.f};
43
44 size_t rows = 5;
45 size_t cols = 6;
46
47 Array2Df input(cols, rows);
48 std::generate(input.begin(), input.end(), SeqInt());
49
50 Array2Df output(cols, rows);
51
52 shift(input, -2, -1, output);
53
54 const float* outData = output.data();
55
56 // print(input);
57 // print(*output);
58
59 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
60 {
61 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
62 }
63 }
64
TEST(TestPfsShift,PlusMinus)65 TEST(TestPfsShift, PlusMinus)
66 {
67 const float ref[] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
68 2.f, 3.f, 4.f, 5.f, 0.f, 0.f,
69 8.f, 9.f, 10.f, 11.f, 0.f, 0.f,
70 14.f, 15.f, 16.f, 17.f, 0.f, 0.f,
71 20.f, 21.f, 22.f, 23.f, 0.f, 0.f};
72
73 size_t rows = 5;
74 size_t cols = 6;
75
76 Array2Df input(cols, rows);
77 std::generate(input.begin(), input.end(), SeqInt());
78
79 Array2Df output(cols, rows);
80 shift(input, 2, -1, output);
81
82 const float* outData = output.data();
83
84 // print(input);
85 // print(*output);
86
87 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
88 {
89 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
90 }
91 }
92
TEST(TestPfsShift,StillMinus)93 TEST(TestPfsShift, StillMinus)
94 {
95 const float ref[] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
96 0.f, 1.f, 2.f, 3.f, 4.f, 5.f,
97 6.f, 7.f, 8.f, 9.f, 10.f, 11.f,
98 12.f, 13.f, 14.f, 15.f, 16.f, 17.f,
99 18.f, 19.f, 20.f, 21.f, 22.f, 23.f};
100
101 size_t rows = 5;
102 size_t cols = 6;
103
104 Array2Df input(cols, rows);
105 std::generate(input.begin(), input.end(), SeqInt());
106
107 Array2Df output(cols, rows);
108 shift(input, 0, -1, output);
109
110 const float* outData = output.data();
111
112 // print(input);
113 // print(*output);
114
115 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
116 {
117 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
118 }
119 }
120
TEST(TestPfsShift,MinusPlus)121 TEST(TestPfsShift, MinusPlus)
122 {
123 const float ref[] = {0.f, 0.f, 6.f, 7.f, 8.f, 9.f,
124 0.f, 0.f, 12.f, 13.f, 14.f, 15.f,
125 0.f, 0.f, 18.f, 19.f, 20.f, 21.f,
126 0.f, 0.f, 24.f, 25.f, 26.f, 27.f,
127 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
128 size_t rows = 5;
129 size_t cols = 6;
130
131 Array2Df input(cols, rows);
132 std::generate(input.begin(), input.end(), SeqInt());
133
134 Array2Df output(cols, rows);
135 shift(input, -2, 1, output);
136
137 const float* outData = output.data();
138
139 // print(input);
140 // print(*output);
141
142 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
143 {
144 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
145 }
146 }
147
TEST(TestPfsShift,PlusPlus)148 TEST(TestPfsShift, PlusPlus)
149 {
150 const float ref[] = {8.f, 9.f, 10.f, 11.f, 0.f, 0.f,
151 14.f, 15.f, 16.f, 17.f, 0.f, 0.f,
152 20.f, 21.f, 22.f, 23.f, 0.f, 0.f,
153 26.f, 27.f, 28.f, 29.f, 0.f, 0.f,
154 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
155
156 size_t rows = 5;
157 size_t cols = 6;
158
159 Array2Df input(cols, rows);
160 std::generate(input.begin(), input.end(), SeqInt());
161
162 Array2Df output(cols, rows);
163 shift(input, 2, 1, output);
164
165 const float* outData = output.data();
166
167 // print(input);
168 // print(*output);
169
170 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
171 {
172 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
173 }
174 }
175
TEST(TestPfsShift,StillStill)176 TEST(TestPfsShift, StillStill)
177 {
178 const float ref[] = {0.f, 1.f, 2.f, 3.f, 4.f, 5.f,
179 6.f, 7.f, 8.f, 9.f, 10.f, 11.f,
180 12.f, 13.f, 14.f, 15.f, 16.f, 17.f,
181 18.f, 19.f, 20.f, 21.f, 22.f, 23.f,
182 24.f, 25.f, 26.f, 27.f, 28.f, 29.f};
183
184 size_t rows = 5;
185 size_t cols = 6;
186
187 Array2Df input(cols, rows);
188 std::generate(input.begin(), input.end(), SeqInt());
189
190 Array2Df output(cols, rows);
191 shift(input, 0, 0, output);
192
193 const float* outData = output.data();
194
195 // print(input);
196 // print(*output);
197
198 for (int idx = 0; idx < static_cast<int>(rows*cols); idx++)
199 {
200 ASSERT_NEAR(ref[idx], outData[idx], 10e-5f);
201 }
202 }
203