Merge pull request opencv#809 from taka-no-me:drop_python1

CMakeLists.txt

@@ -827,8 +827,8 @@ if(BUILD_opencv_python)
   else()
     status("    Libraries:"   HAVE_opencv_python  THEN  ${PYTHON_LIBRARIES}                                        ELSE NO)
   endif()
-  status("    numpy:"         PYTHON_USE_NUMPY    THEN "${PYTHON_NUMPY_INCLUDE_DIR} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
-  status("    packages path:" PYTHON_EXECUTABLE   THEN "${PYTHON_PACKAGES_PATH}"                                   ELSE "-")
+  status("    numpy:"         PYTHON_NUMPY_INCLUDE_DIR THEN "${PYTHON_NUMPY_INCLUDE_DIR} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
+  status("    packages path:" PYTHON_EXECUTABLE        THEN "${PYTHON_PACKAGES_PATH}"                                   ELSE "-")
 endif()
 
 # ========================== java ==========================

cmake/OpenCVDetectPython.cmake

@@ -14,7 +14,6 @@ if(WIN32 AND NOT PYTHON_EXECUTABLE)
 endif()
 find_host_package(PythonInterp 2.0)
 
-unset(PYTHON_USE_NUMPY CACHE)
 unset(HAVE_SPHINX CACHE)
 if(PYTHON_EXECUTABLE)
   if(PYTHON_VERSION_STRING)
@@ -93,7 +92,6 @@ if(PYTHON_EXECUTABLE)
     endif()
 
     if(PYTHON_NUMPY_INCLUDE_DIR)
-      set(PYTHON_USE_NUMPY TRUE)
       execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print numpy.version.version"
                         RESULT_VARIABLE PYTHON_NUMPY_PROCESS
                         OUTPUT_VARIABLE PYTHON_NUMPY_VERSION

doc/_themes/blue/static/default.css_t

@@ -310,21 +310,6 @@ dl.pyfunction > dt:first-child {
     margin-bottom: 7px;
 }
 
-dl.pyoldfunction > dt:first-child {
-    margin-bottom: 7px;
-    color: #8080B0;
-}
-
-dl.pyoldfunction > dt:first-child tt.descname
-{
-    color: #8080B0;
-}
-
-dl.pyoldfunction > dt:first-child tt.descclassname
-{
-    color: #8080B0;
-}
-
 dl.jfunction > dt:first-child {
     margin-bottom: 7px;
 }

doc/ocv.py

@@ -267,10 +267,6 @@ def get_index_text(self, modname, name_cls):
         else:
             return ''
 
-class OCVPyOldModulelevel(OCVPyModulelevel):
-    directive_prefix = 'pyold'
-    pass
-
 class OCVPyXRefRole(XRefRole):
     def process_link(self, env, refnode, has_explicit_title, title, target):
         refnode['ocv:module'] = env.temp_data.get('ocv:module')
@@ -1491,7 +1487,6 @@ class OCVDomain(Domain):
         'cfunction': ObjType(l_('cfunction'), 'cfunc', 'cfuncx'),
         'jfunction': ObjType(l_('jfunction'), 'jfunc', 'jfuncx'),
         'pyfunction': ObjType(l_('pyfunction'), 'pyfunc'),
-        'pyoldfunction': ObjType(l_('pyoldfunction'), 'pyoldfunc'),
         'member':   ObjType(l_('member'),   'member'),
         'emember':   ObjType(l_('emember'),   'emember'),
         'type':     ObjType(l_('type'),     'type'),
@@ -1505,7 +1500,6 @@ class OCVDomain(Domain):
         'cfunction':    OCVCFunctionObject,
         'jfunction':    OCVJavaFunctionObject,
         'pyfunction':   OCVPyModulelevel,
-        'pyoldfunction':   OCVPyOldModulelevel,
         'member':       OCVMemberObject,
         'emember':      OCVEnumMemberObject,
         'type':         OCVTypeObject,
@@ -1522,7 +1516,6 @@ class OCVDomain(Domain):
         'jfunc' :  OCVXRefRole(fix_parens=True),
         'jfuncx' :  OCVXRefRole(),
         'pyfunc' :  OCVPyXRefRole(),
-        'pyoldfunc' :  OCVPyXRefRole(),
         'member': OCVXRefRole(),
         'emember': OCVXRefRole(),
         'type':   OCVXRefRole(),
@@ -1612,7 +1605,6 @@ def get_type_name(self, type, primary=False):
             'cfunction':     _('C function'),
             'jfunction':     _('Java method'),
             'pyfunction':    _('Python function'),
-            'pyoldfunction': _('Legacy Python function'),
             'member':        _('C++ member'),
             'emember':       _('enum member'),
             'type':          _('C/C++ type'),

include/opencv/cvaux.h

@@ -51,11 +51,12 @@
 #include "opencv2/photo/photo_c.h"
 #include "opencv2/video/tracking_c.h"
 #include "opencv2/objdetect/objdetect_c.h"
+#include "opencv2/contrib/compat.hpp"
+
 #include "opencv2/legacy.hpp"
 #include "opencv2/legacy/compat.hpp"
 #include "opencv2/legacy/blobtrack.hpp"
 
-#include "opencv2/contrib.hpp"
 
 #endif
 

modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst

@@ -121,8 +121,6 @@ Finds the camera intrinsic and extrinsic parameters from several views of a cali
 
 .. ocv:cfunction:: double cvCalibrateCamera2( const CvMat* object_points, const CvMat* image_points, const CvMat* point_counts, CvSize image_size, CvMat* camera_matrix, CvMat* distortion_coeffs, CvMat* rotation_vectors=NULL, CvMat* translation_vectors=NULL, int flags=0, CvTermCriteria term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON) )
 
-.. ocv:pyoldfunction:: cv.CalibrateCamera2(objectPoints, imagePoints, pointCounts, imageSize, cameraMatrix, distCoeffs, rvecs, tvecs, flags=0)-> None
-
     :param objectPoints: In the new interface it is a vector of vectors of calibration pattern points in the calibration pattern coordinate space. The outer vector contains as many elements as the number of the pattern views. If the same calibration pattern is shown in each view and it is fully visible, all the vectors will be the same. Although, it is possible to use partially occluded patterns, or even different patterns in different views. Then, the vectors will be different. The points are 3D, but since they are in a pattern coordinate system, then, if the rig is planar, it may make sense to put the model to a XY coordinate plane so that Z-coordinate of each input object point is 0.
 
         In the old interface all the vectors of object points from different views are concatenated together.
@@ -279,8 +277,6 @@ For points in an image of a stereo pair, computes the corresponding epilines in
 
 .. ocv:cfunction:: void cvComputeCorrespondEpilines( const CvMat* points, int which_image, const CvMat* fundamental_matrix, CvMat* correspondent_lines )
 
-.. ocv:pyoldfunction:: cv.ComputeCorrespondEpilines(points, whichImage, F, lines) -> None
-
     :param points: Input points.  :math:`N \times 1`  or  :math:`1 \times N`  matrix of type  ``CV_32FC2``  or  ``vector<Point2f>`` .
 
     :param whichImage: Index of the image (1 or 2) that contains the  ``points`` .
@@ -354,7 +350,6 @@ Converts points to/from homogeneous coordinates.
 .. ocv:function:: void convertPointsHomogeneous( InputArray src, OutputArray dst )
 
 .. ocv:cfunction:: void cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst )
