calib3d: move undistort files from imgproc

modules/calib3d/include/opencv2/calib3d/calib3d_c.h

@@ -379,6 +379,39 @@ CVAPI(void)  cvReprojectImageTo3D( const CvArr* disparityImage,
                                    CvArr* _3dImage, const CvMat* Q,
                                    int handleMissingValues CV_DEFAULT(0) );
 
+/** @brief Transforms the input image to compensate lens distortion
+@see cv::undistort
+*/
+CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
+                          const CvMat* camera_matrix,
+                          const CvMat* distortion_coeffs,
+                          const CvMat* new_camera_matrix CV_DEFAULT(0) );
+
+/** @brief Computes transformation map from intrinsic camera parameters
+   that can used by cvRemap
+*/
+CVAPI(void) cvInitUndistortMap( const CvMat* camera_matrix,
+                                const CvMat* distortion_coeffs,
+                                CvArr* mapx, CvArr* mapy );
+
+/** @brief Computes undistortion+rectification map for a head of stereo camera
+@see cv::initUndistortRectifyMap
+*/
+CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix,
+                                       const CvMat* dist_coeffs,
+                                       const CvMat *R, const CvMat* new_camera_matrix,
+                                       CvArr* mapx, CvArr* mapy );
+
+/** @brief Computes the original (undistorted) feature coordinates
+   from the observed (distorted) coordinates
+@see cv::undistortPoints
+*/
+CVAPI(void) cvUndistortPoints( const CvMat* src, CvMat* dst,
+                               const CvMat* camera_matrix,
+                               const CvMat* dist_coeffs,
+                               const CvMat* R CV_DEFAULT(0),
+                               const CvMat* P CV_DEFAULT(0));
+
 /** @} calib3d_c */
 
 #ifdef __cplusplus

modules/calib3d/misc/java/test/Calib3dTest.java

 package org.opencv.test.calib3d;
 
 import org.opencv.calib3d.Calib3d;
+import org.opencv.core.Core;
 import org.opencv.core.CvType;
 import org.opencv.core.Mat;
 import org.opencv.core.MatOfDouble;
@@ -14,6 +15,15 @@ import org.opencv.imgproc.Imgproc;
 
 public class Calib3dTest extends OpenCVTestCase {
 
+    Size size;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        size = new Size(3, 3);
+    }
+
     public void testCalibrateCameraListOfMatListOfMatSizeMatMatListOfMatListOfMat() {
         fail("Not yet implemented");
     }
@@ -602,4 +612,131 @@ public class Calib3dTest extends OpenCVTestCase {
         Calib3d.computeCorrespondEpilines(left, 1, fundamental, lines);
         assertMatEqual(truth, lines, EPS);
     }
