Add an FFT convolution effect.
[movit] / slice_effect_test.cpp
1 // Unit tests for SliceEffect.
2
3 #include <GL/glew.h>
4
5 #include "effect_chain.h"
6 #include "flat_input.h"
7 #include "gtest/gtest.h"
8 #include "image_format.h"
9 #include "input.h"
10 #include "slice_effect.h"
11 #include "test_util.h"
12
13 namespace movit {
14
15 TEST(SliceEffectTest, Identity) {
16         const int size = 3, output_size = 4;
17         float data[size * size] = {
18                 0.0f, 0.1f, 0.2f,
19                 0.4f, 0.3f, 0.8f,
20                 0.5f, 0.2f, 0.1f,
21         };
22         float expected_data[output_size * size] = {
23                 0.0f, 0.1f, 0.2f, 0.2f,
24                 0.4f, 0.3f, 0.8f, 0.8f,
25                 0.5f, 0.2f, 0.1f, 0.1f,
26         };
27         float out_data[output_size * size];
28
29         EffectChainTester tester(NULL, output_size, size, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
30         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, size, size);
31
32         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
33         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 2));
34         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 2));
35         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::HORIZONTAL));
36         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
37
38         expect_equal(expected_data, out_data, output_size, size);
39 }
40
41 TEST(SliceEffectTest, HorizontalOverlap) {
42         float data[5 * 2] = {
43                 0.0f, 0.1f,  0.2f, 0.3f,  0.4f,
44                 0.4f, 0.3f,  0.2f, 0.1f,  0.0f,
45         };
46         float expected_data[9 * 2] = {
47                 0.0f, 0.1f, 0.2f,  0.2f, 0.3f, 0.4f,  0.4f, 0.4f, 0.4f,
48                 0.4f, 0.3f, 0.2f,  0.2f, 0.1f, 0.0f,  0.0f, 0.0f, 0.0f,
49         };
50         float out_data[9 * 2];
51
52         EffectChainTester tester(NULL, 9, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
53         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, 5, 2);
54
55         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
56         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 2));
57         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 3));
58         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::HORIZONTAL));
59         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
60
61         expect_equal(expected_data, out_data, 9, 2);
62 }
63
64 TEST(SliceEffectTest, HorizontalDiscard) {
65         float data[6 * 2] = {
66                 0.0f, 0.1f, 0.2f,  0.2f, 0.3f, 0.4f,
67                 0.4f, 0.3f, 0.2f,  0.2f, 0.1f, 0.0f,
68         };
69         float expected_data[4 * 2] = {
70                 0.0f, 0.1f,  0.2f, 0.3f,
71                 0.4f, 0.3f,  0.2f, 0.1f,
72         };
73         float out_data[4 * 2];
74
75         EffectChainTester tester(NULL, 4, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
76         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, 6, 2);
77
78         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
79         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 3));
80         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 2));
81         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::HORIZONTAL));
82         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
83
84         expect_equal(expected_data, out_data, 4, 2);
85 }
86
87 TEST(SliceEffectTest, HorizontalOverlapWithOffset) {
88         float data[5 * 2] = {
89                 /* 0.0f, */ 0.0f,  0.1f, 0.2f,  0.3f, 0.4f,
90                 /* 0.4f, */ 0.4f,  0.3f, 0.2f,  0.1f, 0.0f,
91         };
92         float expected_data[9 * 2] = {
93                 0.0f, 0.0f, 0.1f,  0.1f, 0.2f, 0.3f,  0.3f, 0.4f, 0.4f,
94                 0.4f, 0.4f, 0.3f,  0.3f, 0.2f, 0.1f,  0.1f, 0.0f, 0.0f,
95         };
96         float out_data[9 * 2];
97
98         EffectChainTester tester(NULL, 9, 2, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
99         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, 5, 2);
100
101         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
102         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 2));
103         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 3));
104         ASSERT_TRUE(slice_effect->set_int("offset", -1));
105         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::HORIZONTAL));
106         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
107
108         expect_equal(expected_data, out_data, 9, 2);
109 }
110
111 TEST(SliceEffectTest, VerticalOverlapSlicesFromTop) {
112         float data[2 * 3] = {
113                 0.0f, 0.1f,
114                 0.4f, 0.3f,
115
116                 0.6f, 0.2f,
117         };
118         float expected_data[2 * 6] = {
119                 0.0f, 0.1f,
120                 0.4f, 0.3f,
121                 0.6f, 0.2f,
122
123                 0.6f, 0.2f,
124                 0.6f, 0.2f,
125                 0.6f, 0.2f,
126         };
127         float out_data[2 * 6];
128
129         EffectChainTester tester(NULL, 2, 6, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
130         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, 2, 3);
131
132         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
133         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 2));
134         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 3));
135         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::VERTICAL));
136         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
137
138         expect_equal(expected_data, out_data, 2, 6);
139 }
140
141 TEST(SliceEffectTest, VerticalOverlapOffsetsFromTop) {
142         float data[2 * 3] = {
143                 0.0f, 0.1f,
144                 0.4f, 0.3f,
145
146                 0.6f, 0.2f,
147         };
148         float expected_data[2 * 6] = {
149                 0.4f, 0.3f,
150                 0.6f, 0.2f,
151                 0.6f, 0.2f,
152
153                 0.6f, 0.2f,
154                 0.6f, 0.2f,
155                 0.6f, 0.2f,
156         };
157         float out_data[2 * 6];
158
159         EffectChainTester tester(NULL, 2, 6, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR);
160         tester.add_input(data, FORMAT_GRAYSCALE, COLORSPACE_sRGB, GAMMA_LINEAR, 2, 3);
161
162         Effect *slice_effect = tester.get_chain()->add_effect(new SliceEffect());
163         ASSERT_TRUE(slice_effect->set_int("input_slice_size", 2));
164         ASSERT_TRUE(slice_effect->set_int("output_slice_size", 3));
165         ASSERT_TRUE(slice_effect->set_int("offset", 1));
166         ASSERT_TRUE(slice_effect->set_int("direction", SliceEffect::VERTICAL));
167         tester.run(out_data, GL_RED, COLORSPACE_sRGB, GAMMA_LINEAR);
168
169         expect_equal(expected_data, out_data, 2, 6);
170 }
171
172 }  // namespace movit