-.. ocv:pyoldfunction:: cv.ConvertPointsHomogeneous(src, dst) -> None
 
     :param src: Input array or vector of 2D, 3D, or 4D points.
 
@@ -400,8 +395,6 @@ Decomposes a projection matrix into a rotation matrix and a camera matrix.
 
 .. ocv:cfunction:: void cvDecomposeProjectionMatrix( const CvMat * projMatr, CvMat * calibMatr, CvMat * rotMatr, CvMat * posVect, CvMat * rotMatrX=NULL, CvMat * rotMatrY=NULL, CvMat * rotMatrZ=NULL, CvPoint3D64f * eulerAngles=NULL )
 
-.. ocv:pyoldfunction:: cv.DecomposeProjectionMatrix(projMatrix, cameraMatrix, rotMatrix, transVect, rotMatrX=None, rotMatrY=None, rotMatrZ=None) -> eulerAngles
-
     :param projMatrix: 3x4 input projection matrix P.
 
     :param cameraMatrix: Output 3x3 camera matrix K.
@@ -436,7 +429,6 @@ Renders the detected chessboard corners.
 .. ocv:pyfunction:: cv2.drawChessboardCorners(image, patternSize, corners, patternWasFound) -> image
 
 .. ocv:cfunction:: void cvDrawChessboardCorners( CvArr* image, CvSize pattern_size, CvPoint2D32f* corners, int count, int pattern_was_found )
