types-opencv-python 1.0.0__py3-none-any.whl

cv2/fisheye.pyi

@@ -0,0 +1,302 @@
+'''
+encode: utf-8
+Date: 2026-02-19 15:09:25
+LastEditTime: 2026-02-19 15:09:25
+FilePath: /genout6/media/adminmaster/veracrypt3/Develop/td-opencv/dev/base.pyi
+'''
+import typing
+from typing import overload
+
+T0=typing.TypeVar("T0")
+T1=typing.TypeVar("T1")
+T2=typing.TypeVar("T2")
+T3=typing.TypeVar("T3")
+T4=typing.TypeVar("T4")
+T5=typing.TypeVar("T5")
+T6=typing.TypeVar("T6")
+T7=typing.TypeVar("T7")
+T8=typing.TypeVar("T8")
+
+retval=typing.Any
+readyIndex=int
+
+CALIB_USE_INTRINSIC_GUESS:int = ...
+CALIB_RECOMPUTE_EXTRINSIC:int = ...
+CALIB_CHECK_COND:int = ...
+CALIB_FIX_SKEW:int = ...
+CALIB_FIX_K1:int = ...
+CALIB_FIX_K2:int = ...
+CALIB_FIX_K3:int = ...
+CALIB_FIX_K4:int = ...
+CALIB_FIX_INTRINSIC:int = ...
+CALIB_FIX_PRINCIPAL_POINT:int = ...
+CALIB_ZERO_DISPARITY:int = ...
+CALIB_FIX_FOCAL_LENGTH:int = ...
+def calibrate(objectPoints,imagePoints,image_size,K:T0,D:T0,rvecs:T0=...,tvecs:T0=...,flags:int=...,criteria=...) -> retval|T0|T0|T0|T0:
+    """
+    ```
+    Performs camera calibration. 
+    ```
+    ---
+    ```
+    Parameters:
+    objectPoints:               vector of vectors of calibration pattern points in the calibration pattern coordinate space. 
+    imagePoints:                vector of vectors of the projections of calibration pattern points. imagePoints.size() and objectPoints.size() and imagePoints[i].size() must be equal to objectPoints[i].size() for each i. 
+    image_size:                 Size of the image used only to initialize the camera intrinsic matrix. 
+    K:                          Output 3x3 floating-point camera intrinsic matrix $\cameramatrix{A}$ . If fisheye::CALIB_USE_INTRINSIC_GUESS is specified, some or all of fx, fy, cx, cy must be initialized before calling the function. 
+    D:                          Output vector of distortion coefficients $\distcoeffsfisheye$. 
+    rvecs:                      Output vector of rotation vectors (see Rodrigues ) estimated for each pattern view. That is, each k-th rotation vector together with the corresponding k-th translation vector (see the next output parameter description) brings the calibration pattern from the model coordinate space (in which object points are specified) to the world coordinate space, that is, a real position of the calibration pattern in the k-th pattern view (k=0.. M -1). 
+    tvecs:                      Output vector of translation vectors estimated for each pattern view. 
+    flags:                      Different flags that may be zero or a combination of the following values:
+    fisheye::CALIB_USE_INTRINSIC_GUESS cameraMatrix contains valid initial values of fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image center ( imageSize is used), and focal distances are computed in a least-squares fashion.
+    fisheye::CALIB_RECOMPUTE_EXTRINSIC Extrinsic will be recomputed after each iteration of intrinsic optimization.
+    fisheye::CALIB_CHECK_COND The functions will check validity of condition number.
+    fisheye::CALIB_FIX_SKEW Skew coefficient (alpha) is set to zero and stay zero.
+    fisheye::CALIB_FIX_K1,..., fisheye::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay zero.
+    fisheye::CALIB_FIX_PRINCIPAL_POINT The principal point is not changed during the global optimization. It stays at the center or at a different location specified when fisheye::CALIB_USE_INTRINSIC_GUESS is set too.
+    fisheye::CALIB_FIX_FOCAL_LENGTH The focal length is not changed during the global optimization. It is the $max(width,height)/\pi$ or the provided $f_x$, $f_y$ when fisheye::CALIB_USE_INTRINSIC_GUESS is set too. 
+    
+    
+    criteria:                   Termination criteria for the iterative optimization algorithm. 
+    ```
+    """
+
+@overload
+def distortPoints(undistorted,K,D,distorted:T0=...,alpha:float=...) -> T0:
+    """
+    ```
+    Distorts 2D points using fisheye model. 
+    ```
+    ---
+    ```
+    Parameters:
+    undistorted:                Array of object points, 1xN/Nx1 2-channel (or vector<Point2f> ), where N is the number of points in the view. 
+    distorted:                  Output array of image points, 1xN/Nx1 2-channel, or vector<Point2f> .
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    alpha:                      The skew coefficient. 
+    ```
+    """
+
+@overload
+def distortPoints(undistorted,Kundistorted,K,D,distorted:T0=...,alpha:float=...) -> T0:
+    """
+    ```
+    
+    ```
+    ---
+    ```
+    Parameters:
+    undistorted:                Array of object points, 1xN/Nx1 2-channel (or vector<Point2f> ), where N is the number of points in the view. 
+    distorted:                  Output array of image points, 1xN/Nx1 2-channel, or vector<Point2f> . 
+    Kundistorted:               Camera intrinsic matrix used as new camera matrix for undistortion. 
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    alpha:                      The skew coefficient. 
+    ```
+    """
+
+def estimateNewCameraMatrixForUndistortRectify(K,D,image_size,R,P:T0=...,balance:float=...,new_size=...,fov_scale:float=...) -> T0:
+    """
+    ```
+    Estimates new camera intrinsic matrix for undistortion or rectification. 
+    ```
+    ---
+    ```
+    Parameters:
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    image_size:                 Size of the image 
+    R:                          Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel 
+    P:                          New camera intrinsic matrix (3x3) or new projection matrix (3x4) 
+    balance:                    Sets the new focal length in range between the min focal length and the max focal length. Balance is in range of [0, 1]. 
+    new_size:                   the new size 
+    fov_scale:                  Divisor for new focal length. 
+    ```
+    """
+
+def initUndistortRectifyMap(K,D,R,P,size,m1type:int,map1:T0=...,map2:T0=...) -> T0|T0:
+    """
+    ```
+    Computes undistortion and rectification maps for image transform by remap. If D is empty zero distortion is used, if R or P is empty identity matrixes are used. 
+    ```
+    ---
+    ```
+    Parameters:
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    R:                          Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel 
+    P:                          New camera intrinsic matrix (3x3) or new projection matrix (3x4) 
+    size:                       Undistorted image size. 
+    m1type:                     Type of the first output map that can be CV_32FC1 or CV_16SC2 . See convertMaps for details. 
+    map1:                       The first output map. 
+    map2:                       The second output map. 
+    ```
+    """
+
+def projectPoints(objectPoints,rvec,tvec,K,D,imagePoints:T0=...,alpha:float=...,jacobian:T0=...) -> T0|T0:
+    """
+    ```
+    
+    ```
+    """
+
+def solvePnP(objectPoints,imagePoints,cameraMatrix,distCoeffs,rvec:T0=...,tvec:T0=...,useExtrinsicGuess:bool=...,flags:int=...,criteria=...) -> retval|T0|T0:
+    """
+    ```
+    Finds an object pose from 3D-2D point correspondences for fisheye camera model. 
+    ```
+    ---
+    ```
+    Parameters:
+    objectPoints:               Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points. vector<Point3d> can also be passed here. 
+    imagePoints:                Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. vector<Point2d> can also be passed here. 
+    cameraMatrix:               Input camera intrinsic matrix $\cameramatrix{A}$ . 
+    distCoeffs:                 Input vector of distortion coefficients (4x1/1x4). 
+    rvec:                       Output rotation vector (see Rodrigues ) that, together with tvec, brings points from the model coordinate system to the camera coordinate system. 
+    tvec:                       Output translation vector. 
+    useExtrinsicGuess:          Parameter used for SOLVEPNP_ITERATIVE. If true (1), the function uses the provided rvec and tvec values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them. 
+    flags:                      Method for solving a PnP problem: see calib3d_solvePnP_flags 
+    criteria:                   Termination criteria for internal undistortPoints call. The function internally undistorts points with undistortPoints and call cv::solvePnP, thus the input are very similar. More information about Perspective-n-Points is described in Perspective-n-Point (PnP) pose computation for more information. 
+    ```
+    """
+
+def solvePnPRansac(objectPoints,imagePoints,cameraMatrix,distCoeffs,rvec:T0=...,tvec:T0=...,useExtrinsicGuess:bool=...,iterationsCount:int=...,reprojectionError:float=...,confidence:float=...,inliers:T0=...,flags:int=...,criteria=...) -> retval|T0|T0|T0:
+    """
+    ```
+    Finds an object pose from 3D-2D point correspondences using the RANSAC scheme for fisheye camera moodel. 
+    ```
+    ---
+    ```
+    Parameters:
+    objectPoints:               Array of object points in the object coordinate space, Nx3 1-channel or 1xN/Nx1 3-channel, where N is the number of points. vector<Point3d> can be also passed here. 
+    imagePoints:                Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel, where N is the number of points. vector<Point2d> can be also passed here. 
+    cameraMatrix:               Input camera intrinsic matrix $\cameramatrix{A}$ . 
+    distCoeffs:                 Input vector of distortion coefficients (4x1/1x4). 
+    rvec:                       Output rotation vector (see Rodrigues ) that, together with tvec, brings points from the model coordinate system to the camera coordinate system. 
+    tvec:                       Output translation vector. 
+    useExtrinsicGuess:          Parameter used for SOLVEPNP_ITERATIVE. If true (1), the function uses the provided rvec and tvec values as initial approximations of the rotation and translation vectors, respectively, and further optimizes them. 
+    iterationsCount:            Number of iterations. 
+    reprojectionError:          Inlier threshold value used by the RANSAC procedure. The parameter value is the maximum allowed distance between the observed and computed point projections to consider it an inlier. 
+    confidence:                 The probability that the algorithm produces a useful result. 
+    inliers:                    Output vector that contains indices of inliers in objectPoints and imagePoints . 
+    flags:                      Method for solving a PnP problem: see calib3d_solvePnP_flags This function returns the rotation and the translation vectors that transform a 3D point expressed in the object coordinate frame to the camera coordinate frame, using different methods:
+    P3P methods (SOLVEPNP_P3P, SOLVEPNP_AP3P): need 4 input points to return a unique solution.
+    SOLVEPNP_IPPE Input points must be >= 4 and object points must be coplanar.
+    SOLVEPNP_IPPE_SQUARE Special case suitable for marker pose estimation. Number of input points must be 4. Object points must be defined in the following order:
+    point 0: [-squareLength / 2, squareLength / 2, 0]
+    point 1: [ squareLength / 2, squareLength / 2, 0]
+    point 2: [ squareLength / 2, -squareLength / 2, 0]
+    point 3: [-squareLength / 2, -squareLength / 2, 0]
+    for all the other flags, number of input points must be >= 4 and object points can be in any configuration. 
+    
+    
+    criteria:                   Termination criteria for internal undistortPoints call. The function interally undistorts points with undistortPoints and call cv::solvePnP, thus the input are very similar. More information about Perspective-n-Points is described in Perspective-n-Point (PnP) pose computation for more information. 
+    ```
+    """
+
+@overload
+def stereoCalibrate(objectPoints,imagePoints1,imagePoints2,K1:T0,D1:T0,K2:T0,D2:T0,imageSize,R:T0=...,T:T0=...,rvecs:T0=...,tvecs:T0=...,flags:int=...,criteria=...) -> retval|T0|T0|T0|T0|T0|T0|T0|T0:
+    """
+    ```
+    Performs stereo calibration. 
+    ```
+    ---
+    ```
+    Parameters:
+    objectPoints:               Vector of vectors of the calibration pattern points. 
+    imagePoints1:               Vector of vectors of the projections of the calibration pattern points, observed by the first camera. 
+    imagePoints2:               Vector of vectors of the projections of the calibration pattern points, observed by the second camera. 
+    K1:                         Input/output first camera intrinsic matrix: $\vecthreethree{f_x^{(j)}}{0}{c_x^{(j)}}{0}{f_y^{(j)}}{c_y^{(j)}}{0}{0}{1}$ , $j = 0,\, 1$ . If any of fisheye::CALIB_USE_INTRINSIC_GUESS , fisheye::CALIB_FIX_INTRINSIC are specified, some or all of the matrix components must be initialized. 
+    D1:                         Input/output vector of distortion coefficients $\distcoeffsfisheye$ of 4 elements. 
+    K2:                         Input/output second camera intrinsic matrix. The parameter is similar to K1 . 
+    D2:                         Input/output lens distortion coefficients for the second camera. The parameter is similar to D1 . 
+    imageSize:                  Size of the image used only to initialize camera intrinsic matrix. 
+    R:                          Output rotation matrix between the 1st and the 2nd camera coordinate systems. 
+    T:                          Output translation vector between the coordinate systems of the cameras. 
+    rvecs:                      Output vector of rotation vectors ( Rodrigues ) estimated for each pattern view in the coordinate system of the first camera of the stereo pair (e.g. std::vector<cv::Mat>). More in detail, each i-th rotation vector together with the corresponding i-th translation vector (see the next output parameter description) brings the calibration pattern from the object coordinate space (in which object points are specified) to the camera coordinate space of the first camera of the stereo pair. In more technical terms, the tuple of the i-th rotation and translation vector performs a change of basis from object coordinate space to camera coordinate space of the first camera of the stereo pair. 
+    tvecs:                      Output vector of translation vectors estimated for each pattern view, see parameter description of previous output parameter ( rvecs ). 
+    flags:                      Different flags that may be zero or a combination of the following values:
+    fisheye::CALIB_FIX_INTRINSIC Fix K1, K2? and D1, D2? so that only R, T matrices are estimated.
+    fisheye::CALIB_USE_INTRINSIC_GUESS K1, K2 contains valid initial values of fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially set to the image center (imageSize is used), and focal distances are computed in a least-squares fashion.
+    fisheye::CALIB_RECOMPUTE_EXTRINSIC Extrinsic will be recomputed after each iteration of intrinsic optimization.
+    fisheye::CALIB_CHECK_COND The functions will check validity of condition number.
+    fisheye::CALIB_FIX_SKEW Skew coefficient (alpha) is set to zero and stay zero.
+    fisheye::CALIB_FIX_K1,..., fisheye::CALIB_FIX_K4 Selected distortion coefficients are set to zeros and stay zero. 
+    
+    
+    criteria:                   Termination criteria for the iterative optimization algorithm. 
+    ```
+    """
+
+@overload
+def stereoCalibrate(objectPoints,imagePoints1,imagePoints2,K1:T0,D1:T0,K2:T0,D2:T0,imageSize,R:T0=...,T:T0=...,flags:int=...,criteria=...) -> retval|T0|T0|T0|T0|T0|T0:
+    """
+    ```
+    This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. 
+    ```
+    """
+
+def stereoRectify(K1,D1,K2,D2,imageSize,R,tvec,flags:int,R1:T0=...,R2:T0=...,P1:T0=...,P2:T0=...,Q:T0=...,newImageSize=...,balance:float=...,fov_scale:float=...) -> T0|T0|T0|T0|T0:
+    """
+    ```
+    Stereo rectification for fisheye camera model. 
+    ```
+    ---
+    ```
+    Parameters:
+    K1:                         First camera intrinsic matrix. 
+    D1:                         First camera distortion parameters. 
+    K2:                         Second camera intrinsic matrix. 
+    D2:                         Second camera distortion parameters. 
+    imageSize:                  Size of the image used for stereo calibration. 
+    R:                          Rotation matrix between the coordinate systems of the first and the second cameras. 
+    tvec:                       Translation vector between coordinate systems of the cameras. 
+    R1:                         Output 3x3 rectification transform (rotation matrix) for the first camera. 
+    R2:                         Output 3x3 rectification transform (rotation matrix) for the second camera. 
+    P1:                         Output 3x4 projection matrix in the new (rectified) coordinate systems for the first camera. 
+    P2:                         Output 3x4 projection matrix in the new (rectified) coordinate systems for the second camera. 
+    Q:                          Output $4 \times 4$ disparity-to-depth mapping matrix (see reprojectImageTo3D ). 
+    flags:                      Operation flags that may be zero or fisheye::CALIB_ZERO_DISPARITY . If the flag is set, the function makes the principal points of each camera have the same pixel coordinates in the rectified views. And if the flag is not set, the function may still shift the images in the horizontal or vertical direction (depending on the orientation of epipolar lines) to maximize the useful image area. 
+    newImageSize:               New image resolution after rectification. The same size should be passed to initUndistortRectifyMap (see the stereo_calib.cpp sample in OpenCV samples directory). When (0,0) is passed (default), it is set to the original imageSize . Setting it to larger value can help you preserve details in the original image, especially when there is a big radial distortion. 
+    balance:                    Sets the new focal length in range between the min focal length and the max focal length. Balance is in range of [0, 1]. 
+    fov_scale:                  Divisor for new focal length. 
+    ```
+    """
+
+def undistortImage(distorted,K,D,undistorted:T0=...,Knew=...,new_size=...) -> T0:
+    """
+    ```
+    Transforms an image to compensate for fisheye lens distortion. 
+    ```
+    ---
+    ```
+    Parameters:
+    distorted:                  image with fisheye lens distortion. 
+    undistorted:                Output image with compensated fisheye lens distortion. 
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    Knew:                       Camera intrinsic matrix of the distorted image. By default, it is the identity matrix but you may additionally scale and shift the result by using a different matrix. 
+    new_size:                   the new size
+    ```
+    """
+
+def undistortPoints(distorted,K,D,undistorted:T0=...,R=...,P=...,criteria=...) -> T0:
+    """
+    ```
+    Undistorts 2D points using fisheye model. 
+    ```
+    ---
+    ```
+    Parameters:
+    distorted:                  Array of object points, 1xN/Nx1 2-channel (or vector<Point2f> ), where N is the number of points in the view. 
+    undistorted:                Output array of image points, 1xN/Nx1 2-channel, or vector<Point2f> . 
+    K:                          Camera intrinsic matrix $\cameramatrix{K}$. 
+    D:                          Input vector of distortion coefficients $\distcoeffsfisheye$. 
+    R:                          Rectification transformation in the object space: 3x3 1-channel, or vector: 3x1/1x3 1-channel or 1x1 3-channel 
+    P:                          New camera intrinsic matrix (3x3) or new projection matrix (3x4) 
+    criteria:                   Termination criteria 
+    ```
+    """
+
+