+
+    public void testGetDefaultNewCameraMatrixMat() {
+        Mat mtx = Calib3d.getDefaultNewCameraMatrix(gray0);
+
+        assertFalse(mtx.empty());
+        assertEquals(0, Core.countNonZero(mtx));
+    }
+
+    public void testGetDefaultNewCameraMatrixMatSizeBoolean() {
+        Mat mtx = Calib3d.getDefaultNewCameraMatrix(gray0, size, true);
+
+        assertFalse(mtx.empty());
+        assertFalse(0 == Core.countNonZero(mtx));
+        // TODO_: write better test
+    }
+
+    public void testInitUndistortRectifyMap() {
+        fail("Not yet implemented");
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
+        cameraMatrix.put(0, 0, 1, 0, 1);
+        cameraMatrix.put(1, 0, 0, 1, 1);
+        cameraMatrix.put(2, 0, 0, 0, 1);
+
+        Mat R = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
+        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+
+        Mat distCoeffs = new Mat();
+        Mat map1 = new Mat();
+        Mat map2 = new Mat();
+
+        // TODO: complete this test
+        Calib3d.initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, CvType.CV_32F, map1, map2);
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMat() {
+        fail("Not yet implemented");
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F);
+        // Size imageSize = new Size(2, 2);
+
+        cameraMatrix.put(0, 0, 1, 0, 1);
+        cameraMatrix.put(1, 0, 0, 1, 2);
+        cameraMatrix.put(2, 0, 0, 0, 1);
+
+        distCoeffs.put(0, 0, 1, 3, 2, 4);
+        truth = new Mat(3, 3, CvType.CV_32F);
+        truth.put(0, 0, 0, 0, 0);
+        truth.put(1, 0, 0, 0, 0);
+        truth.put(2, 0, 0, 3, 0);
+        // TODO: No documentation for this function
+        // Calib3d.initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize,
+        // 5, m1type, truthput1, truthput2);
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testUndistortMatMatMatMat() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 2);
+                put(2, 0, 0, 0, 1);
+            }
+        };
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 3, 2, 4);
+            }
+        };
+
+        Calib3d.undistort(src, dst, cameraMatrix, distCoeffs);
+
+        truth = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 0, 0, 0);
+                put(1, 0, 0, 0, 0);
+                put(2, 0, 0, 3, 0);
+            }
+        };
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    public void testUndistortMatMatMatMatMat() {
+        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
+            {
+                put(0, 0, 1, 0, 1);
+                put(1, 0, 0, 1, 2);
+                put(2, 0, 0, 0, 1);
+            }
+        };
+        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
+            {
+                put(0, 0, 2, 1, 4, 5);
+            }
+        };
+        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(1));
+
+        Calib3d.undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix);
+
+        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
+        assertMatEqual(truth, dst, EPS);
+    }
+
+    //undistortPoints(List<Point> src, List<Point> dst, Mat cameraMatrix, Mat distCoeffs)
+    public void testUndistortPointsListOfPointListOfPointMatMat() {
+        MatOfPoint2f src = new MatOfPoint2f(new Point(1, 2), new Point(3, 4), new Point(-1, -1));
+        MatOfPoint2f dst = new MatOfPoint2f();
+        Mat cameraMatrix = Mat.eye(3, 3, CvType.CV_64FC1);
+        Mat distCoeffs = new Mat(8, 1, CvType.CV_64FC1, new Scalar(0));
+
+        Calib3d.undistortPoints(src, dst, cameraMatrix, distCoeffs);
+
+        assertEquals(src.size(), dst.size());
+        for(int i=0; i<src.toList().size(); i++) {
+            //Log.d("UndistortPoints", "s="+src.get(i)+", d="+dst.get(i));
+            assertTrue(src.toList().get(i).equals(dst.toList().get(i)));
+        }
+    }
+
 }

modules/calib3d/src/calibration.cpp

@@ -42,7 +42,7 @@
 
 #include "precomp.hpp"
 #include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/imgproc/detail/distortion_model.hpp"
+#include "distortion_model.hpp"
 #include "opencv2/calib3d/calib3d_c.h"
 #include <stdio.h>
 #include <iterator>

modules/imgproc/src/undistort.cpp → modules/calib3d/src/undistort.cpp

@@ -41,9 +41,11 @@
 //M*/
 
 #include "precomp.hpp"
-#include "opencv2/imgproc/detail/distortion_model.hpp"
+#include "distortion_model.hpp"
 #include "undistort.hpp"
 
+#include "opencv2/calib3d/calib3d_c.h"
+
 cv::Mat cv::getDefaultNewCameraMatrix( InputArray _cameraMatrix, Size imgsize,
                                bool centerPrincipalPoint )
 {
@@ -534,29 +536,31 @@ static void cvUndistortPointsInternal( const CvMat* _src, CvMat* _dst, const CvM
     }
 }
 
-void cvUndistortPoints( const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,
-                   const CvMat* _distCoeffs,
-                   const CvMat* matR, const CvMat* matP )
+void cvUndistortPoints(const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,
+                       const CvMat* _distCoeffs,
+                       const CvMat* matR, const CvMat* matP)
 {
     cvUndistortPointsInternal(_src, _dst, _cameraMatrix, _distCoeffs, matR, matP,
                               cv::TermCriteria(cv::TermCriteria::COUNT, 5, 0.01));
 }
 