-.. ocv:pyoldfunction:: cv.DrawChessboardCorners(image, patternSize, corners, patternWasFound)-> None
 
     :param image: Destination image. It must be an 8-bit color image.
 
@@ -459,7 +451,6 @@ Finds the positions of internal corners of the chessboard.
 .. ocv:pyfunction:: cv2.findChessboardCorners(image, patternSize[, corners[, flags]]) -> retval, corners
 
 .. ocv:cfunction:: int cvFindChessboardCorners( const void* image, CvSize pattern_size, CvPoint2D32f* corners, int* corner_count=NULL, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE )
-.. ocv:pyoldfunction:: cv.FindChessboardCorners(image, patternSize, flags=CV_CALIB_CB_ADAPTIVE_THRESH) -> corners
 
     :param image: Source chessboard view. It must be an 8-bit grayscale or color image.
 
@@ -564,8 +555,6 @@ Finds an object pose from 3D-2D point correspondences.
 
 .. ocv:cfunction:: void cvFindExtrinsicCameraParams2( const CvMat* object_points, const CvMat* image_points, const CvMat* camera_matrix, const CvMat* distortion_coeffs, CvMat* rotation_vector, CvMat* translation_vector, int use_extrinsic_guess=0 )
 
-.. ocv:pyoldfunction:: cv.FindExtrinsicCameraParams2(objectPoints, imagePoints, cameraMatrix, distCoeffs, rvec, tvec, useExtrinsicGuess=0 ) -> None
-
     :param objectPoints: Array of object points in the object coordinate space, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points.  ``vector<Point3f>``  can be also passed here.
 
     :param imagePoints: Array of corresponding image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points.  ``vector<Point2f>``  can be also passed here.
@@ -636,7 +625,6 @@ Calculates a fundamental matrix from the corresponding points in two images.
 .. ocv:pyfunction:: cv2.findFundamentalMat(points1, points2[, method[, param1[, param2[, mask]]]]) -> retval, mask
 
 .. ocv:cfunction:: int cvFindFundamentalMat( const CvMat* points1, const CvMat* points2, CvMat* fundamental_matrix, int method=CV_FM_RANSAC, double param1=3., double param2=0.99, CvMat* status=NULL )
-.. ocv:pyoldfunction:: cv.FindFundamentalMat(points1, points2, fundamentalMatrix, method=CV_FM_RANSAC, param1=1., param2=0.99, status=None) -> retval
 
     :param points1: Array of  ``N``  points from the first image. The point coordinates should be floating-point (single or double precision).
 
@@ -820,8 +808,6 @@ Finds a perspective transformation between two planes.
 
 .. ocv:cfunction:: int cvFindHomography( const CvMat* src_points, const CvMat* dst_points, CvMat* homography, int method=0, double ransacReprojThreshold=3, CvMat* mask=0 )
 
