Blender V5.3
libmv/simple_pipeline/camera_intrinsics.cc
Go to the documentation of this file.
1// Copyright (c) 2011 libmv authors.
2//
3// Permission is hereby granted, free of charge, to any person obtaining a copy
4// of this software and associated documentation files (the "Software"), to
5// deal in the Software without restriction, including without limitation the
6// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7// sell copies of the Software, and to permit persons to whom the Software is
8// furnished to do so, subject to the following conditions:
9//
10// The above copyright notice and this permission notice shall be included in
11// all copies or substantial portions of the Software.
12//
13// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19// IN THE SOFTWARE.
20
22
26
27namespace libmv {
28
29namespace internal {
30
32 : offset_(NULL), width_(0), height_(0), overscan_(0.0) {
33}
34
36 : offset_(NULL),
37 width_(from.width_),
38 height_(from.height_),
39 overscan_(from.overscan_) {
40 if (from.offset_) {
41 offset_ = new Offset[width_ * height_];
42 memcpy(offset_, from.offset_, sizeof(Offset) * width_ * height_);
43 }
44}
45
47 delete[] offset_;
48}
49
51 delete[] offset_;
52 offset_ = NULL;
53}
54
55} // namespace internal
56
58 : image_width_(0), image_height_(0), K_(Mat3::Identity()) {
59}
60
62 : image_width_(from.image_width_),
63 image_height_(from.image_height_),
64 K_(from.K_),
65 distort_(from.distort_),
66 undistort_(from.undistort_) {
67}
68
69// Set the image size in pixels.
70void CameraIntrinsics::SetImageSize(int width, int height) {
71 image_width_ = width;
72 image_height_ = height;
74}
75
76// Set the entire calibration matrix at once.
77void CameraIntrinsics::SetK(const Mat3 new_k) {
78 K_ = new_k;
80}
81
82// Set both x and y focal length in pixels.
83void CameraIntrinsics::SetFocalLength(double focal_x, double focal_y) {
84 K_(0, 0) = focal_x;
85 K_(1, 1) = focal_y;
87}
88
89// Set principal point in pixels.
90void CameraIntrinsics::SetPrincipalPoint(double cx, double cy) {
91 K_(0, 2) = cx;
92 K_(1, 2) = cy;
94}
95
97 double image_y,
98 double* normalized_x,
99 double* normalized_y) const {
100 *normalized_x = (image_x - principal_point_x()) / focal_length_x();
101 *normalized_y = (image_y - principal_point_y()) / focal_length_y();
102}
103
105 double normalized_y,
106 double* image_x,
107 double* image_y) const {
108 *image_x = normalized_x * focal_length_x() + principal_point_x();
109 *image_y = normalized_y * focal_length_y() + principal_point_y();
110}
111
112// Reset lookup grids after changing the distortion model.
114 distort_.Reset();
115 undistort_.Reset();
116}
117
118void CameraIntrinsics::Pack(PackedIntrinsics* packed_intrinsics) const {
119 packed_intrinsics->SetFocalLength(focal_length());
120 packed_intrinsics->SetPrincipalPoint(principal_point_x(),
122}
123
124void CameraIntrinsics::Unpack(const PackedIntrinsics& packed_intrinsics) {
125 SetFocalLength(packed_intrinsics.GetFocalLength(),
126 packed_intrinsics.GetFocalLength());
127
128 SetPrincipalPoint(packed_intrinsics.GetPrincipalPointX(),
129 packed_intrinsics.GetPrincipalPointY());
130}
131
132// Polynomial model.
133
138
145
147 double k2,
148 double k3) {
149 parameters_[OFFSET_K1] = k1;
150 parameters_[OFFSET_K2] = k2;
151 parameters_[OFFSET_K3] = k3;
153}
154
156 parameters_[OFFSET_P1] = p1;
157 parameters_[OFFSET_P2] = p2;
159}
160
162 double normalized_y,
163 double* image_x,
164 double* image_y) const {
169 k1(),
170 k2(),
171 k3(),
172 p1(),
173 p2(),
174 normalized_x,
175 normalized_y,
176 image_x,
177 image_y);
178}
179
181 double image_y,
182 double* normalized_x,
183 double* normalized_y) const {
188 k1(),
189 k2(),
190 k3(),
191 p1(),
192 p2(),
193 image_x,
194 image_y,
195 normalized_x,
196 normalized_y);
197}
198
200 PackedIntrinsics* packed_intrinsics) const {
201 CameraIntrinsics::Pack(packed_intrinsics);
202
203 packed_intrinsics->SetK1(k1());
204 packed_intrinsics->SetK2(k2());
205 packed_intrinsics->SetK3(k3());
206
207 packed_intrinsics->SetP1(p1());
208 packed_intrinsics->SetP2(p2());
209}
210
212 const PackedIntrinsics& packed_intrinsics) {
213 CameraIntrinsics::Unpack(packed_intrinsics);
214
215 SetRadialDistortion(packed_intrinsics.GetK1(),
216 packed_intrinsics.GetK2(),
217 packed_intrinsics.GetK3());
218
219 SetTangentialDistortion(packed_intrinsics.GetP1(), packed_intrinsics.GetP2());
220}
221
222// Division model.
223
227
233
235 parameters_[OFFSET_K1] = k1;
236 parameters_[OFFSET_K2] = k2;
238}
239
241 double normalized_y,
242 double* image_x,
243 double* image_y) const {
248 k1(),
249 k2(),
250 normalized_x,
251 normalized_y,
252 image_x,
253 image_y);
254}
255
257 double image_y,
258 double* normalized_x,
259 double* normalized_y) const {
264 k1(),
265 k2(),
266 image_x,
267 image_y,
268 normalized_x,
269 normalized_y);
270}
271
272void DivisionCameraIntrinsics::Pack(PackedIntrinsics* packed_intrinsics) const {
273 CameraIntrinsics::Pack(packed_intrinsics);
274
275 packed_intrinsics->SetK1(k1());
276 packed_intrinsics->SetK2(k2());
277}
278
280 const PackedIntrinsics& packed_intrinsics) {
281 CameraIntrinsics::Unpack(packed_intrinsics);
282
283 SetDistortion(packed_intrinsics.GetK1(), packed_intrinsics.GetK2());
284}
285
286// Nuke model.
287
292
298
300 parameters_[OFFSET_K1] = k1;
301 parameters_[OFFSET_K2] = k2;
303}
304
306 parameters_[OFFSET_P1] = p1;
307 parameters_[OFFSET_P2] = p2;
309}
310
312 double normalized_y,
313 double* image_x,
314 double* image_y) const {
319 image_width(),
320 image_height(),
321 k1(),
322 k2(),
323 p1(),
324 p2(),
325 normalized_x,
326 normalized_y,
327 image_x,
328 image_y);
329}
330
332 double image_y,
333 double* normalized_x,
334 double* normalized_y) const {
339 image_width(),
340 image_height(),
341 k1(),
342 k2(),
343 p1(),
344 p2(),
345 image_x,
346 image_y,
347 normalized_x,
348 normalized_y);
349}
350
351void NukeCameraIntrinsics::Pack(PackedIntrinsics* packed_intrinsics) const {
352 CameraIntrinsics::Pack(packed_intrinsics);
353
354 packed_intrinsics->SetK1(k1());
355 packed_intrinsics->SetK2(k2());
356
357 packed_intrinsics->SetP1(p1());
358 packed_intrinsics->SetP2(p2());
359}
360
361void NukeCameraIntrinsics::Unpack(const PackedIntrinsics& packed_intrinsics) {
362 CameraIntrinsics::Unpack(packed_intrinsics);
363
364 SetRadialDistortion(packed_intrinsics.GetK1(), packed_intrinsics.GetK2());
365 SetTangentialDistortion(packed_intrinsics.GetP1(), packed_intrinsics.GetP2());
366}
367
368// Brown model.
369
374
376 : CameraIntrinsics(from) {
377 SetRadialDistortion(from.k1(), from.k2(), from.k3(), from.k4());
378 SetTangentialDistortion(from.p1(), from.p2());
379}
380
382 double k2,
383 double k3,
384 double k4) {
385 parameters_[OFFSET_K1] = k1;
386 parameters_[OFFSET_K2] = k2;
387 parameters_[OFFSET_K3] = k3;
388 parameters_[OFFSET_K4] = k4;
390}
391
393 parameters_[OFFSET_P1] = p1;
394 parameters_[OFFSET_P2] = p2;
396}
397
399 double normalized_y,
400 double* image_x,
401 double* image_y) const {
406 k1(),
407 k2(),
408 k3(),
409 k4(),
410 p1(),
411 p2(),
412 normalized_x,
413 normalized_y,
414 image_x,
415 image_y);
416}
417
419 double image_y,
420 double* normalized_x,
421 double* normalized_y) const {
426 k1(),
427 k2(),
428 k3(),
429 k4(),
430 p1(),
431 p2(),
432 image_x,
433 image_y,
434 normalized_x,
435 normalized_y);
436}
437
438void BrownCameraIntrinsics::Pack(PackedIntrinsics* packed_intrinsics) const {
439 CameraIntrinsics::Pack(packed_intrinsics);
440
441 packed_intrinsics->SetK1(k1());
442 packed_intrinsics->SetK2(k2());
443 packed_intrinsics->SetK3(k3());
444 packed_intrinsics->SetK4(k4());
445
446 packed_intrinsics->SetP1(p1());
447 packed_intrinsics->SetP2(p2());
448}
449
450void BrownCameraIntrinsics::Unpack(const PackedIntrinsics& packed_intrinsics) {
451 CameraIntrinsics::Unpack(packed_intrinsics);
452
453 SetRadialDistortion(packed_intrinsics.GetK1(),
454 packed_intrinsics.GetK2(),
455 packed_intrinsics.GetK3(),
456 packed_intrinsics.GetK4());
457
458 SetTangentialDistortion(packed_intrinsics.GetP1(), packed_intrinsics.GetP2());
459}
460
461std::ostream& operator<<(std::ostream& os, const CameraIntrinsics& intrinsics) {
462 if (intrinsics.focal_length_x() == intrinsics.focal_length_x()) {
463 os << "f=" << intrinsics.focal_length();
464 } else {
465 os << "fx=" << intrinsics.focal_length_x()
466 << " fy=" << intrinsics.focal_length_y();
467 }
468 os << " cx=" << intrinsics.principal_point_x()
469 << " cy=" << intrinsics.principal_point_y()
470 << " w=" << intrinsics.image_width() << " h=" << intrinsics.image_height();
471
472#define PRINT_NONZERO_COEFFICIENT(intrinsics, coeff) \
473 { \
474 if (intrinsics->coeff() != 0.0) { \
475 os << " " #coeff "=" << intrinsics->coeff(); \
476 } \
477 } \
478 (void)0
479
480 switch (intrinsics.GetDistortionModelType()) {
482 const PolynomialCameraIntrinsics* polynomial_intrinsics =
483 static_cast<const PolynomialCameraIntrinsics*>(&intrinsics);
484 PRINT_NONZERO_COEFFICIENT(polynomial_intrinsics, k1);
485 PRINT_NONZERO_COEFFICIENT(polynomial_intrinsics, k2);
486 PRINT_NONZERO_COEFFICIENT(polynomial_intrinsics, k3);
487 PRINT_NONZERO_COEFFICIENT(polynomial_intrinsics, p1);
488 PRINT_NONZERO_COEFFICIENT(polynomial_intrinsics, p2);
489 break;
490 }
492 const DivisionCameraIntrinsics* division_intrinsics =
493 static_cast<const DivisionCameraIntrinsics*>(&intrinsics);
494 PRINT_NONZERO_COEFFICIENT(division_intrinsics, k1);
495 PRINT_NONZERO_COEFFICIENT(division_intrinsics, k2);
496 break;
497 }
499 const NukeCameraIntrinsics* nuke_intrinsics =
500 static_cast<const NukeCameraIntrinsics*>(&intrinsics);
501 PRINT_NONZERO_COEFFICIENT(nuke_intrinsics, k1);
502 PRINT_NONZERO_COEFFICIENT(nuke_intrinsics, k2);
503 PRINT_NONZERO_COEFFICIENT(nuke_intrinsics, p1);
504 PRINT_NONZERO_COEFFICIENT(nuke_intrinsics, p2);
505 break;
506 }
508 const BrownCameraIntrinsics* brown_intrinsics =
509 static_cast<const BrownCameraIntrinsics*>(&intrinsics);
510 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, k1);
511 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, k2);
512 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, k3);
513 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, k4);
514 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, p1);
515 PRINT_NONZERO_COEFFICIENT(brown_intrinsics, p2);
516 break;
517 }
518 default: LOG(FATAL) << "Unknown distortion model.";
519 }
520
521#undef PRINT_NONZERO_COEFFICIENT
522
523 return os;
524}
525
526} // namespace libmv
void ApplyIntrinsics(double normalized_x, double normalized_y, double *image_x, double *image_y) const override
virtual void Unpack(const PackedIntrinsics &packed_intrinsics) override
virtual void Pack(PackedIntrinsics *packed_intrinsics) const override
void SetRadialDistortion(double k1, double k2, double k3, double k4)
void InvertIntrinsics(double image_x, double image_y, double *normalized_x, double *normalized_y) const override
void SetFocalLength(double focal_x, double focal_y)
void NormalizedToImageSpace(double normalized_x, double normalized_y, double *image_x, double *image_y) const
virtual void Unpack(const PackedIntrinsics &packed_intrinsics)
virtual void Pack(PackedIntrinsics *packed_intrinsics) const
virtual DistortionModelType GetDistortionModelType() const =0
void ImageSpaceToNormalized(double image_x, double image_y, double *normalized_x, double *normalized_y) const
virtual void Unpack(const PackedIntrinsics &packed_intrinsics) override
virtual void Pack(PackedIntrinsics *packed_intrinsics) const override
void InvertIntrinsics(double image_x, double image_y, double *normalized_x, double *normalized_y) const override
void ApplyIntrinsics(double normalized_x, double normalized_y, double *image_x, double *image_y) const override
virtual void Pack(PackedIntrinsics *packed_intrinsics) const override
void InvertIntrinsics(double image_x, double image_y, double *normalized_x, double *normalized_y) const override
virtual void Unpack(const PackedIntrinsics &packed_intrinsics) override
void ApplyIntrinsics(double normalized_x, double normalized_y, double *image_x, double *image_y) const override
double GetPrincipalPointY() const
void SetFocalLength(double focal_length)
double GetPrincipalPointX() const
void SetPrincipalPoint(double x, double y)
virtual void Pack(PackedIntrinsics *packed_intrinsics) const override
void InvertIntrinsics(double image_x, double image_y, double *normalized_x, double *normalized_y) const override
virtual void Unpack(const PackedIntrinsics &packed_intrinsics) override
void SetRadialDistortion(double k1, double k2, double k3)
void ApplyIntrinsics(double normalized_x, double normalized_y, double *image_x, double *image_y) const override
#define PRINT_NONZERO_COEFFICIENT(intrinsics, coeff)
#define LOG(level)
Definition log.h:97
std::ostream & operator<<(std::ostream &os, const CameraIntrinsics &intrinsics)
A human-readable representation of the camera intrinsic parameters.
void InvertPolynomialDistortionModel(const double focal_length_x, const double focal_length_y, const double principal_point_x, const double principal_point_y, const double k1, const double k2, const double k3, const double p1, const double p2, const double image_x, const double image_y, double *normalized_x, double *normalized_y)
void ApplyPolynomialDistortionModel(const T &focal_length_x, const T &focal_length_y, const T &principal_point_x, const T &principal_point_y, const T &k1, const T &k2, const T &k3, const T &p1, const T &p2, const T &normalized_x, const T &normalized_y, T *image_x, T *image_y)
Eigen::Matrix< double, 3, 3 > Mat3
Definition numeric.h:74
void ApplyDivisionDistortionModel(const T &focal_length_x, const T &focal_length_y, const T &principal_point_x, const T &principal_point_y, const T &k1, const T &k2, const T &normalized_x, const T &normalized_y, T *image_x, T *image_y)
void ApplyNukeDistortionModel(const double focal_length_x, const double focal_length_y, const double principal_point_x, const double principal_point_y, const int image_width, const int image_height, const double k1, const double k2, const double p1, const double p2, const double normalized_x, const double normalized_y, double *image_x, double *image_y)
void InvertBrownDistortionModel(const double focal_length_x, const double focal_length_y, const double principal_point_x, const double principal_point_y, const double k1, const double k2, const double k3, const double k4, const double p1, const double p2, const double image_x, const double image_y, double *normalized_x, double *normalized_y)
void InvertDivisionDistortionModel(const double focal_length_x, const double focal_length_y, const double principal_point_x, const double principal_point_y, const double k1, const double k2, const double image_x, const double image_y, double *normalized_x, double *normalized_y)
@ DISTORTION_MODEL_POLYNOMIAL
@ DISTORTION_MODEL_DIVISION
@ DISTORTION_MODEL_BROWN
@ DISTORTION_MODEL_NUKE
void InvertNukeDistortionModel(const T &focal_length_x, const T &focal_length_y, const T &principal_point_x, const T &principal_point_y, const int image_width, const int image_height, const T &k1, const T &k2, const T &p1, const T &p2, const T &image_x, const T &image_y, T *normalized_x, T *normalized_y)
void ApplyBrownDistortionModel(const T &focal_length_x, const T &focal_length_y, const T &principal_point_x, const T &principal_point_y, const T &k1, const T &k2, const T &k3, const T &k4, const T &p1, const T &p2, const T &normalized_x, const T &normalized_y, T *image_x, T *image_y)