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