-.. ocv:pyoldfunction:: cv.FindHomography(srcPoints, dstPoints, H, method=0, ransacReprojThreshold=3.0, status=None) -> None
-
     :param srcPoints: Coordinates of the points in the original plane, a matrix of the type  ``CV_32FC2``  or ``vector<Point2f>`` .
 
     :param dstPoints: Coordinates of the points in the target plane, a matrix of the type  ``CV_32FC2``  or a  ``vector<Point2f>`` .
@@ -946,8 +932,6 @@ Returns the new camera matrix based on the free scaling parameter.
 
 .. ocv:cfunction:: void cvGetOptimalNewCameraMatrix( const CvMat* camera_matrix, const CvMat* dist_coeffs, CvSize image_size, double alpha, CvMat* new_camera_matrix, CvSize new_imag_size=cvSize(0,0), CvRect* valid_pixel_ROI=0, int center_principal_point=0 )
 
-.. ocv:pyoldfunction:: cv.GetOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, alpha, newCameraMatrix, newImageSize=(0, 0), validPixROI=0, centerPrincipalPoint=0) -> None
-
     :param cameraMatrix: Input camera matrix.
 
     :param distCoeffs: Input vector of distortion coefficients  :math:`(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])`  of 4, 5, 8 or 12 elements. If the vector is NULL/empty, the zero distortion coefficients are assumed.
@@ -981,8 +965,6 @@ Finds an initial camera matrix from 3D-2D point correspondences.
 
 .. ocv:cfunction:: void cvInitIntrinsicParams2D( const CvMat* object_points, const CvMat* image_points, const CvMat* npoints, CvSize image_size, CvMat* camera_matrix, double aspect_ratio=1. )
 
-.. ocv:pyoldfunction:: cv.InitIntrinsicParams2D(objectPoints, imagePoints, npoints, imageSize, cameraMatrix, aspectRatio=1.) -> None
-
     :param objectPoints: Vector of vectors of the calibration pattern points in the calibration pattern coordinate space. In the old interface all the per-view vectors are concatenated. See :ocv:func:`calibrateCamera` for details.
 
     :param imagePoints: Vector of vectors of the projections of the calibration pattern points. In the old interface all the per-view vectors are concatenated.
@@ -1030,8 +1012,6 @@ Projects 3D points to an image plane.
 
 .. ocv:cfunction:: void cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector, const CvMat* translation_vector, const CvMat* camera_matrix, const CvMat* distortion_coeffs, CvMat* image_points, CvMat* dpdrot=NULL, CvMat* dpdt=NULL, CvMat* dpdf=NULL, CvMat* dpdc=NULL, CvMat* dpddist=NULL, double aspect_ratio=0 )
 
-.. ocv:pyoldfunction:: cv.ProjectPoints2(objectPoints, rvec, tvec, cameraMatrix, distCoeffs, imagePoints, dpdrot=None, dpdt=None, dpdf=None, dpdc=None, dpddist=None)-> None
-
     :param objectPoints: Array of object points, 3xN/Nx3 1-channel or 1xN/Nx1 3-channel  (or  ``vector<Point3f>`` ), where N is the number of points in the view.
 
     :param rvec: Rotation vector. See  :ocv:func:`Rodrigues` for details.
@@ -1075,8 +1055,6 @@ Reprojects a disparity image to 3D space.
 
 .. ocv:cfunction:: void cvReprojectImageTo3D( const CvArr* disparityImage, CvArr* _3dImage, const CvMat* Q, int handleMissingValues=0 )
 
-.. ocv:pyoldfunction:: cv.ReprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues=0) -> None
-
     :param disparity: Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image.
 
     :param _3dImage: Output 3-channel floating-point image of the same size as  ``disparity`` . Each element of  ``_3dImage(x,y)``  contains 3D coordinates of the point  ``(x,y)``  computed from the disparity map.
