fixed "import cv" in the new python samples. corrected Python bindings to...

fixed "import cv" in the new python samples. corrected Python bindings to match the documentation and vice versa (NOTE: in cv2.stereoCalibrate the parameter ordering has been changed)

modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst

@@ -113,7 +113,7 @@ Finds the camera intrinsic and extrinsic parameters from several views of a cali
 
 .. ocv:function:: double calibrateCamera( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags=0 )
 
-.. ocv:pyfunction:: cv2.calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix, distCoeffs[, rvecs[, tvecs[, flags]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
+.. ocv:pyfunction:: cv2.calibrateCamera(objectPoints, imagePoints, imageSize[, cameraMatrix[, distCoeffs[, rvecs[, tvecs[, flags]]]]]) -> retval, cameraMatrix, distCoeffs, rvecs, tvecs
 
 .. ocv:cfunction:: double cvCalibrateCamera2( const CvMat* objectPoints, const CvMat* imagePoints, const CvMat* pointCounts, CvSize imageSize, CvMat* cameraMatrix, CvMat* distCoeffs, CvMat* rvecs=NULL, CvMat* tvecs=NULL, int flags=0 )
 
@@ -1204,7 +1204,7 @@ Calibrates the stereo camera.
 
 .. ocv:function:: double stereoCalibrate( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+                         TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC )
 
-.. ocv:pyfunction:: cv2.stereoCalibrate(objectPoints, imagePoints1, imagePoints2, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, imageSize[, R[, T[, E[, F[, criteria[, flags]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
+.. ocv:pyfunction:: cv2.stereoCalibrate(objectPoints, imagePoints1, imagePoints2, imageSize[, cameraMatrix1[, distCoeffs1[, cameraMatrix2[, distCoeffs2[, R[, T[, E[, F[, criteria[, flags]]]]]]) -> retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F
 
 .. ocv:cfunction:: double cvStereoCalibrate( const CvMat* objectPoints, const CvMat* imagePoints1, const CvMat* imagePoints2, const CvMat* pointCounts, CvMat* cameraMatrix1, CvMat* distCoeffs1, CvMat* cameraMatrix2, CvMat* distCoeffs2, CvSize imageSize, CvMat* R, CvMat* T, CvMat* E=0, CvMat* F=0, CvTermCriteria termCrit=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, termCrit=(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 30, 1e-6), flags=CV_CALIB_FIX_INTRINSIC)-> None

modules/imgproc/doc/motion_analysis_and_object_tracking.rst

@@ -9,7 +9,7 @@ Adds an image to the accumulator.
 
 .. ocv:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulate(src, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulate(src, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvAcc( const CvArr* src, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.Acc(src, dst, mask=None)-> None
@@ -44,7 +44,7 @@ Adds the square of a source image to the accumulator.
 
 .. ocv:function:: void accumulateSquare( InputArray src, InputOutputArray dst,  InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateSquare(src, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateSquare(src, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvSquareAcc( const CvArr* src, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.SquareAcc(src, dst, mask=None)-> None
@@ -77,7 +77,7 @@ Adds the per-element product of two input images to the accumulator.
 
 .. ocv:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateProduct(src1, src2, dst[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateProduct(src1, src2, dst[, mask]) -> None
 
 .. ocv:cfunction:: void cvMultiplyAcc( const CvArr* src1, const CvArr* src2, CvArr* dst, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.MultiplyAcc(src1, src2, dst, mask=None)-> None
@@ -112,7 +112,7 @@ Updates a running average.
 
 .. ocv:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray() )
 
-.. ocv:pyfunction:: cv2.accumulateWeighted(src, dst, alpha[, mask]) -> dst
+.. ocv:pyfunction:: cv2.accumulateWeighted(src, dst, alpha[, mask]) -> None
 
 .. ocv:cfunction:: void cvRunningAvg( const CvArr* src, CvArr* dst, double alpha, const CvArr* mask=NULL )
 .. ocv:pyoldfunction:: cv.RunningAvg(src, dst, alpha, mask=None)-> None

modules/imgproc/include/opencv2/imgproc/imgproc.hpp

@@ -574,16 +574,16 @@ CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
                                         int sdepth=-1 );
 
 //! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
-CV_EXPORTS_W void accumulate( InputArray src, CV_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
                               InputArray mask=noArray() );
 //! adds squared src image to the accumulator (dst += src*src).
-CV_EXPORTS_W void accumulateSquare( InputArray src, CV_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
                                     InputArray mask=noArray() );
 //! adds product of the 2 images to the accumulator (dst += src1*src2).
 CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
-                                     CV_OUT InputOutputArray dst, InputArray mask=noArray() );
+                                     InputOutputArray dst, InputArray mask=noArray() );
 //! updates the running average (dst = dst*(1-alpha) + src*alpha)
-CV_EXPORTS_W void accumulateWeighted( InputArray src, CV_OUT InputOutputArray dst,
+CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
                                       double alpha, InputArray mask=noArray() );
     
 //! type of the threshold operation

modules/python/src2/gen2.py

@@ -357,7 +357,7 @@ class FuncVariant(object):
                 continue
             if a.returnarg:
                 outlist.append((a.name, argno))
-            if not a.inputarg:
+            if not a.inputarg or a.returnarg:
                 if a.isbig():
                     outarr_list.append((a.name, argno))
                 continue

modules/video/doc/motion_analysis_and_object_tracking.rst

@@ -34,7 +34,7 @@ Calculates an optical flow for a sparse feature set using the iterative Lucas-Ka
 
     :param criteria: Parameter specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations  ``criteria.maxCount``  or when the search window moves by less than  ``criteria.epsilon`` .
     
-    :param derivLambda: Relative weight of the spatial image derivatives impact to the optical flow estimation. If  ``derivLambda=0`` , only the image intensity is used. If  ``derivLambda=1`` , only derivatives are used. Any other values between 0 and 1 mean that both derivatives and the image intensity are used (in the corresponding proportions).
+    :param derivLambda: Not used.
 
     :param flags: Operation flags:
 

samples/python2/calibrate.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 import os
 from common import splitfn
 
@@ -50,10 +51,7 @@ if __name__ == '__main__':
         
         print 'ok'
 
-    camera_matrix = np.zeros((3, 3))
-    dist_coefs = np.zeros(4)
-    img_n = len(img_points)
-    rms, camera_matrix, dist_coefs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, (w, h), camera_matrix, dist_coefs)
+    rms, camera_matrix, dist_coefs, rvecs, tvecs = cv2.calibrateCamera(obj_points, img_points, (w, h))
     print "RMS:", rms
     print "camera matrix:\n", camera_matrix
     print "distortion coefficients: ", dist_coefs.ravel()

samples/python2/coherence.py

@@ -7,7 +7,8 @@
 '''
 
 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 
 
 def coherence_filter(img, sigma = 11, str_sigma = 11, blend = 0.5, iter_n = 4):

samples/python2/color_histogram.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from time import clock
 import sys
 

samples/python2/common.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 import os
 
 image_extensions = ['.bmp', '.jpg', '.jpeg', '.png', '.tif', '.tiff', '.pbm', '.pgm', '.ppm']

samples/python2/distrans.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from common import make_cmap
 
 help_message = '''USAGE: distrans.py [<image>]

samples/python2/edge.py

-import cv2, cv
+import cv2
+import cv2.cv as cv
 import video
 import sys
 

samples/python2/facedetect.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from video import create_capture
 from common import clock, draw_str
 

samples/python2/find_obj.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from common import anorm
 
 help_message = '''SURF image match 

samples/python2/floodfill.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 
 help_message = '''USAGE: floodfill.py [<image>]
 

samples/python2/lk_track.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 import video
 from common import anorm2, draw_str
 from time import clock
@@ -15,7 +16,7 @@ Keys:
 
 
 
-lk_params = dict( winSize  = (3, 3), 
+lk_params = dict( winSize  = (21, 21), 
                   maxLevel = 2, 
                   criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03),
                   derivLambda = 0.0 )    

samples/python2/motempl.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 import video
 from common import nothing, clock, draw_str
 

samples/python2/obj_detect.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 
 def detect(img, cascade):
     rects = cascade.detectMultiScale(img, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

samples/python2/opt_flow.py

 import numpy as np
 import math
-import cv2, cv
+import cv2
+import cv2.cv as cv
 import video
 
 help_message = '''

samples/python2/stereo_match.py

@@ -5,7 +5,8 @@ Resulting .ply file cam be easily viewed using MeshLab (http://meshlab.sourcefor
 '''
 
 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 
 ply_header = '''ply
 format ascii 1.0

samples/python2/turing.py

@@ -4,7 +4,8 @@ Inspired by http://www.jonathanmccabe.com/Cyclic_Symmetric_Multi-Scale_Turing_Pa
 '''
 
 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from common import draw_str
 import getopt, sys
 from itertools import count

samples/python2/watershed.py

 import numpy as np
-import cv2, cv
+import cv2
+import cv2.cv as cv
 from common import Sketcher
 
 help_message = '''