OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / stitching / detail / warpers.hpp
1  /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 //  By downloading, copying, installing or using the software you agree to this license.
6 //  If you do not agree to this license, do not download, install,
7 //  copy or use the software.
8 //
9 //
10 //                          License Agreement
11 //                For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15 // Third party copyrights are property of their respective owners.
16 //
17 // Redistribution and use in source and binary forms, with or without modification,
18 // are permitted provided that the following conditions are met:
19 //
20 //   * Redistribution's of source code must retain the above copyright notice,
21 //     this list of conditions and the following disclaimer.
22 //
23 //   * Redistribution's in binary form must reproduce the above copyright notice,
24 //     this list of conditions and the following disclaimer in the documentation
25 //     and/or other materials provided with the distribution.
26 //
27 //   * The name of the copyright holders may not be used to endorse or promote products
28 //     derived from this software without specific prior written permission.
29 //
30 // This software is provided by the copyright holders and contributors "as is" and
31 // any express or implied warranties, including, but not limited to, the implied
32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
33 // In no event shall the Intel Corporation or contributors be liable for any direct,
34 // indirect, incidental, special, exemplary, or consequential damages
35 // (including, but not limited to, procurement of substitute goods or services;
36 // loss of use, data, or profits; or business interruption) however caused
37 // and on any theory of liability, whether in contract, strict liability,
38 // or tort (including negligence or otherwise) arising in any way out of
39 // the use of this software, even if advised of the possibility of such damage.
40 //
41 //M*/
42
43 #ifndef __OPENCV_STITCHING_WARPERS_HPP__
44 #define __OPENCV_STITCHING_WARPERS_HPP__
45
46 #include "opencv2/core/core.hpp"
47 #include "opencv2/imgproc/imgproc.hpp"
48 #include "opencv2/opencv_modules.hpp"
49 #if defined(HAVE_OPENCV_GPU) && !defined(ANDROID)
50 # include "opencv2/gpu/gpu.hpp"
51 #endif
52
53 namespace cv {
54 namespace detail {
55
56 class CV_EXPORTS RotationWarper
57 {
58 public:
59     virtual ~RotationWarper() {}
60
61     virtual Point2f warpPoint(const Point2f &pt, const Mat &K, const Mat &R) = 0;
62
63     virtual Rect buildMaps(Size src_size, const Mat &K, const Mat &R, Mat &xmap, Mat &ymap) = 0;
64
65     virtual Point warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
66                        Mat &dst) = 0;
67
68     virtual void warpBackward(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
69                               Size dst_size, Mat &dst) = 0;
70
71     virtual Rect warpRoi(Size src_size, const Mat &K, const Mat &R) = 0;
72
73     float getScale() const { return 1.f; }
74     void setScale(float) {}
75 };
76
77
78 struct CV_EXPORTS ProjectorBase
79 {
80     void setCameraParams(const Mat &K = Mat::eye(3, 3, CV_32F),
81                          const Mat &R = Mat::eye(3, 3, CV_32F),
82                          const Mat &T = Mat::zeros(3, 1, CV_32F));
83
84     float scale;
85     float k[9];
86     float rinv[9];
87     float r_kinv[9];
88     float k_rinv[9];
89     float t[3];
90 };
91
92
93 template <class P>
94 class CV_EXPORTS RotationWarperBase : public RotationWarper
95 {
96 public:
97     Point2f warpPoint(const Point2f &pt, const Mat &K, const Mat &R);
98
99     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, Mat &xmap, Mat &ymap);
100
101     Point warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
102                Mat &dst);
103
104     void warpBackward(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
105                       Size dst_size, Mat &dst);
106
107     Rect warpRoi(Size src_size, const Mat &K, const Mat &R);
108
109     float getScale() const { return projector_.scale; }
110     void setScale(float val) { projector_.scale = val; }
111
112 protected:
113
114     // Detects ROI of the destination image. It's correct for any projection.
115     virtual void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
116
117     // Detects ROI of the destination image by walking over image border.
118     // Correctness for any projection isn't guaranteed.
119     void detectResultRoiByBorder(Size src_size, Point &dst_tl, Point &dst_br);
120
121     P projector_;
122 };
123
124
125 struct CV_EXPORTS PlaneProjector : ProjectorBase
126 {
127     void mapForward(float x, float y, float &u, float &v);
128     void mapBackward(float u, float v, float &x, float &y);
129 };
130
131
132 class CV_EXPORTS PlaneWarper : public RotationWarperBase<PlaneProjector>
133 {
134 public:
135     PlaneWarper(float scale = 1.f) { projector_.scale = scale; }
136
137     void setScale(float scale) { projector_.scale = scale; }
138
139     Point2f warpPoint(const Point2f &pt, const Mat &K, const Mat &R, const Mat &T);
140
141     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, const Mat &T, Mat &xmap, Mat &ymap);
142
143     Point warp(const Mat &src, const Mat &K, const Mat &R, const Mat &T, int interp_mode, int border_mode,
144                Mat &dst);
145
146     Rect warpRoi(Size src_size, const Mat &K, const Mat &R, const Mat &T);
147
148 protected:
149     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
150 };
151
152
153 struct CV_EXPORTS SphericalProjector : ProjectorBase
154 {
155     void mapForward(float x, float y, float &u, float &v);
156     void mapBackward(float u, float v, float &x, float &y);
157 };
158
159
160 // Projects image onto unit sphere with origin at (0, 0, 0).
161 // Poles are located at (0, -1, 0) and (0, 1, 0) points.
162 class CV_EXPORTS SphericalWarper : public RotationWarperBase<SphericalProjector>
163 {
164 public:
165     SphericalWarper(float scale) { projector_.scale = scale; }
166
167 protected:
168     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
169 };
170
171
172 struct CV_EXPORTS CylindricalProjector : ProjectorBase
173 {
174     void mapForward(float x, float y, float &u, float &v);
175     void mapBackward(float u, float v, float &x, float &y);
176 };
177
178
179 // Projects image onto x * x + z * z = 1 cylinder
180 class CV_EXPORTS CylindricalWarper : public RotationWarperBase<CylindricalProjector>
181 {
182 public:
183     CylindricalWarper(float scale) { projector_.scale = scale; }
184
185 protected:
186     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
187     {
188         RotationWarperBase<CylindricalProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
189     }
190 };
191
192
193 struct CV_EXPORTS FisheyeProjector : ProjectorBase
194 {
195     void mapForward(float x, float y, float &u, float &v);
196     void mapBackward(float u, float v, float &x, float &y);
197 };
198
199
200 class CV_EXPORTS FisheyeWarper : public RotationWarperBase<FisheyeProjector>
201 {
202 public:
203     FisheyeWarper(float scale) { projector_.scale = scale; }
204 };
205
206
207 struct CV_EXPORTS StereographicProjector : ProjectorBase
208 {
209     void mapForward(float x, float y, float &u, float &v);
210     void mapBackward(float u, float v, float &x, float &y);
211 };
212
213
214 class CV_EXPORTS StereographicWarper : public RotationWarperBase<StereographicProjector>
215 {
216 public:
217     StereographicWarper(float scale) { projector_.scale = scale; }
218 };
219
220
221 struct CV_EXPORTS CompressedRectilinearProjector : ProjectorBase
222 {
223     float a, b;
224
225     void mapForward(float x, float y, float &u, float &v);
226     void mapBackward(float u, float v, float &x, float &y);
227 };
228
229
230 class CV_EXPORTS CompressedRectilinearWarper : public RotationWarperBase<CompressedRectilinearProjector>
231 {
232 public:
233     CompressedRectilinearWarper(float scale, float A = 1, float B = 1)
234     {
235         projector_.a = A;
236         projector_.b = B;
237         projector_.scale = scale;
238     }
239 };
240
241
242 struct CV_EXPORTS CompressedRectilinearPortraitProjector : ProjectorBase
243 {
244     float a, b;
245
246     void mapForward(float x, float y, float &u, float &v);
247     void mapBackward(float u, float v, float &x, float &y);
248 };
249
250
251 class CV_EXPORTS CompressedRectilinearPortraitWarper : public RotationWarperBase<CompressedRectilinearPortraitProjector>
252 {
253 public:
254    CompressedRectilinearPortraitWarper(float scale, float A = 1, float B = 1)
255    {
256        projector_.a = A;
257        projector_.b = B;
258        projector_.scale = scale;
259    }
260 };
261
262
263 struct CV_EXPORTS PaniniProjector : ProjectorBase
264 {
265     float a, b;
266
267     void mapForward(float x, float y, float &u, float &v);
268     void mapBackward(float u, float v, float &x, float &y);
269 };
270
271
272 class CV_EXPORTS PaniniWarper : public RotationWarperBase<PaniniProjector>
273 {
274 public:
275    PaniniWarper(float scale, float A = 1, float B = 1)
276    {
277        projector_.a = A;
278        projector_.b = B;
279        projector_.scale = scale;
280    }
281 };
282
283
284 struct CV_EXPORTS PaniniPortraitProjector : ProjectorBase
285 {
286     float a, b;
287
288     void mapForward(float x, float y, float &u, float &v);
289     void mapBackward(float u, float v, float &x, float &y);
290 };
291
292
293 class CV_EXPORTS PaniniPortraitWarper : public RotationWarperBase<PaniniPortraitProjector>
294 {
295 public:
296    PaniniPortraitWarper(float scale, float A = 1, float B = 1)
297    {
298        projector_.a = A;
299        projector_.b = B;
300        projector_.scale = scale;
301    }
302
303 };
304
305
306 struct CV_EXPORTS MercatorProjector : ProjectorBase
307 {
308     void mapForward(float x, float y, float &u, float &v);
309     void mapBackward(float u, float v, float &x, float &y);
310 };
311
312
313 class CV_EXPORTS MercatorWarper : public RotationWarperBase<MercatorProjector>
314 {
315 public:
316     MercatorWarper(float scale) { projector_.scale = scale; }
317 };
318
319
320 struct CV_EXPORTS TransverseMercatorProjector : ProjectorBase
321 {
322     void mapForward(float x, float y, float &u, float &v);
323     void mapBackward(float u, float v, float &x, float &y);
324 };
325
326
327 class CV_EXPORTS TransverseMercatorWarper : public RotationWarperBase<TransverseMercatorProjector>
328 {
329 public:
330     TransverseMercatorWarper(float scale) { projector_.scale = scale; }
331 };
332
333
334 #if defined(HAVE_OPENCV_GPU) && !defined(ANDROID)
335 class CV_EXPORTS PlaneWarperGpu : public PlaneWarper
336 {
337 public:
338     PlaneWarperGpu(float scale = 1.f) : PlaneWarper(scale) {}
339
340     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, Mat &xmap, Mat &ymap)
341     {
342         Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
343         d_xmap_.download(xmap);
344         d_ymap_.download(ymap);
345         return result;
346     }
347
348     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, const Mat &T, Mat &xmap, Mat &ymap)
349     {
350         Rect result = buildMaps(src_size, K, R, T, d_xmap_, d_ymap_);
351         d_xmap_.download(xmap);
352         d_ymap_.download(ymap);
353         return result;
354     }
355
356     Point warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
357                Mat &dst)
358     {
359         d_src_.upload(src);
360         Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
361         d_dst_.download(dst);
362         return result;
363     }
364
365     Point warp(const Mat &src, const Mat &K, const Mat &R, const Mat &T, int interp_mode, int border_mode,
366                Mat &dst)
367     {
368         d_src_.upload(src);
369         Point result = warp(d_src_, K, R, T, interp_mode, border_mode, d_dst_);
370         d_dst_.download(dst);
371         return result;
372     }
373
374     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, gpu::GpuMat &xmap, gpu::GpuMat &ymap);
375
376     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, const Mat &T, gpu::GpuMat &xmap, gpu::GpuMat &ymap);
377
378     Point warp(const gpu::GpuMat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
379                gpu::GpuMat &dst);
380
381     Point warp(const gpu::GpuMat &src, const Mat &K, const Mat &R, const Mat &T, int interp_mode, int border_mode,
382                gpu::GpuMat &dst);
383
384 private:
385     gpu::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
386 };
387
388
389 class CV_EXPORTS SphericalWarperGpu : public SphericalWarper
390 {
391 public:
392     SphericalWarperGpu(float scale) : SphericalWarper(scale) {}
393
394     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, Mat &xmap, Mat &ymap)
395     {
396         Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
397         d_xmap_.download(xmap);
398         d_ymap_.download(ymap);
399         return result;
400     }
401
402     Point warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
403                Mat &dst)
404     {
405         d_src_.upload(src);
406         Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
407         d_dst_.download(dst);
408         return result;
409     }
410
411     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, gpu::GpuMat &xmap, gpu::GpuMat &ymap);
412
413     Point warp(const gpu::GpuMat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
414                gpu::GpuMat &dst);
415
416 private:
417     gpu::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
418 };
419
420
421 class CV_EXPORTS CylindricalWarperGpu : public CylindricalWarper
422 {
423 public:
424     CylindricalWarperGpu(float scale) : CylindricalWarper(scale) {}
425
426     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, Mat &xmap, Mat &ymap)
427     {
428         Rect result = buildMaps(src_size, K, R, d_xmap_, d_ymap_);
429         d_xmap_.download(xmap);
430         d_ymap_.download(ymap);
431         return result;
432     }
433
434     Point warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
435                Mat &dst)
436     {
437         d_src_.upload(src);
438         Point result = warp(d_src_, K, R, interp_mode, border_mode, d_dst_);
439         d_dst_.download(dst);
440         return result;
441     }
442
443     Rect buildMaps(Size src_size, const Mat &K, const Mat &R, gpu::GpuMat &xmap, gpu::GpuMat &ymap);
444
445     Point warp(const gpu::GpuMat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode,
446                gpu::GpuMat &dst);
447
448 private:
449     gpu::GpuMat d_xmap_, d_ymap_, d_src_, d_dst_;
450 };
451 #endif
452
453
454 struct SphericalPortraitProjector : ProjectorBase
455 {
456     void mapForward(float x, float y, float &u, float &v);
457     void mapBackward(float u, float v, float &x, float &y);
458 };
459
460
461 // Projects image onto unit sphere with origin at (0, 0, 0).
462 // Poles are located NOT at (0, -1, 0) and (0, 1, 0) points, BUT at (1, 0, 0) and (-1, 0, 0) points.
463 class CV_EXPORTS SphericalPortraitWarper : public RotationWarperBase<SphericalPortraitProjector>
464 {
465 public:
466     SphericalPortraitWarper(float scale) { projector_.scale = scale; }
467
468 protected:
469     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
470 };
471
472 struct CylindricalPortraitProjector : ProjectorBase
473 {
474     void mapForward(float x, float y, float &u, float &v);
475     void mapBackward(float u, float v, float &x, float &y);
476 };
477
478
479 class CV_EXPORTS CylindricalPortraitWarper : public RotationWarperBase<CylindricalPortraitProjector>
480 {
481 public:
482     CylindricalPortraitWarper(float scale) { projector_.scale = scale; }
483
484 protected:
485     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
486     {
487         RotationWarperBase<CylindricalPortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
488     }
489 };
490
491 struct PlanePortraitProjector : ProjectorBase
492 {
493     void mapForward(float x, float y, float &u, float &v);
494     void mapBackward(float u, float v, float &x, float &y);
495 };
496
497
498 class CV_EXPORTS PlanePortraitWarper : public RotationWarperBase<PlanePortraitProjector>
499 {
500 public:
501     PlanePortraitWarper(float scale) { projector_.scale = scale; }
502
503 protected:
504     void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br)
505     {
506         RotationWarperBase<PlanePortraitProjector>::detectResultRoiByBorder(src_size, dst_tl, dst_br);
507     }
508 };
509
510 } // namespace detail
511 } // namespace cv
512
513 #include "warpers_inl.hpp"
514
515 #endif // __OPENCV_STITCHING_WARPERS_HPP__