-void cv::undistortPoints( InputArray _src, OutputArray _dst,
-                          InputArray _cameraMatrix,
-                          InputArray _distCoeffs,
-                          InputArray _Rmat,
-                          InputArray _Pmat )
+namespace cv {
+
+void undistortPoints(InputArray _src, OutputArray _dst,
+                     InputArray _cameraMatrix,
+                     InputArray _distCoeffs,
+                     InputArray _Rmat,
+                     InputArray _Pmat)
 {
     undistortPoints(_src, _dst, _cameraMatrix, _distCoeffs, _Rmat, _Pmat, TermCriteria(TermCriteria::MAX_ITER, 5, 0.01));
 }
 
-void cv::undistortPoints( InputArray _src, OutputArray _dst,
-                          InputArray _cameraMatrix,
-                          InputArray _distCoeffs,
-                          InputArray _Rmat,
-                          InputArray _Pmat,
-                          TermCriteria criteria)
+void undistortPoints(InputArray _src, OutputArray _dst,
+                     InputArray _cameraMatrix,
+                     InputArray _distCoeffs,
+                     InputArray _Rmat,
+                     InputArray _Pmat,
+                     TermCriteria criteria)
 {
     Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat();
     Mat distCoeffs = _distCoeffs.getMat(), R = _Rmat.getMat(), P = _Pmat.getMat();
@@ -578,10 +582,7 @@ void cv::undistortPoints( InputArray _src, OutputArray _dst,
     cvUndistortPointsInternal(&_csrc, &_cdst, &_ccameraMatrix, pD, pR, pP, criteria);
 }
 
-namespace cv
-{
-
-static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, int projType)
+static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, enum UndistortTypes projType)
 {
     double x = p.x, y = p.y;
     double beta = 1 + 2*alpha;
@@ -613,11 +614,11 @@ static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, int pr
         }
         return Point2f((float)asin(x1), (float)asin(y1));
     }
-    CV_Error(CV_StsBadArg, "Unknown projection type");
+    CV_Error(Error::StsBadArg, "Unknown projection type");
 }
 
 
-static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType)
+static Point2f invMapPointSpherical(Point2f _p, float alpha, enum UndistortTypes projType)
 {
     double eps = 1e-12;
     Vec2d p(_p.x, _p.y), q(_p.x, _p.y), err;
@@ -646,11 +647,10 @@ static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType)
     return i < maxiter ? Point2f((float)q[0], (float)q[1]) : Point2f(-FLT_MAX, -FLT_MAX);
 }
 
-}
-
-float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeffs0,
-                            Size imageSize, int destImageWidth, int m1type,
-                            OutputArray _map1, OutputArray _map2, int projType, double _alpha )
+float initWideAngleProjMap(InputArray _cameraMatrix0, InputArray _distCoeffs0,
+                           Size imageSize, int destImageWidth, int m1type,
+                           OutputArray _map1, OutputArray _map2,
+                           enum UndistortTypes projType, double _alpha)
 {
     Mat cameraMatrix0 = _cameraMatrix0.getMat(), distCoeffs0 = _distCoeffs0.getMat();
     double k[14] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0}, M[9]={0,0,0,0,0,0,0,0,0};
@@ -735,4 +735,5 @@ float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeff
     return scale;
 }
 
+} // namespace
 /*  End of file  */

modules/imgproc/src/undistort.hpp → modules/calib3d/src/undistort.hpp

@@ -40,8 +40,8 @@
 //
 //M*/
 
-#ifndef OPENCV_IMGPROC_UNDISTORT_HPP
-#define OPENCV_IMGPROC_UNDISTORT_HPP
+#ifndef OPENCV_CALIB3D_UNDISTORT_HPP
+#define OPENCV_CALIB3D_UNDISTORT_HPP
 
 namespace cv
 {
@@ -54,6 +54,6 @@ namespace cv
 #endif
 }
 
-#endif
+#endif // OPENCV_CALIB3D_UNDISTORT_HPP
 
 /*  End of file  */

modules/calib3d/test/test_undistort_badarg.cpp

