99141c61bfc3e07ad4bf1e456f3a3cb86a3f5d3c
[blender.git] / extern / libmv / libmv / simple_pipeline / camera_intrinsics.h
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
21 #ifndef LIBMV_SIMPLE_PIPELINE_CAMERA_INTRINSICS_H_
22 #define LIBMV_SIMPLE_PIPELINE_CAMERA_INTRINSICS_H_
23
24 #include <Eigen/Core>
25 typedef Eigen::Matrix<double, 3, 3> Mat3;
26
27 namespace libmv {
28
29 class CameraIntrinsics {
30  public:
31   CameraIntrinsics();
32   ~CameraIntrinsics();
33
34   const Mat3 &K()                 const { return K_;            }
35   // FIXME(MatthiasF): these should be CamelCase methods
36   double      focal_length()      const { return K_(0, 0);      }
37   double      focal_length_x()    const { return K_(0, 0);      }
38   double      focal_length_y()    const { return K_(1, 1);      }
39   double      principal_point_x() const { return K_(0, 2);      }
40   double      principal_point_y() const { return K_(1, 2);      }
41   int         image_width()       const { return image_width_;  }
42   int         image_height()      const { return image_height_; }
43   double      k1()                const { return k1_; }
44   double      k2()                const { return k2_; }
45   double      k3()                const { return k3_; }
46   double      p1()                const { return p1_; }
47   double      p2()                const { return p2_; }
48
49   /// Set the entire calibration matrix at once.
50   void SetK(const Mat3 new_k);
51
52   /// Set both x and y focal length in pixels.
53   void SetFocalLength(double focal_x, double focal_y);
54
55   void SetPrincipalPoint(double cx, double cy);
56
57   void SetImageSize(int width, int height);
58
59   void SetRadialDistortion(double k1, double k2, double k3 = 0);
60
61   void SetTangentialDistortion(double p1, double p2);
62
63   /*!
64       Apply camera intrinsics to the normalized point to get image coordinates.
65
66       This applies the lens distortion to a point which is in normalized
67       camera coordinates (i.e. the principal point is at (0, 0)) to get image
68       coordinates in pixels.
69   */
70   void ApplyIntrinsics(double normalized_x, double normalized_y,
71                        double *image_x, double *image_y) const;
72
73   /*!
74       Invert camera intrinsics on the image point to get normalized coordinates.
75
76       This reverses the effect of lens distortion on a point which is in image
77       coordinates to get normalized camera coordinates.
78   */
79   void InvertIntrinsics(double image_x, double image_y,
80                         double *normalized_x, double *normalized_y) const;
81
82   /*!
83       Distort an image using the current camera instrinsics
84
85       The distorted image is computed in \a dst using samples from \a src.
86       both buffers should be \a width x \a height x \a channels sized.
87
88       \note This is the reference implementation using floating point images.
89   */
90   void Distort(const float* src, float* dst,
91                int width, int height, int channels);
92   /*!
93       Distort an image using the current camera instrinsics
94
95       The distorted image is computed in \a dst using samples from \a src.
96       both buffers should be \a width x \a height x \a channels sized.
97
98       \note This version is much faster.
99   */
100   void Distort(const unsigned char* src, unsigned char* dst,
101                int width, int height, int channels);
102   /*!
103       Undistort an image using the current camera instrinsics
104
105       The undistorted image is computed in \a dst using samples from \a src.
106       both buffers should be \a width x \a height x \a channels sized.
107
108       \note This is the reference implementation using floating point images.
109   */
110   void Undistort(const float* src, float* dst,
111                  int width, int height, int channels);
112   /*!
113       Undistort an image using the current camera instrinsics
114
115       The undistorted image is computed in \a dst using samples from \a src.
116       both buffers should be \a width x \a height x \a channels sized.
117
118       \note This version is much faster.
119   */
120   void Undistort(const unsigned char* src, unsigned char* dst,
121                  int width, int height, int channels);
122
123  private:
124   template<typename WarpFunction> void ComputeLookupGrid(struct Grid* grid, int width, int height);
125   void CheckUndistortLookupGrid(int width, int height);
126   void CheckDistortLookupGrid(int width, int height);
127   void FreeLookupGrid();
128
129   // The traditional intrinsics matrix from x = K[R|t]X.
130   Mat3 K_;
131
132   // This is the size of the image. This is necessary to, for example, handle
133   // the case of processing a scaled image.
134   int image_width_;
135   int image_height_;
136
137   // OpenCV's distortion model with third order polynomial radial distortion
138   // terms and second order tangential distortion. The distortion is applied to
139   // the normalized coordinates before the focal length, which makes them
140   // independent of image size.
141   double k1_, k2_, k3_, p1_, p2_;
142
143   struct Grid *distort_;
144   struct Grid *undistort_;
145 };
146
147 }  // namespace libmv
148
149 #endif  // LIBMV_SIMPLE_PIPELINE_CAMERA_INTRINSICS_H_