ACloudViewer  3.9.4
A Modern Library for 3D Data Processing
camera_test.cc
Go to the documentation of this file.
1 // Copyright (c) 2018, ETH Zurich and UNC Chapel Hill.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 //
7 // * Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 //
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 //
14 // * Neither the name of ETH Zurich and UNC Chapel Hill nor the names of
15 // its contributors may be used to endorse or promote products derived
16 // from this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
22 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28 // POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Author: Johannes L. Schoenberger (jsch-at-demuc-dot-de)
31 
32 #define TEST_NAME "base/camera"
33 #include "util/testing.h"
34 
35 #include "base/camera.h"
36 #include "base/camera_models.h"
37 
38 using namespace colmap;
39 
40 BOOST_AUTO_TEST_CASE(TestEmpty) {
41  Camera camera;
42  BOOST_CHECK_EQUAL(camera.CameraId(), kInvalidCameraId);
43  BOOST_CHECK_EQUAL(camera.ModelId(), kInvalidCameraModelId);
44  BOOST_CHECK_EQUAL(camera.ModelName(), "");
45  BOOST_CHECK_EQUAL(camera.Width(), 0);
46  BOOST_CHECK_EQUAL(camera.Height(), 0);
47  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), false);
48  BOOST_CHECK_THROW(camera.FocalLengthIdxs(), std::domain_error);
49  BOOST_CHECK_THROW(camera.ParamsInfo(), std::domain_error);
50  BOOST_CHECK_EQUAL(camera.ParamsToString(), "");
51  BOOST_CHECK_EQUAL(camera.NumParams(), 0);
52  BOOST_CHECK_EQUAL(camera.Params().size(), 0);
53  BOOST_CHECK_EQUAL(camera.ParamsData(), camera.Params().data());
54 }
55 
56 BOOST_AUTO_TEST_CASE(TestCameraId) {
57  Camera camera;
58  BOOST_CHECK_EQUAL(camera.CameraId(), kInvalidCameraId);
59  camera.SetCameraId(1);
60  BOOST_CHECK_EQUAL(camera.CameraId(), 1);
61 }
62 
63 BOOST_AUTO_TEST_CASE(TestModelId) {
64  Camera camera;
65  BOOST_CHECK_EQUAL(camera.ModelId(), kInvalidCameraModelId);
66  BOOST_CHECK_EQUAL(camera.ModelName(), "");
67  camera.SetModelId(SimplePinholeCameraModel::model_id);
68  BOOST_CHECK_EQUAL(camera.ModelId(),
69  static_cast<int>(SimplePinholeCameraModel::model_id));
70  BOOST_CHECK_EQUAL(camera.ModelName(), "SIMPLE_PINHOLE");
71  BOOST_CHECK_EQUAL(camera.NumParams(), SimplePinholeCameraModel::num_params);
72  camera.SetModelIdFromName("SIMPLE_RADIAL");
73  BOOST_CHECK_EQUAL(camera.ModelId(),
74  static_cast<int>(SimpleRadialCameraModel::model_id));
75  BOOST_CHECK_EQUAL(camera.ModelName(), "SIMPLE_RADIAL");
76  BOOST_CHECK_EQUAL(camera.NumParams(), SimpleRadialCameraModel::num_params);
77 }
78 
79 BOOST_AUTO_TEST_CASE(TestWidthHeight) {
80  Camera camera;
81  BOOST_CHECK_EQUAL(camera.Width(), 0);
82  BOOST_CHECK_EQUAL(camera.Height(), 0);
83  camera.SetWidth(1);
84  BOOST_CHECK_EQUAL(camera.Width(), 1);
85  BOOST_CHECK_EQUAL(camera.Height(), 0);
86  camera.SetHeight(1);
87  BOOST_CHECK_EQUAL(camera.Width(), 1);
88  BOOST_CHECK_EQUAL(camera.Height(), 1);
89 }
90 
91 BOOST_AUTO_TEST_CASE(TestFocalLength) {
92  Camera camera;
93  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
94  BOOST_CHECK_EQUAL(camera.FocalLength(), 1.0);
95  camera.SetFocalLength(2.0);
96  BOOST_CHECK_EQUAL(camera.FocalLength(), 2.0);
97  camera.InitializeWithId(PinholeCameraModel::model_id, 1.0, 1, 1);
98  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 1.0);
99  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 1.0);
100  camera.SetFocalLengthX(2.0);
101  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 2.0);
102  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 1.0);
103  camera.SetFocalLengthY(2.0);
104  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 2.0);
105  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 2.0);
106 }
107 
108 BOOST_AUTO_TEST_CASE(TestPriorFocalLength) {
109  Camera camera;
110  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), false);
111  camera.SetPriorFocalLength(true);
112  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), true);
113  camera.SetPriorFocalLength(false);
114  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), false);
115 }
116 
117 BOOST_AUTO_TEST_CASE(TestPrincipalPoint) {
118  Camera camera;
119  camera.InitializeWithId(PinholeCameraModel::model_id, 1.0, 1, 1);
120  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 0.5);
121  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
122  camera.SetPrincipalPointX(2.0);
123  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 2.0);
124  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
125  camera.SetPrincipalPointY(2.0);
126  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 2.0);
127  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 2.0);
128 }
129 
130 BOOST_AUTO_TEST_CASE(TestParamIdxs) {
131  Camera camera;
132  BOOST_CHECK_THROW(camera.FocalLengthIdxs(), std::domain_error);
133  BOOST_CHECK_THROW(camera.PrincipalPointIdxs(), std::domain_error);
134  BOOST_CHECK_THROW(camera.ExtraParamsIdxs(), std::domain_error);
135  camera.SetModelId(FullOpenCVCameraModel::model_id);
136  BOOST_CHECK_EQUAL(camera.FocalLengthIdxs().size(), 2);
137  BOOST_CHECK_EQUAL(camera.PrincipalPointIdxs().size(), 2);
138  BOOST_CHECK_EQUAL(camera.ExtraParamsIdxs().size(), 8);
139 }
140 
141 BOOST_AUTO_TEST_CASE(TestCalibrationMatrix) {
142  Camera camera;
143  camera.InitializeWithId(PinholeCameraModel::model_id, 1.0, 1, 1);
144  const Eigen::Matrix3d K = camera.CalibrationMatrix();
145  Eigen::Matrix3d K_ref;
146  K_ref << 1, 0, 0.5, 0, 1, 0.5, 0, 0, 1;
147  BOOST_CHECK_EQUAL(K, K_ref);
148 }
149 
150 BOOST_AUTO_TEST_CASE(TestParamsInfo) {
151  Camera camera;
152  BOOST_CHECK_THROW(camera.ParamsInfo(), std::domain_error);
153  camera.SetModelId(SimpleRadialCameraModel::model_id);
154  BOOST_CHECK_EQUAL(camera.ParamsInfo(), "f, cx, cy, k");
155 }
156 
157 BOOST_AUTO_TEST_CASE(TestParams) {
158  Camera camera;
159  BOOST_CHECK_EQUAL(camera.NumParams(), 0);
160  BOOST_CHECK_EQUAL(camera.Params().size(), camera.NumParams());
161  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
162  BOOST_CHECK_EQUAL(camera.NumParams(), 3);
163  BOOST_CHECK_EQUAL(camera.Params().size(), camera.NumParams());
164  BOOST_CHECK_EQUAL(camera.ParamsData(), camera.Params().data());
165  BOOST_CHECK_EQUAL(camera.Params(0), 1.0);
166  BOOST_CHECK_EQUAL(camera.Params(1), 0.5);
167  BOOST_CHECK_EQUAL(camera.Params(2), 0.5);
168  BOOST_CHECK_EQUAL(camera.Params()[0], 1.0);
169  BOOST_CHECK_EQUAL(camera.Params()[1], 0.5);
170  BOOST_CHECK_EQUAL(camera.Params()[2], 0.5);
171  camera.SetParams({2.0, 1.0, 1.0});
172  BOOST_CHECK_EQUAL(camera.Params(0), 2.0);
173  BOOST_CHECK_EQUAL(camera.Params(1), 1.0);
174  BOOST_CHECK_EQUAL(camera.Params(2), 1.0);
175 }
176 
177 BOOST_AUTO_TEST_CASE(TestParamsToString) {
178  Camera camera;
179  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
180  BOOST_CHECK_EQUAL(camera.ParamsToString(), "1.000000, 0.500000, 0.500000");
181 }
182 
183 BOOST_AUTO_TEST_CASE(TestParamsFromString) {
184  Camera camera;
185  camera.SetModelId(SimplePinholeCameraModel::model_id);
186  BOOST_CHECK(camera.SetParamsFromString("1.000000, 0.500000, 0.500000"));
187  const std::vector<double> params{1.0, 0.5, 0.5};
188  BOOST_CHECK_EQUAL_COLLECTIONS(camera.Params().begin(), camera.Params().end(),
189  params.begin(), params.end());
190  BOOST_CHECK(!camera.SetParamsFromString("1.000000, 0.500000"));
191  BOOST_CHECK_EQUAL_COLLECTIONS(camera.Params().begin(), camera.Params().end(),
192  params.begin(), params.end());
193 }
194 
195 BOOST_AUTO_TEST_CASE(TestVerifyParams) {
196  Camera camera;
197  BOOST_CHECK_THROW(camera.VerifyParams(), std::domain_error);
198  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
199  BOOST_CHECK_EQUAL(camera.VerifyParams(), true);
200  camera.Params().resize(2);
201  BOOST_CHECK_EQUAL(camera.VerifyParams(), false);
202 }
203 
204 BOOST_AUTO_TEST_CASE(TestIsUndistorted) {
205  Camera camera;
206  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
207  BOOST_CHECK(camera.IsUndistorted());
208  camera.InitializeWithId(SimpleRadialCameraModel::model_id, 1.0, 1, 1);
209  BOOST_CHECK(camera.IsUndistorted());
210  camera.SetParams({1.0, 0.5, 0.5, 0.005});
211  BOOST_CHECK(!camera.IsUndistorted());
212  camera.InitializeWithId(RadialCameraModel::model_id, 1.0, 1, 1);
213  BOOST_CHECK(camera.IsUndistorted());
214  camera.SetParams({1.0, 0.5, 0.5, 0.0, 0.005});
215  BOOST_CHECK(!camera.IsUndistorted());
216  camera.InitializeWithId(OpenCVCameraModel::model_id, 1.0, 1, 1);
217  BOOST_CHECK(camera.IsUndistorted());
218  camera.SetParams({1.0, 1.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.001});
219  BOOST_CHECK(!camera.IsUndistorted());
220  camera.InitializeWithId(FullOpenCVCameraModel::model_id, 1.0, 1, 1);
221  BOOST_CHECK(camera.IsUndistorted());
222  camera.SetParams({1.0, 1.0, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.001});
223  BOOST_CHECK(!camera.IsUndistorted());
224 }
225 
226 BOOST_AUTO_TEST_CASE(TestHasBogusParams) {
227  Camera camera;
228  BOOST_CHECK_THROW(camera.HasBogusParams(0.0, 0.0, 0.0), std::domain_error);
229  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
230  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 1.0), false);
231  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 0.0), false);
232  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 0.99, 1.0), true);
233  BOOST_CHECK_EQUAL(camera.HasBogusParams(1.01, 1.1, 1.0), true);
234  camera.InitializeWithId(SimpleRadialCameraModel::model_id, 1.0, 1, 1);
235  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 1.0), false);
236  camera.Params(3) = 1.01;
237  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 1.0), true);
238  camera.Params(3) = -0.5;
239  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 1.0), false);
240  camera.Params(3) = -1.01;
241  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 1.1, 1.0), true);
242 }
243 
244 BOOST_AUTO_TEST_CASE(TestInitializeWithId) {
245  Camera camera;
246  camera.InitializeWithId(SimplePinholeCameraModel::model_id, 1.0, 1, 1);
247  BOOST_CHECK_EQUAL(camera.CameraId(), kInvalidCameraId);
248  BOOST_CHECK_EQUAL(camera.ModelId(),
249  static_cast<int>(SimplePinholeCameraModel::model_id));
250  BOOST_CHECK_EQUAL(camera.ModelName(), "SIMPLE_PINHOLE");
251  BOOST_CHECK_EQUAL(camera.Width(), 1);
252  BOOST_CHECK_EQUAL(camera.Height(), 1);
253  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), false);
254  BOOST_CHECK_EQUAL(camera.FocalLengthIdxs().size(), 1);
255  BOOST_CHECK_EQUAL(camera.PrincipalPointIdxs().size(), 2);
256  BOOST_CHECK_EQUAL(camera.ExtraParamsIdxs().size(), 0);
257  BOOST_CHECK_EQUAL(camera.ParamsInfo(), "f, cx, cy");
258  BOOST_CHECK_EQUAL(camera.ParamsToString(), "1.000000, 0.500000, 0.500000");
259  BOOST_CHECK_EQUAL(camera.FocalLength(), 1.0);
260  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 0.5);
261  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
262  BOOST_CHECK_EQUAL(camera.VerifyParams(), true);
263  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 2.0, 1.0), false);
264  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 0.5, 1.0), true);
265  BOOST_CHECK_EQUAL(camera.NumParams(),
266  static_cast<int>(SimplePinholeCameraModel::num_params));
267  BOOST_CHECK_EQUAL(camera.Params().size(),
268  static_cast<int>(SimplePinholeCameraModel::num_params));
269 }
270 
271 BOOST_AUTO_TEST_CASE(TestInitializeWithName) {
272  Camera camera;
273  camera.InitializeWithName("SIMPLE_PINHOLE", 1.0, 1, 1);
274  BOOST_CHECK_EQUAL(camera.CameraId(), kInvalidCameraId);
275  BOOST_CHECK_EQUAL(camera.ModelId(),
276  static_cast<int>(SimplePinholeCameraModel::model_id));
277  BOOST_CHECK_EQUAL(camera.ModelName(), "SIMPLE_PINHOLE");
278  BOOST_CHECK_EQUAL(camera.Width(), 1);
279  BOOST_CHECK_EQUAL(camera.Height(), 1);
280  BOOST_CHECK_EQUAL(camera.HasPriorFocalLength(), false);
281  BOOST_CHECK_EQUAL(camera.FocalLengthIdxs().size(), 1);
282  BOOST_CHECK_EQUAL(camera.PrincipalPointIdxs().size(), 2);
283  BOOST_CHECK_EQUAL(camera.ExtraParamsIdxs().size(), 0);
284  BOOST_CHECK_EQUAL(camera.ParamsInfo(), "f, cx, cy");
285  BOOST_CHECK_EQUAL(camera.ParamsToString(), "1.000000, 0.500000, 0.500000");
286  BOOST_CHECK_EQUAL(camera.FocalLength(), 1.0);
287  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 0.5);
288  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
289  BOOST_CHECK_EQUAL(camera.VerifyParams(), true);
290  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 2.0, 1.0), false);
291  BOOST_CHECK_EQUAL(camera.HasBogusParams(0.1, 0.5, 1.0), true);
292  BOOST_CHECK_EQUAL(camera.NumParams(),
293  static_cast<int>(SimplePinholeCameraModel::num_params));
294  BOOST_CHECK_EQUAL(camera.Params().size(),
295  static_cast<int>(SimplePinholeCameraModel::num_params));
296 }
297 
298 BOOST_AUTO_TEST_CASE(TestImageToWorld) {
299  Camera camera;
300  BOOST_CHECK_THROW(camera.ImageToWorld(Eigen::Vector2d::Zero()),
301  std::domain_error);
302  camera.InitializeWithName("SIMPLE_PINHOLE", 1.0, 1, 1);
303  BOOST_CHECK_EQUAL(camera.ImageToWorld(Eigen::Vector2d(0.0, 0.0))(0), -0.5);
304  BOOST_CHECK_EQUAL(camera.ImageToWorld(Eigen::Vector2d(0.0, 0.0))(1), -0.5);
305  BOOST_CHECK_EQUAL(camera.ImageToWorld(Eigen::Vector2d(0.5, 0.5))(0), 0.0);
306  BOOST_CHECK_EQUAL(camera.ImageToWorld(Eigen::Vector2d(0.5, 0.5))(1), 0.0);
307 }
308 
309 BOOST_AUTO_TEST_CASE(TestImageToWorldThreshold) {
310  Camera camera;
311  BOOST_CHECK_THROW(camera.ImageToWorldThreshold(0), std::domain_error);
312  camera.InitializeWithName("SIMPLE_PINHOLE", 1.0, 1, 1);
313  BOOST_CHECK_EQUAL(camera.ImageToWorldThreshold(0), 0);
314  BOOST_CHECK_EQUAL(camera.ImageToWorldThreshold(1), 1);
315  camera.SetFocalLength(2.0);
316  BOOST_CHECK_EQUAL(camera.ImageToWorldThreshold(1), 0.5);
317  camera.InitializeWithName("PINHOLE", 1.0, 1, 1);
318  camera.SetFocalLengthY(3.0);
319  BOOST_CHECK_EQUAL(camera.ImageToWorldThreshold(1), 0.5);
320 }
321 
322 BOOST_AUTO_TEST_CASE(TestWorldToImage) {
323  Camera camera;
324  BOOST_CHECK_THROW(camera.WorldToImage(Eigen::Vector2d::Zero()),
325  std::domain_error);
326  camera.InitializeWithName("SIMPLE_PINHOLE", 1.0, 1, 1);
327  BOOST_CHECK_EQUAL(camera.WorldToImage(Eigen::Vector2d(0.0, 0.0))(0), 0.5);
328  BOOST_CHECK_EQUAL(camera.WorldToImage(Eigen::Vector2d(0.0, 0.0))(1), 0.5);
329  BOOST_CHECK_EQUAL(camera.WorldToImage(Eigen::Vector2d(-0.5, -0.5))(0), 0.0);
330  BOOST_CHECK_EQUAL(camera.WorldToImage(Eigen::Vector2d(-0.5, -0.5))(1), 0.0);
331 }
332 
333 BOOST_AUTO_TEST_CASE(TestRescale) {
334  Camera camera;
335  camera.InitializeWithName("SIMPLE_PINHOLE", 1.0, 1, 1);
336  camera.Rescale(2.0);
337  BOOST_CHECK_EQUAL(camera.Width(), 2);
338  BOOST_CHECK_EQUAL(camera.Height(), 2);
339  BOOST_CHECK_EQUAL(camera.FocalLength(), 2);
340  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 1);
341  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 1);
342 
343  camera.InitializeWithName("PINHOLE", 1.0, 1, 1);
344  camera.Rescale(2.0);
345  BOOST_CHECK_EQUAL(camera.Width(), 2);
346  BOOST_CHECK_EQUAL(camera.Height(), 2);
347  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 2);
348  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 2);
349  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 1);
350  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 1);
351 
352  camera.InitializeWithName("PINHOLE", 1.0, 2, 2);
353  camera.Rescale(0.5);
354  BOOST_CHECK_EQUAL(camera.Width(), 1);
355  BOOST_CHECK_EQUAL(camera.Height(), 1);
356  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 0.5);
357  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 0.5);
358  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 0.5);
359  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
360 
361  camera.InitializeWithName("PINHOLE", 1.0, 2, 2);
362  camera.Rescale(1, 1);
363  BOOST_CHECK_EQUAL(camera.Width(), 1);
364  BOOST_CHECK_EQUAL(camera.Height(), 1);
365  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 0.5);
366  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 0.5);
367  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 0.5);
368  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 0.5);
369 
370  camera.InitializeWithName("PINHOLE", 1.0, 2, 2);
371  camera.Rescale(4, 4);
372  BOOST_CHECK_EQUAL(camera.Width(), 4);
373  BOOST_CHECK_EQUAL(camera.Height(), 4);
374  BOOST_CHECK_EQUAL(camera.FocalLengthX(), 2);
375  BOOST_CHECK_EQUAL(camera.FocalLengthY(), 2);
376  BOOST_CHECK_EQUAL(camera.PrincipalPointX(), 2);
377  BOOST_CHECK_EQUAL(camera.PrincipalPointY(), 2);
378 }
camera_models.h
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(TestEmpty)
Definition: camera_test.cc:40
colmap::Camera::SetWidth
void SetWidth(const size_t width)
Definition: camera.h:164
colmap::Camera::VerifyParams
bool VerifyParams() const
Definition: camera.cc:182
colmap::Camera::InitializeWithName
void InitializeWithName(const std::string &model_name, const double focal_length, const size_t width, const size_t height)
Definition: camera.cc:212
colmap::Camera::FocalLengthY
double FocalLengthY() const
Definition: camera.cc:121
colmap::Camera::InitializeWithId
void InitializeWithId(const int model_id, const double focal_length, const size_t width, const size_t height)
Definition: camera.cc:203
colmap::Camera::ImageToWorld
Eigen::Vector2d ImageToWorld(const Eigen::Vector2d &image_point) const
Definition: camera.cc:219
colmap::Camera::SetPriorFocalLength
void SetPriorFocalLength(const bool prior)
Definition: camera.h:170
colmap::Camera::SetModelIdFromName
void SetModelIdFromName(const std::string &model_name)
Definition: camera.cc:57
colmap::Camera::Params
const std::vector< double > & Params() const
Definition: camera.h:176
colmap::Camera::ImageToWorldThreshold
double ImageToWorldThreshold(const double threshold) const
Definition: camera.cc:226
colmap::Camera::SetParamsFromString
bool SetParamsFromString(const std::string &string)
Definition: camera.cc:172
colmap::Camera::CameraId
camera_t CameraId() const
Definition: camera.h:154
colmap::Camera::ModelName
std::string ModelName() const
Definition: camera.cc:49
colmap::Camera::ModelId
int ModelId() const
Definition: camera.h:158
colmap::Camera::SetPrincipalPointX
void SetPrincipalPointX(const double ppx)
Definition: camera.cc:158
colmap::Camera::ParamsToString
std::string ParamsToString() const
Definition: camera.cc:170
colmap::Camera::SetFocalLengthX
void SetFocalLengthX(const double focal_length_x)
Definition: camera.cc:134
colmap::Camera::PrincipalPointIdxs
const std::vector< size_t > & PrincipalPointIdxs() const
Definition: camera.cc:67
colmap::Camera::Rescale
void Rescale(const double scale)
Definition: camera.cc:237
colmap::Camera::SetParams
void SetParams(const std::vector< double > &params)
Definition: camera.h:188
colmap::Camera::SetFocalLengthY
void SetFocalLengthY(const double focal_length_y)
Definition: camera.cc:140
colmap::Camera::SetFocalLength
void SetFocalLength(const double focal_length)
Definition: camera.cc:127
colmap::Camera::HasPriorFocalLength
bool HasPriorFocalLength() const
Definition: camera.h:168
colmap::Camera::NumParams
size_t NumParams() const
Definition: camera.h:174
colmap::Camera::HasBogusParams
bool HasBogusParams(const double min_focal_length_ratio, const double max_focal_length_ratio, const double max_extra_param) const
Definition: camera.cc:186
colmap::Camera::FocalLength
double FocalLength() const
Definition: camera.cc:109
colmap::Camera::SetPrincipalPointY
void SetPrincipalPointY(const double ppy)
Definition: camera.cc:164
colmap::Camera::SetCameraId
void SetCameraId(const camera_t camera_id)
Definition: camera.h:156
colmap::Camera::ParamsInfo
std::string ParamsInfo() const
Definition: camera.cc:96
colmap::Camera::ExtraParamsIdxs
const std::vector< size_t > & ExtraParamsIdxs() const
Definition: camera.cc:71
colmap::Camera::CalibrationMatrix
Eigen::Matrix3d CalibrationMatrix() const
Definition: camera.cc:75
colmap::Camera::FocalLengthX
double FocalLengthX() const
Definition: camera.cc:115
colmap::Camera::FocalLengthIdxs
const std::vector< size_t > & FocalLengthIdxs() const
Definition: camera.cc:63
colmap::Camera::PrincipalPointX
double PrincipalPointX() const
Definition: camera.cc:146
colmap::Camera::WorldToImage
Eigen::Vector2d WorldToImage(const Eigen::Vector2d &world_point) const
Definition: camera.cc:230
colmap::Camera::Width
size_t Width() const
Definition: camera.h:160
colmap::Camera::PrincipalPointY
double PrincipalPointY() const
Definition: camera.cc:152
colmap::Camera::Height
size_t Height() const
Definition: camera.h:162
colmap::Camera::ParamsData
const double * ParamsData() const
Definition: camera.h:184
colmap::Camera::SetHeight
void SetHeight(const size_t height)
Definition: camera.h:166
colmap::Camera::SetModelId
void SetModelId(const int model_id)
Definition: camera.cc:51
colmap::Camera::IsUndistorted
bool IsUndistorted() const
Definition: camera.cc:194
colmap::kInvalidCameraModelId
static const int kInvalidCameraModelId
Definition: camera_models.h:55
colmap::kInvalidCameraId
const camera_t kInvalidCameraId
Definition: types.h:75
colmap::OpenCVCameraModel::model_id
static const int model_id
Definition: camera_models.h:226
colmap::PinholeCameraModel::model_id
static const int model_id
Definition: camera_models.h:180
colmap::RadialCameraModel::model_id
static const int model_id
Definition: camera_models.h:210
colmap::SimplePinholeCameraModel::num_params
static const size_t num_params
Definition: camera_models.h:167
colmap::SimpleRadialCameraModel::num_params
static const size_t num_params
Definition: camera_models.h:196