cv2/flann.pyi

@@ -0,0 +1,55 @@
+'''
+encode: utf-8
+Date: 2026-02-19 15:09:25
+LastEditTime: 2026-02-19 15:09:25
+FilePath: /genout6/media/adminmaster/veracrypt3/Develop/td-opencv/dev/base.pyi
+'''
+import typing
+from typing import overload
+
+T0=typing.TypeVar("T0")
+T1=typing.TypeVar("T1")
+T2=typing.TypeVar("T2")
+T3=typing.TypeVar("T3")
+T4=typing.TypeVar("T4")
+T5=typing.TypeVar("T5")
+T6=typing.TypeVar("T6")
+T7=typing.TypeVar("T7")
+T8=typing.TypeVar("T8")
+
+retval=typing.Any
+readyIndex=int
+
+FLANN_INDEX_TYPE_8U:int = ...
+FLANN_INDEX_TYPE_8S:int = ...
+FLANN_INDEX_TYPE_16U:int = ...
+FLANN_INDEX_TYPE_16S:int = ...
+FLANN_INDEX_TYPE_32S:int = ...
+FLANN_INDEX_TYPE_32F:int = ...
+FLANN_INDEX_TYPE_64F:int = ...
+FLANN_INDEX_TYPE_STRING:int = ...
+FLANN_INDEX_TYPE_BOOL:int = ...
+FLANN_INDEX_TYPE_ALGORITHM:int = ...
+LAST_VALUE_FLANN_INDEX_TYPE:int = ...
+class Index:
+    def save(self,filename) -> None: ...
+
+    def release(self) -> None: ...
+
+    def radiusSearch(self,query,radius,maxResults,indices:T0=...,dists:T1=...,params=...) -> retval|T0|T1: ...
+
+    def load(self,features,filename) -> retval: ...
+
+    def knnSearch(self,query,knn,indices:T0=...,dists:T1=...,params=...) -> T0|T1: ...
+
+    def getDistance(self) -> retval: ...
+
+    def getAlgorithm(self) -> retval: ...
+
+    def build(self,features,params,distType=...) -> None: ...
+
+    def __init__(self,features,params,distType=...) -> None: ...
+
+    def __init__(self) -> None: ...
+
+