@@ -40,7 +40,7 @@
 //M*/
 
 #include "test_precomp.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/calib3d/calib3d_c.h"
 
 namespace opencv_test { namespace {
 

modules/imgproc/include/opencv2/imgproc/imgproc_c.h

@@ -273,39 +273,6 @@ CVAPI(void)  cvLinearPolar( const CvArr* src, CvArr* dst,
                          CvPoint2D32f center, double maxRadius,
                          int flags CV_DEFAULT(CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS));
 
-/** @brief Transforms the input image to compensate lens distortion
-@see cv::undistort
-*/
-CVAPI(void) cvUndistort2( const CvArr* src, CvArr* dst,
-                          const CvMat* camera_matrix,
-                          const CvMat* distortion_coeffs,
-                          const CvMat* new_camera_matrix CV_DEFAULT(0) );
-
-/** @brief Computes transformation map from intrinsic camera parameters
-   that can used by cvRemap
-*/
-CVAPI(void) cvInitUndistortMap( const CvMat* camera_matrix,
-                                const CvMat* distortion_coeffs,
-                                CvArr* mapx, CvArr* mapy );
-
-/** @brief Computes undistortion+rectification map for a head of stereo camera
-@see cv::initUndistortRectifyMap
-*/
-CVAPI(void) cvInitUndistortRectifyMap( const CvMat* camera_matrix,
-                                       const CvMat* dist_coeffs,
-                                       const CvMat *R, const CvMat* new_camera_matrix,
-                                       CvArr* mapx, CvArr* mapy );
-
-/** @brief Computes the original (undistorted) feature coordinates
-   from the observed (distorted) coordinates
-@see cv::undistortPoints
-*/
-CVAPI(void) cvUndistortPoints( const CvMat* src, CvMat* dst,
-                               const CvMat* camera_matrix,
-                               const CvMat* dist_coeffs,
-                               const CvMat* R CV_DEFAULT(0),
-                               const CvMat* P CV_DEFAULT(0));
-
 /** @brief Returns a structuring element of the specified size and shape for morphological operations.
 
 @note the created structuring element IplConvKernel\* element must be released in the end using

modules/imgproc/misc/java/test/ImgprocTest.java

@@ -891,21 +891,6 @@ public class ImgprocTest extends OpenCVTestCase {
         assertMatEqual(truth, transform, EPS);
     }
 
-    public void testGetDefaultNewCameraMatrixMat() {
-        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0);
-
-        assertFalse(mtx.empty());
-        assertEquals(0, Core.countNonZero(mtx));
-    }
-
-    public void testGetDefaultNewCameraMatrixMatSizeBoolean() {
-        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0, size, true);
-
-        assertFalse(mtx.empty());
-        assertFalse(0 == Core.countNonZero(mtx));
-        // TODO_: write better test
-    }
-
     public void testGetDerivKernelsMatMatIntIntInt() {
         Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
         Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
@@ -1139,52 +1124,6 @@ public class ImgprocTest extends OpenCVTestCase {
         fail("Not yet implemented");
     }
 
-    public void testInitUndistortRectifyMap() {
-        fail("Not yet implemented");
-        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
-        cameraMatrix.put(0, 0, 1, 0, 1);
-        cameraMatrix.put(1, 0, 0, 1, 1);
-        cameraMatrix.put(2, 0, 0, 0, 1);
-
-        Mat R = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
-        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
-
-        Mat distCoeffs = new Mat();
-        Mat map1 = new Mat();
-        Mat map2 = new Mat();
-
-        // TODO: complete this test
-        Imgproc.initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, CvType.CV_32F, map1, map2);
-    }
-
-    public void testInitWideAngleProjMapMatMatSizeIntIntMatMat() {
-        fail("Not yet implemented");
-        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
-        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F);
-        // Size imageSize = new Size(2, 2);
-
-        cameraMatrix.put(0, 0, 1, 0, 1);
-        cameraMatrix.put(1, 0, 0, 1, 2);
-        cameraMatrix.put(2, 0, 0, 0, 1);
-
-        distCoeffs.put(0, 0, 1, 3, 2, 4);
-        truth = new Mat(3, 3, CvType.CV_32F);
-        truth.put(0, 0, 0, 0, 0);
-        truth.put(1, 0, 0, 0, 0);
-        truth.put(2, 0, 0, 3, 0);
-        // TODO: No documentation for this function
-        // Imgproc.initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize,
-        // 5, m1type, truthput1, truthput2);
-    }
-
-    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatInt() {
-        fail("Not yet implemented");
-    }
-
-    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatIntDouble() {
-        fail("Not yet implemented");
-    }
-
     public void testIntegral2MatMatMat() {
         Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
         Mat expSum = new Mat(4, 4, CvType.CV_64F);
@@ -1748,72 +1687,6 @@ public class ImgprocTest extends OpenCVTestCase {
         assertMatEqual(makeMask(gray255.clone(), 0), dst);
     }
 
-    public void testUndistortMatMatMatMat() {
-        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
-        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
-            {
-                put(0, 0, 1, 0, 1);
-                put(1, 0, 0, 1, 2);
-                put(2, 0, 0, 0, 1);
-            }
-        };
-        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
-            {
-                put(0, 0, 1, 3, 2, 4);
-            }
-        };
-
-        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs);
-
-        truth = new Mat(3, 3, CvType.CV_32F) {
-            {
-                put(0, 0, 0, 0, 0);
-                put(1, 0, 0, 0, 0);
-                put(2, 0, 0, 3, 0);
-            }
-        };
-        assertMatEqual(truth, dst, EPS);
-    }
-
-    public void testUndistortMatMatMatMatMat() {
-        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
-        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
-            {
-                put(0, 0, 1, 0, 1);
-                put(1, 0, 0, 1, 2);
-                put(2, 0, 0, 0, 1);
-            }
-        };
-        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
-            {
-                put(0, 0, 2, 1, 4, 5);
-            }
-        };
-        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(1));
-
-        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix);
-
-        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
-        assertMatEqual(truth, dst, EPS);
-    }
-
-    //undistortPoints(List<Point> src, List<Point> dst, Mat cameraMatrix, Mat distCoeffs)
-    public void testUndistortPointsListOfPointListOfPointMatMat() {
-        MatOfPoint2f src = new MatOfPoint2f(new Point(1, 2), new Point(3, 4), new Point(-1, -1));
-        MatOfPoint2f dst = new MatOfPoint2f();
-        Mat cameraMatrix = Mat.eye(3, 3, CvType.CV_64FC1);
-        Mat distCoeffs = new Mat(8, 1, CvType.CV_64FC1, new Scalar(0));
-
-        Imgproc.undistortPoints(src, dst, cameraMatrix, distCoeffs);
-
-        assertEquals(src.size(), dst.size());
-        for(int i=0; i<src.toList().size(); i++) {
-            //Log.d("UndistortPoints", "s="+src.get(i)+", d="+dst.get(i));
-            assertTrue(src.toList().get(i).equals(dst.toList().get(i)));
-        }
-    }
-
-
     public void testWarpAffineMatMatMatSize() {
         Mat src = new Mat(3, 3, CvType.CV_32F) {
             {

samples/android/camera-calibration/src/org/opencv/samples/cameracalibration/OnCameraFrameRender.java

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
+import org.opencv.calib3d.Calib3d;
 import org.opencv.core.Core;
 import org.opencv.core.Mat;
 import org.opencv.core.MatOfPoint;
@@ -50,7 +51,7 @@ class UndistortionFrameRender extends FrameRender {
     @Override
     public Mat render(CvCameraViewFrame inputFrame) {
         Mat renderedFrame = new Mat(inputFrame.rgba().size(), inputFrame.rgba().type());
-        Imgproc.undistort(inputFrame.rgba(), renderedFrame,
+        Calib3d.undistort(inputFrame.rgba(), renderedFrame,
                 mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients());
 
         return renderedFrame;
@@ -71,7 +72,7 @@ class ComparisonFrameRender extends FrameRender {
     @Override
     public Mat render(CvCameraViewFrame inputFrame) {
         Mat undistortedFrame = new Mat(inputFrame.rgba().size(), inputFrame.rgba().type());
-        Imgproc.undistort(inputFrame.rgba(), undistortedFrame,
+        Calib3d.undistort(inputFrame.rgba(), undistortedFrame,
                 mCalibrator.getCameraMatrix(), mCalibrator.getDistortionCoefficients());
 
         Mat comparisonFrame = inputFrame.rgba();