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

cv2/aruco.pyi

@@ -0,0 +1,627 @@
+'''
+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
+
+CORNER_REFINE_NONE:int = ...
+CORNER_REFINE_SUBPIX:int = ...
+CORNER_REFINE_CONTOUR:int = ...
+CORNER_REFINE_APRILTAG:int = ...
+DICT_4X4_50:int = ...
+DICT_4X4_100:int = ...
+DICT_4X4_250:int = ...
+DICT_4X4_1000:int = ...
+DICT_5X5_50:int = ...
+DICT_5X5_100:int = ...
+DICT_5X5_250:int = ...
+DICT_5X5_1000:int = ...
+DICT_6X6_50:int = ...
+DICT_6X6_100:int = ...
+DICT_6X6_250:int = ...
+DICT_6X6_1000:int = ...
+DICT_7X7_50:int = ...
+DICT_7X7_100:int = ...
+DICT_7X7_250:int = ...
+DICT_7X7_1000:int = ...
+DICT_ARUCO_ORIGINAL:int = ...
+DICT_APRILTAG_16h5:int = ...
+DICT_APRILTAG_25h9:int = ...
+DICT_APRILTAG_36h10:int = ...
+DICT_APRILTAG_36h11:int = ...
+DICT_ARUCO_MIP_36h12:int = ...
+class Board:
+    def matchImagePoints(self,detectedCorners,detectedIds,objPoints:T0=...,imgPoints:T0=...) -> T0|T0:
+        """
+        ```
+        Given a board configuration and a set of detected markers, returns the corresponding image points and object points, can be used in solvePnP(). 
+        ```
+        ---
+        ```
+        Parameters:
+        detectedCorners:            List of detected marker corners of the board. For cv::Board and cv::GridBoard the method expects std::vector<std::vector<Point2f>> or std::vector<Mat> with Aruco marker corners. For cv::CharucoBoard the method expects std::vector<Point2f> or Mat with ChAruco corners (chess board corners matched with Aruco markers).
+        detectedIds:                List of identifiers for each marker or charuco corner. For any Board class the method expects std::vector<int> or Mat.
+        objPoints:                  Vector of marker points in the board coordinate space. For any Board class the method expects std::vector<cv::Point3f> objectPoints or cv::Mat
+        imgPoints:                  Vector of marker points in the image coordinate space. For any Board class the method expects std::vector<cv::Point2f> objectPoints or cv::Mat
+        ```
+        """
+
+    def getRightBottomCorner(self) -> retval: ...
+
+    def getObjPoints(self) -> retval: ...
+
+    def getIds(self) -> retval: ...
+
+    def getDictionary(self) -> retval: ...
+
+    def generateImage(self,outSize,img:T0=...,marginSize:int=...,borderBits:int=...) -> T0:
+        """
+        ```
+        Draw a planar board. 
+        ```
+        ---
+        ```
+        Parameters:
+        outSize:                    size of the output image in pixels. 
+        img:                        output image with the board. The size of this image will be outSize and the board will be on the center, keeping the board proportions. 
+        marginSize:                 minimum margins (in pixels) of the board in the output image 
+        borderBits:                 width of the marker borders.
+        ```
+        """
+
+    @overload
+    def __init__(self,objPoints,dictionary,ids) -> None:
+        """
+        ```
+        Common Board constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        objPoints:                  array of object points of all the marker corners in the board 
+        dictionary:                 the dictionary of markers employed for this board 
+        ids:                        vector of the identifiers of the markers in the board 
+        ```
+        """
+
+class GridBoard(Board):
+    def getMarkerSeparation(self) -> retval: ...
+
+    def getMarkerLength(self) -> retval: ...
+
+    def getGridSize(self) -> retval: ...
+
+    @overload
+    def __init__(self,size,markerLength:float,markerSeparation:float,dictionary,ids=...) -> None:
+        """
+        ```
+        GridBoard constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        size:                       number of markers in x and y directions 
+        markerLength:               marker side length (normally in meters) 
+        markerSeparation:           separation between two markers (same unit as markerLength) 
+        dictionary:                 dictionary of markers indicating the type of markers 
+        ids:                        set of marker ids in dictionary to use on board. 
+        ```
+        """
+
+class CharucoBoard(Board):
+    def setLegacyPattern(self,legacyPattern:bool) -> None:
+        """
+        ```
+        set legacy chessboard pattern. 
+        ```
+        """
+
+    def getSquareLength(self) -> retval: ...
+
+    def getMarkerLength(self) -> retval: ...
+
+    def getLegacyPattern(self) -> retval: ...
+
+    def getChessboardSize(self) -> retval: ...
+
+    def getChessboardCorners(self) -> retval: ...
+
+    def checkCharucoCornersCollinear(self,charucoIds) -> retval:
+        """
+        ```
+        check whether the ChArUco markers are collinear 
+        ```
+        ---
+        ```
+        Parameters:
+        charucoIds:                 list of identifiers for each corner in charucoCorners per frame. 
+        ```
+        """
+
+    @overload
+    def __init__(self,size,squareLength:float,markerLength:float,dictionary,ids=...) -> None:
+        """
+        ```
+        CharucoBoard constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        size:                       number of chessboard squares in x and y directions 
+        squareLength:               squareLength chessboard square side length (normally in meters) 
+        markerLength:               marker side length (same unit than squareLength) 
+        dictionary:                 dictionary of markers indicating the type of markers 
+        ids:                        array of id used markers The first markers in the dictionary are used to fill the white chessboard squares. 
+        ```
+        """
+
+class DetectorParameters:
+    def writeDetectorParameters(self,fs,name:str=...) -> retval:
+        """
+        ```
+        Write a set of DetectorParameters to FileStorage. 
+        ```
+        """
+
+    def readDetectorParameters(self,fn) -> retval:
+        """
+        ```
+        Read a new set of DetectorParameters from FileNode (use FileStorage.root()). 
+        ```
+        """
+
+    def __init__(self) -> None: ...
+
+class RefineParameters:
+    def writeRefineParameters(self,fs,name:str=...) -> retval:
+        """
+        ```
+        Write a set of RefineParameters to FileStorage. 
+        ```
+        """
+
+    def readRefineParameters(self,fn) -> retval:
+        """
+        ```
+        Read a new set of RefineParameters from FileNode (use FileStorage.root()). 
+        ```
+        """
+
+    @overload
+    def __init__(self,minRepDistance:float=...,errorCorrectionRate:float=...,checkAllOrders:bool=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class ArucoDetector(Algorithm):
+    def write(self,fs,name:str) -> None:
+        """
+        ```
+        simplified API for language bindings 
+        ```
+        """
+
+    def setRefineParameters(self,refineParameters) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setDictionary(self,dictionary) -> None:
+        """
+        ```
+        Sets and replaces the first dictionary in internal list to be used for marker detection. 
+        ```
+        ---
+        ```
+        Parameters:
+        dictionary:                 The new dictionary that will replace the first dictionary in the internal list. 
+        ```
+        """
+
+    def setDictionaries(self,dictionaries) -> None:
+        """
+        ```
+        Sets the entire collection of dictionaries to be used for marker detection, replacing any existing dictionaries. 
+        ```
+        ---
+        ```
+        Parameters:
+        dictionaries:               A std::vector<Dictionary> containing the new set of dictionaries to be used.
+        ```
+        """
+
+    def setDetectorParameters(self,detectorParameters) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def refineDetectedMarkers(self,image,board,detectedCorners:T0,detectedIds:T0,rejectedCorners:T0,cameraMatrix=...,distCoeffs=...,recoveredIdxs:T0=...) -> T0|T0|T0|T0:
+        """
+        ```
+        Refine not detected markers based on the already detected and the board layout. 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image 
+        board:                      layout of markers in the board. 
+        detectedCorners:            vector of already detected marker corners. 
+        detectedIds:                vector of already detected marker identifiers. 
+        rejectedCorners:            vector of rejected candidates during the marker detection process. 
+        cameraMatrix:               optional input 3x3 floating-point camera matrix $A = \vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}$ 
+        distCoeffs:                 optional vector of distortion coefficients $(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 
+        recoveredIdxs:              Optional array to returns the indexes of the recovered candidates in the original rejectedCorners array.
+        ```
+        """
+
+    def read(self,fn) -> None:
+        """
+        ```
+        Reads algorithm parameters from a file storage. 
+        ```
+        """
+
+    def getRefineParameters(self) -> retval: ...
+
+    def getDictionary(self) -> retval: ...
+
+    def getDictionaries(self) -> retval: ...
+
+    def getDetectorParameters(self) -> retval: ...
+
+    def detectMarkersWithConfidence(self,image,corners:T0=...,ids:T0=...,markersConfidence:T0=...,rejectedImgPoints:T0=...) -> T0|T0|T0|T0:
+        """
+        ```
+        Marker detection with confidence computation. 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image 
+        corners:                    vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array is Nx4. The order of the corners is clockwise. 
+        ids:                        vector of identifiers of the detected markers. The identifier is of type int (e.g. std::vector<int>). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array. 
+        markersConfidence:          contains the normalized confidence [0;1] of the markers' detection, defined as 1 minus the normalized uncertainty (percentage of incorrect pixel detections), with 1 describing a pixel perfect detection. The confidence values are of type float (e.g. std::vector<float>) 
+        rejectedImgPoints:          contains the imgPoints of those squares whose inner code has not a correct codification. Useful for debugging purposes.
+        ```
+        """
+
+    def detectMarkersMultiDict(self,image,corners:T0=...,ids:T0=...,rejectedImgPoints:T0=...,dictIndices:T0=...) -> T0|T0|T0|T0:
+        """
+        ```
+        Basic marker detection. 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image 
+        corners:                    vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array is Nx4. The order of the corners is clockwise. 
+        ids:                        vector of identifiers of the detected markers. The identifier is of type int (e.g. std::vector<int>). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array. 
+        rejectedImgPoints:          contains the imgPoints of those squares whose inner code has not a correct codification. Useful for debugging purposes. 
+        dictIndices:                vector of dictionary indices for each detected marker. Use getDictionaries() to get the list of corresponding dictionaries.
+        ```
+        """
+
+    def detectMarkers(self,image,corners:T0=...,ids:T0=...,rejectedImgPoints:T0=...) -> T0|T0|T0:
+        """
+        ```
+        Basic marker detection. 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image 
+        corners:                    vector of detected marker corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array is Nx4. The order of the corners is clockwise. 
+        ids:                        vector of identifiers of the detected markers. The identifier is of type int (e.g. std::vector<int>). For N detected markers, the size of ids is also N. The identifiers have the same order than the markers in the imgPoints array. 
+        rejectedImgPoints:          contains the imgPoints of those squares whose inner code has not a correct codification. Useful for debugging purposes.
+        ```
+        """
+
+    @overload
+    def __init__(self,dictionaries,detectorParams=...,refineParams=...) -> None:
+        """
+        ```
+        ArucoDetector constructor for multiple dictionaries. 
+        ```
+        ---
+        ```
+        Parameters:
+        dictionaries:               indicates the type of markers that will be searched. Empty dictionaries will throw an error. 
+        detectorParams:             marker detection parameters 
+        refineParams:               marker refine detection parameters 
+        ```
+        """
+
+    @overload
+    def __init__(self,dictionary=...,detectorParams=...,refineParams=...) -> None:
+        """
+        ```
+        Basic ArucoDetector constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        dictionary:                 indicates the type of markers that will be searched 
+        detectorParams:             marker detection parameters 
+        refineParams:               marker refine detection parameters 
+        ```
+        """
+
+class Dictionary:
+    def writeDictionary(self,fs,name:str=...) -> None:
+        """
+        ```
+        Write a dictionary to FileStorage, format is the same as in readDictionary(). 
+        ```
+        """
+
+    def readDictionary(self,fn) -> retval:
+        """
+        ```
+        Read a new dictionary from FileNode. 
+        ```
+        """
+
+    def identify(self,onlyBits,maxCorrectionRate) -> retval|idx|rotation: ...
+
+    def getDistanceToId(self,bits,id:int,allRotations:bool=...) -> retval:
+        """
+        ```
+        Returns Hamming distance of the input bits to the specific id. 
+        ```
+        """
+
+    @staticmethod
+    def getByteListFromBits(bits) -> retval:
+        """
+        ```
+        Transform matrix of bits to list of bytes with 4 marker rotations. 
+        ```
+        """
+
+    @staticmethod
+    def getBitsFromByteList(byteList,markerSize:int,rotationId:int=...) -> retval:
+        """
+        ```
+        Transform list of bytes to matrix of bits. 
+        ```
+        """
+
+    def generateImageMarker(self,id:int,sidePixels:int,_img:T0=...,borderBits:int=...) -> T0:
+        """
+        ```
+        Generate a canonical marker image. 
+        ```
+        """
+
+    @overload
+    def __init__(self,bytesList,_markerSize:int,maxcorr:int=...) -> None:
+        """
+        ```
+        Basic ArUco dictionary constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        _markerSize:                ArUco marker size in units 
+        maxcorr:                    maximum number of bits that can be corrected 
+        ```
+        """
+
+    def __init__(self) -> None: ...
+
+class CharucoParameters:
+    def __init__(self) -> None: ...
+
+class CharucoDetector(Algorithm):
+    def setRefineParameters(self,refineParameters) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setDetectorParameters(self,detectorParameters) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setCharucoParameters(self,charucoParameters) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setBoard(self,board) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getRefineParameters(self) -> retval: ...
+
+    def getDetectorParameters(self) -> retval: ...
+
+    def getCharucoParameters(self) -> retval: ...
+
+    def getBoard(self) -> retval: ...
+
+    def detectDiamonds(self,image,diamondCorners:T0=...,diamondIds:T0=...,markerCorners:T0=...,markerIds:T0=...) -> T0|T0|T0|T0:
+        """
+        ```
+        Detect ChArUco Diamond markers. 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image necessary for corner subpixel. 
+        diamondCorners:             output list of detected diamond corners (4 corners per diamond). The order is the same than in marker corners: top left, top right, bottom right and bottom left. Similar format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ). 
+        diamondIds:                 ids of the diamonds in diamondCorners. The id of each diamond is in fact of type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the diamond. 
+        markerCorners:              list of detected marker corners from detectMarkers function. If markerCorners and markerCorners are empty, the function detect aruco markers and ids. 
+        markerIds:                  list of marker ids in markerCorners. If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+        ```
+        """
+
+    def detectBoard(self,image,charucoCorners:T0=...,charucoIds:T0=...,markerCorners:T0=...,markerIds:T0=...) -> T0|T0|T0|T0:
+        """
+        ```
+        detect aruco markers and interpolate position of ChArUco board corners 
+        ```
+        ---
+        ```
+        Parameters:
+        image:                      input image necessary for corner refinement. Note that markers are not detected and should be sent in corners and ids parameters. 
+        charucoCorners:             interpolated chessboard corners. 
+        charucoIds:                 interpolated chessboard corners identifiers. 
+        markerCorners:              vector of already detected markers corners. For each marker, its four corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise. If markerCorners and markerCorners are empty, the function detect aruco markers and ids. 
+        markerIds:                  list of identifiers for each marker in corners. If markerCorners and markerCorners are empty, the function detect aruco markers and ids.
+        ```
+        """
+
+    @overload
+    def __init__(self,board,charucoParams=...,detectorParams=...,refineParams=...) -> None:
+        """
+        ```
+        Basic CharucoDetector constructor. 
+        ```
+        ---
+        ```
+        Parameters:
+        board:                      ChAruco board 
+        charucoParams:              charuco detection parameters 
+        detectorParams:             marker detection parameters 
+        refineParams:               marker refine detection parameters 
+        ```
+        """
+
+@staticmethod
+def Dictionary_getBitsFromByteList(byteList,markerSize:int,rotationId:int=...) -> retval:
+    """
+    ```
+    Transform list of bytes to matrix of bits. 
+    ```
+    """
+
+@staticmethod
+def Dictionary_getByteListFromBits(bits) -> retval:
+    """
+    ```
+    Transform matrix of bits to list of bytes with 4 marker rotations. 
+    ```
+    """
+
+def drawDetectedCornersCharuco(image:T0,charucoCorners,charucoIds=...,cornerColor=...) -> T0:
+    """
+    ```
+    Draws a set of Charuco corners. 
+    ```
+    ---
+    ```
+    Parameters:
+    image:                      input/output image. It must have 1 or 3 channels. The number of channels is not altered. 
+    charucoCorners:             vector of detected charuco corners 
+    charucoIds:                 list of identifiers for each corner in charucoCorners 
+    cornerColor:                color of the square surrounding each corner
+    ```
+    """
+
+def drawDetectedDiamonds(image:T0,diamondCorners,diamondIds=...,borderColor=...) -> T0:
+    """
+    ```
+    Draw a set of detected ChArUco Diamond markers. 
+    ```
+    ---
+    ```
+    Parameters:
+    image:                      input/output image. It must have 1 or 3 channels. The number of channels is not altered. 
+    diamondCorners:             positions of diamond corners in the same format returned by detectCharucoDiamond(). (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise. 
+    diamondIds:                 vector of identifiers for diamonds in diamondCorners, in the same format returned by detectCharucoDiamond() (e.g. std::vector<Vec4i>). Optional, if not provided, ids are not painted. 
+    borderColor:                color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one.
+    ```
+    """
+
+def drawDetectedMarkers(image:T0,corners,ids=...,borderColor=...) -> T0:
+    """
+    ```
+    Draw detected markers in image. 
+    ```
+    ---
+    ```
+    Parameters:
+    image:                      input/output image. It must have 1 or 3 channels. The number of channels is not altered. 
+    corners:                    positions of marker corners on input image. (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the dimensions of this array should be Nx4. The order of the corners should be clockwise. 
+    ids:                        vector of identifiers for markers in markersCorners . Optional, if not provided, ids are not painted. 
+    borderColor:                color of marker borders. Rest of colors (text color and first corner color) are calculated based on this one to improve visualization.
+    ```
+    """
+
+def extendDictionary(nMarkers:int,markerSize:int,baseDictionary=...,randomSeed:int=...) -> retval:
+    """
+    ```
+    Extend base dictionary by new nMarkers. 
+    ```
+    ---
+    ```
+    Parameters:
+    nMarkers:                   number of markers in the dictionary 
+    markerSize:                 number of bits per dimension of each markers 
+    baseDictionary:             Include the markers in this dictionary at the beginning (optional) 
+    randomSeed:                 a user supplied seed for theRNG()
+    ```
+    """
+
+def generateImageMarker(dictionary,id:int,sidePixels:int,img:T0=...,borderBits:int=...) -> T0:
+    """
+    ```
+    Generate a canonical marker image. 
+    ```
+    ---
+    ```
+    Parameters:
+    dictionary:                 dictionary of markers indicating the type of markers 
+    id:                         identifier of the marker that will be returned. It has to be a valid id in the specified dictionary. 
+    sidePixels:                 size of the image in pixels 
+    img:                        output image with the marker 
+    borderBits:                 width of the marker border.
+    ```
+    """
+
+def getPredefinedDictionary(dict:int) -> retval:
+    """
+    ```
+    Returns one of the predefined dictionaries referenced by DICT_*. 
+    ```
+    """
+
+
+from . import Algorithm
+
+
+idx=typing.Any
+Algorithm=typing.Any
+rotation=typing.Any