@@ -1109,7 +1087,6 @@ Computes an RQ decomposition of 3x3 matrices.
 .. ocv:pyfunction:: cv2.RQDecomp3x3(src[, mtxR[, mtxQ[, Qx[, Qy[, Qz]]]]]) -> retval, mtxR, mtxQ, Qx, Qy, Qz
 
 .. ocv:cfunction:: void cvRQDecomp3x3( const CvMat * matrixM, CvMat * matrixR, CvMat * matrixQ, CvMat * matrixQx=NULL, CvMat * matrixQy=NULL, CvMat * matrixQz=NULL, CvPoint3D64f * eulerAngles=NULL )
-.. ocv:pyoldfunction:: cv.RQDecomp3x3(M, R, Q, Qx=None, Qy=None, Qz=None) -> eulerAngles
 
     :param src: 3x3 input matrix.
 
@@ -1140,8 +1117,6 @@ Converts a rotation matrix to a rotation vector or vice versa.
 
 .. ocv:cfunction:: int cvRodrigues2( const CvMat* src, CvMat* dst, CvMat* jacobian=0 )
 
-.. ocv:pyoldfunction:: cv.Rodrigues2(src, dst, jacobian=0)-> None
-
     :param src: Input rotation vector (3x1 or 1x3) or rotation matrix (3x3).
 
     :param dst: Output rotation matrix (3x3) or rotation vector (3x1 or 1x3), respectively.
@@ -1269,8 +1244,6 @@ Calibrates the stereo camera.
 
 .. ocv:cfunction:: double cvStereoCalibrate( const CvMat* object_points, const CvMat* image_points1, const CvMat* image_points2, const CvMat* npoints, CvMat* camera_matrix1, CvMat* dist_coeffs1, CvMat* camera_matrix2, CvMat* dist_coeffs2, CvSize image_size, CvMat* R, CvMat* T, CvMat* E=0, CvMat* F=0, CvTermCriteria term_crit=cvTermCriteria( CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6), int flags=CV_CALIB_FIX_INTRINSIC )
 
-.. ocv:pyoldfunction:: cv.StereoCalibrate(objectPoints, imagePoints1, imagePoints2, pointCounts, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize, R, T, E=None, F=None, term_crit=(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, 1e-6), flags=CV_CALIB_FIX_INTRINSIC)-> None
-
     :param objectPoints: Vector of vectors of the calibration pattern points.
 
     :param imagePoints1: Vector of vectors of the projections of the calibration pattern points, observed by the first camera.
@@ -1362,8 +1335,6 @@ Computes rectification transforms for each head of a calibrated stereo camera.
 
 .. ocv:cfunction:: void cvStereoRectify( const CvMat* camera_matrix1, const CvMat* camera_matrix2, const CvMat* dist_coeffs1, const CvMat* dist_coeffs2, CvSize image_size, const CvMat* R, const CvMat* T, CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2, CvMat* Q=0, int flags=CV_CALIB_ZERO_DISPARITY, double alpha=-1, CvSize new_image_size=cvSize(0,0), CvRect* valid_pix_ROI1=0, CvRect* valid_pix_ROI2=0 )
 
-.. ocv:pyoldfunction:: cv.StereoRectify(cameraMatrix1, cameraMatrix2, distCoeffs1, distCoeffs2, imageSize, R, T, R1, R2, P1, P2, Q=None, flags=CV_CALIB_ZERO_DISPARITY, alpha=-1, newImageSize=(0, 0)) -> (roi1, roi2)
-
     :param cameraMatrix1: First camera matrix.
 
     :param cameraMatrix2: Second camera matrix.
@@ -1451,8 +1422,6 @@ Computes a rectification transform for an uncalibrated stereo camera.
 
 .. ocv:cfunction:: int cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2, const CvMat* F, CvSize img_size, CvMat* H1, CvMat* H2, double threshold=5 )
 
-.. ocv:pyoldfunction:: cv.StereoRectifyUncalibrated(points1, points2, F, imageSize, H1, H2, threshold=5)-> None
-
     :param points1: Array of feature points in the first image.
 
     :param points2: The corresponding points in the second image. The same formats as in  :ocv:func:`findFundamentalMat` are supported.