opencv-contrib-python-headless 4.13.0.90__cp37-abi3-manylinux_2_28_aarch64.whl

cv2/stereo/__init__.pyi

@@ -0,0 +1,88 @@
+__all__: list[str] = []
+
+import cv2.typing
+import os
+
+
+# Enumerations
+CV_SPECKLE_REMOVAL_ALGORITHM: int
+CV_SPECKLE_REMOVAL_AVG_ALGORITHM: int
+CV_QUADRATIC_INTERPOLATION: int
+CV_SIMETRICV_INTERPOLATION: int
+CV_DENSE_CENSUS: int
+CV_SPARSE_CENSUS: int
+CV_CS_CENSUS: int
+CV_MODIFIED_CS_CENSUS: int
+CV_MODIFIED_CENSUS_TRANSFORM: int
+CV_MEAN_VARIATION: int
+CV_STAR_KERNEL: int
+
+
+StereoMatcher_DISP_SHIFT: int
+STEREO_MATCHER_DISP_SHIFT: int
+StereoMatcher_DISP_SCALE: int
+STEREO_MATCHER_DISP_SCALE: int
+
+StereoBinaryBM_PREFILTER_NORMALIZED_RESPONSE: int
+STEREO_BINARY_BM_PREFILTER_NORMALIZED_RESPONSE: int
+StereoBinaryBM_PREFILTER_XSOBEL: int
+STEREO_BINARY_BM_PREFILTER_XSOBEL: int
+
+StereoBinarySGBM_MODE_SGBM: int
+STEREO_BINARY_SGBM_MODE_SGBM: int
+StereoBinarySGBM_MODE_HH: int
+STEREO_BINARY_SGBM_MODE_HH: int
+
+
+# Classes
+class MatchQuasiDense:
+    p0: cv2.typing.Point2i
+    p1: cv2.typing.Point2i
+    corr: float
+
+    # Functions
+    def __init__(self) -> None: ...
+
+    def apply(self, rhs: MatchQuasiDense) -> bool: ...
+
+
+class PropagationParameters:
+    corrWinSizeX: int
+    corrWinSizeY: int
+    borderX: int
+    borderY: int
+    correlationThreshold: float
+    textrureThreshold: float
+    neighborhoodSize: int
+    disparityGradient: int
+    lkTemplateSize: int
+    lkPyrLvl: int
+    lkTermParam1: int
+    lkTermParam2: float
+    gftQualityThres: float
+    gftMinSeperationDist: int
+    gftMaxNumFeatures: int
+
+class QuasiDenseStereo:
+    Param: PropagationParameters
+
+    # Functions
+    def loadParameters(self, filepath: str | os.PathLike[str]) -> int: ...
+
+    def saveParameters(self, filepath: str | os.PathLike[str]) -> int: ...
+
+    def getSparseMatches(self) -> _typing.Sequence[MatchQuasiDense]: ...
+
+    def getDenseMatches(self) -> _typing.Sequence[MatchQuasiDense]: ...
+
+    def process(self, imgLeft: cv2.typing.MatLike, imgRight: cv2.typing.MatLike) -> None: ...
+
+    def getMatch(self, x: int, y: int) -> cv2.typing.Point2f: ...
+
+    def getDisparity(self) -> cv2.typing.MatLike: ...
+
+    @classmethod
+    def create(cls, monoImgSize: cv2.typing.Size, paramFilepath: str = ...) -> QuasiDenseStereo: ...
+
+
+

cv2/structured_light/__init__.pyi

@@ -0,0 +1,94 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Enumerations
+FTP: int
+PSP: int
+FAPS: int
+DECODE_3D_UNDERWORLD: int
+
+
+
+# Classes
+class GrayCodePattern(StructuredLightPattern):
+    # Functions
+    @classmethod
+    def create(cls, width: int, height: int) -> GrayCodePattern: ...
+
+    def getNumberOfPatternImages(self) -> int: ...
+
+    def setWhiteThreshold(self, value: int) -> None: ...
+
+    def setBlackThreshold(self, value: int) -> None: ...
+
+    @_typing.overload
+    def getImagesForShadowMasks(self, blackImage: cv2.typing.MatLike, whiteImage: cv2.typing.MatLike) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def getImagesForShadowMasks(self, blackImage: cv2.UMat, whiteImage: cv2.UMat) -> tuple[cv2.UMat, cv2.UMat]: ...
+
+    @_typing.overload
+    def getProjPixel(self, patternImages: _typing.Sequence[cv2.typing.MatLike], x: int, y: int) -> tuple[bool, cv2.typing.Point]: ...
+    @_typing.overload
+    def getProjPixel(self, patternImages: _typing.Sequence[cv2.UMat], x: int, y: int) -> tuple[bool, cv2.typing.Point]: ...
+
+
+class StructuredLightPattern(cv2.Algorithm):
+    # Functions
+    @_typing.overload
+    def generate(self, patternImages: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[bool, _typing.Sequence[cv2.typing.MatLike]]: ...
+    @_typing.overload
+    def generate(self, patternImages: _typing.Sequence[cv2.UMat] | None = ...) -> tuple[bool, _typing.Sequence[cv2.UMat]]: ...
+
+    @_typing.overload
+    def decode(self, patternImages: _typing.Sequence[_typing.Sequence[cv2.typing.MatLike]], disparityMap: cv2.typing.MatLike | None = ..., blackImages: _typing.Sequence[cv2.typing.MatLike] | None = ..., whiteImages: _typing.Sequence[cv2.typing.MatLike] | None = ..., flags: int = ...) -> tuple[bool, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def decode(self, patternImages: _typing.Sequence[_typing.Sequence[cv2.typing.MatLike]], disparityMap: cv2.UMat | None = ..., blackImages: _typing.Sequence[cv2.UMat] | None = ..., whiteImages: _typing.Sequence[cv2.UMat] | None = ..., flags: int = ...) -> tuple[bool, cv2.UMat]: ...
+
+
+class SinusoidalPattern(StructuredLightPattern):
+    # Classes
+    class Params:
+        width: int
+        height: int
+        nbrOfPeriods: int
+        shiftValue: float
+        methodId: int
+        nbrOfPixelsBetweenMarkers: int
+        horizontal: bool
+        setMarkers: bool
+
+        # Functions
+        def __init__(self) -> None: ...
+
+
+
+    # Functions
+    @classmethod
+    def create(cls, parameters: SinusoidalPattern.Params = ...) -> SinusoidalPattern: ...
+
+    @_typing.overload
+    def computePhaseMap(self, patternImages: _typing.Sequence[cv2.typing.MatLike], wrappedPhaseMap: cv2.typing.MatLike | None = ..., shadowMask: cv2.typing.MatLike | None = ..., fundamental: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def computePhaseMap(self, patternImages: _typing.Sequence[cv2.UMat], wrappedPhaseMap: cv2.UMat | None = ..., shadowMask: cv2.UMat | None = ..., fundamental: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
+
+    @_typing.overload
+    def unwrapPhaseMap(self, wrappedPhaseMap: cv2.typing.MatLike, camSize: cv2.typing.Size, unwrappedPhaseMap: cv2.typing.MatLike | None = ..., shadowMask: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def unwrapPhaseMap(self, wrappedPhaseMap: cv2.UMat, camSize: cv2.typing.Size, unwrappedPhaseMap: cv2.UMat | None = ..., shadowMask: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def findProCamMatches(self, projUnwrappedPhaseMap: cv2.typing.MatLike, camUnwrappedPhaseMap: cv2.typing.MatLike, matches: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> _typing.Sequence[cv2.typing.MatLike]: ...
+    @_typing.overload
+    def findProCamMatches(self, projUnwrappedPhaseMap: cv2.UMat, camUnwrappedPhaseMap: cv2.UMat, matches: _typing.Sequence[cv2.UMat] | None = ...) -> _typing.Sequence[cv2.UMat]: ...
+
+    @_typing.overload
+    def computeDataModulationTerm(self, patternImages: _typing.Sequence[cv2.typing.MatLike], shadowMask: cv2.typing.MatLike, dataModulationTerm: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def computeDataModulationTerm(self, patternImages: _typing.Sequence[cv2.UMat], shadowMask: cv2.UMat, dataModulationTerm: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+
+

cv2/text/__init__.pyi

@@ -0,0 +1,204 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import os
+import typing as _typing
+
+
+# Enumerations
+ERFILTER_NM_RGBLGrad: int
+ERFILTER_NM_RGBLGRAD: int
+ERFILTER_NM_IHSGrad: int
+ERFILTER_NM_IHSGRAD: int
+OCR_LEVEL_WORD: int
+OCR_LEVEL_TEXTLINE: int
+
+ERGROUPING_ORIENTATION_HORIZ: int
+ERGROUPING_ORIENTATION_ANY: int
+erGrouping_Modes = int
+"""One of [ERGROUPING_ORIENTATION_HORIZ, ERGROUPING_ORIENTATION_ANY]"""
+
+PSM_OSD_ONLY: int
+PSM_AUTO_OSD: int
+PSM_AUTO_ONLY: int
+PSM_AUTO: int
+PSM_SINGLE_COLUMN: int
+PSM_SINGLE_BLOCK_VERT_TEXT: int
+PSM_SINGLE_BLOCK: int
+PSM_SINGLE_LINE: int
+PSM_SINGLE_WORD: int
+PSM_CIRCLE_WORD: int
+PSM_SINGLE_CHAR: int
+page_seg_mode = int
+"""One of [PSM_OSD_ONLY, PSM_AUTO_OSD, PSM_AUTO_ONLY, PSM_AUTO, PSM_SINGLE_COLUMN, PSM_SINGLE_BLOCK_VERT_TEXT, PSM_SINGLE_BLOCK, PSM_SINGLE_LINE, PSM_SINGLE_WORD, PSM_CIRCLE_WORD, PSM_SINGLE_CHAR]"""
+
+OEM_TESSERACT_ONLY: int
+OEM_CUBE_ONLY: int
+OEM_TESSERACT_CUBE_COMBINED: int
+OEM_DEFAULT: int
+ocr_engine_mode = int
+"""One of [OEM_TESSERACT_ONLY, OEM_CUBE_ONLY, OEM_TESSERACT_CUBE_COMBINED, OEM_DEFAULT]"""
+
+OCR_DECODER_VITERBI: int
+decoder_mode = int
+"""One of [OCR_DECODER_VITERBI]"""
+
+OCR_KNN_CLASSIFIER: int
+OCR_CNN_CLASSIFIER: int
+classifier_type = int
+"""One of [OCR_KNN_CLASSIFIER, OCR_CNN_CLASSIFIER]"""
+
+
+
+# Classes
+class ERFilter(cv2.Algorithm):
+    # Classes
+    class Callback:
+        ...
+
+
+class BaseOCR:
+    ...
+
+class OCRTesseract(BaseOCR):
+    # Functions
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, mask: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, mask: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+
+    def setWhiteList(self, char_whitelist: str) -> None: ...
+
+    @classmethod
+    def create(cls, datapath: str = ..., language: str = ..., char_whitelist: str = ..., oem: int = ..., psmode: int = ...) -> OCRTesseract: ...
+
+
+class OCRHMMDecoder(BaseOCR):
+    # Classes
+    class ClassifierCallback:
+        ...
+
+
+    # Functions
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, mask: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, mask: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, classifier: OCRHMMDecoder.ClassifierCallback, vocabulary: str, transition_probabilities_table: cv2.typing.MatLike, emission_probabilities_table: cv2.typing.MatLike, mode: int = ...) -> OCRHMMDecoder: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, classifier: OCRHMMDecoder.ClassifierCallback, vocabulary: str, transition_probabilities_table: cv2.UMat, emission_probabilities_table: cv2.UMat, mode: int = ...) -> OCRHMMDecoder: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, filename: str | os.PathLike[str], vocabulary: str, transition_probabilities_table: cv2.typing.MatLike, emission_probabilities_table: cv2.typing.MatLike, mode: int = ..., classifier: int = ...) -> OCRHMMDecoder: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, filename: str | os.PathLike[str], vocabulary: str, transition_probabilities_table: cv2.UMat, emission_probabilities_table: cv2.UMat, mode: int = ..., classifier: int = ...) -> OCRHMMDecoder: ...
+
+
+class OCRBeamSearchDecoder(BaseOCR):
+    # Classes
+    class ClassifierCallback:
+        ...
+
+
+    # Functions
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.typing.MatLike, mask: cv2.typing.MatLike, min_confidence: int, component_level: int = ...) -> str: ...
+    @_typing.overload
+    def run(self, image: cv2.UMat, mask: cv2.UMat, min_confidence: int, component_level: int = ...) -> str: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, classifier: OCRBeamSearchDecoder.ClassifierCallback, vocabulary: str, transition_probabilities_table: cv2.typing.MatLike, emission_probabilities_table: cv2.typing.MatLike, mode: decoder_mode = ..., beam_size: int = ...) -> OCRBeamSearchDecoder: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, classifier: OCRBeamSearchDecoder.ClassifierCallback, vocabulary: str, transition_probabilities_table: cv2.UMat, emission_probabilities_table: cv2.UMat, mode: decoder_mode = ..., beam_size: int = ...) -> OCRBeamSearchDecoder: ...
+
+
+class TextDetector:
+    # Functions
+    @_typing.overload
+    def detect(self, inputImage: cv2.typing.MatLike) -> tuple[_typing.Sequence[cv2.typing.Rect], _typing.Sequence[float]]: ...
+    @_typing.overload
+    def detect(self, inputImage: cv2.UMat) -> tuple[_typing.Sequence[cv2.typing.Rect], _typing.Sequence[float]]: ...
+
+
+class TextDetectorCNN(TextDetector):
+    # Functions
+    @_typing.overload
+    def detect(self, inputImage: cv2.typing.MatLike) -> tuple[_typing.Sequence[cv2.typing.Rect], _typing.Sequence[float]]: ...
+    @_typing.overload
+    def detect(self, inputImage: cv2.UMat) -> tuple[_typing.Sequence[cv2.typing.Rect], _typing.Sequence[float]]: ...
+
+    @classmethod
+    def create(cls, modelArchFilename: str, modelWeightsFilename: str) -> TextDetectorCNN: ...
+
+
+
+# Functions
+@_typing.overload
+def computeNMChannels(_src: cv2.typing.MatLike, _channels: _typing.Sequence[cv2.typing.MatLike] | None = ..., _mode: int = ...) -> _typing.Sequence[cv2.typing.MatLike]: ...
+@_typing.overload
+def computeNMChannels(_src: cv2.UMat, _channels: _typing.Sequence[cv2.UMat] | None = ..., _mode: int = ...) -> _typing.Sequence[cv2.UMat]: ...
+
+@_typing.overload
+def createERFilterNM1(cb: ERFilter.Callback, thresholdDelta: int = ..., minArea: float = ..., maxArea: float = ..., minProbability: float = ..., nonMaxSuppression: bool = ..., minProbabilityDiff: float = ...) -> ERFilter: ...
+@_typing.overload
+def createERFilterNM1(filename: str | os.PathLike[str], thresholdDelta: int = ..., minArea: float = ..., maxArea: float = ..., minProbability: float = ..., nonMaxSuppression: bool = ..., minProbabilityDiff: float = ...) -> ERFilter: ...
+
+@_typing.overload
+def createERFilterNM2(cb: ERFilter.Callback, minProbability: float = ...) -> ERFilter: ...
+@_typing.overload
+def createERFilterNM2(filename: str | os.PathLike[str], minProbability: float = ...) -> ERFilter: ...
+
+def createOCRHMMTransitionsTable(vocabulary: str, lexicon: _typing.Sequence[str]) -> cv2.typing.MatLike: ...
+
+@_typing.overload
+def detectRegions(image: cv2.typing.MatLike, er_filter1: ERFilter, er_filter2: ERFilter) -> _typing.Sequence[_typing.Sequence[cv2.typing.Point]]: ...
+@_typing.overload
+def detectRegions(image: cv2.UMat, er_filter1: ERFilter, er_filter2: ERFilter) -> _typing.Sequence[_typing.Sequence[cv2.typing.Point]]: ...
+@_typing.overload
+def detectRegions(image: cv2.typing.MatLike, er_filter1: ERFilter, er_filter2: ERFilter, method: int = ..., filename: str | os.PathLike[str] = ..., minProbability: float = ...) -> _typing.Sequence[cv2.typing.Rect]: ...
+@_typing.overload
+def detectRegions(image: cv2.UMat, er_filter1: ERFilter, er_filter2: ERFilter, method: int = ..., filename: str | os.PathLike[str] = ..., minProbability: float = ...) -> _typing.Sequence[cv2.typing.Rect]: ...
+
+@_typing.overload
+def detectTextSWT(input: cv2.typing.MatLike, dark_on_light: bool, draw: cv2.typing.MatLike | None = ..., chainBBs: cv2.typing.MatLike | None = ...) -> tuple[_typing.Sequence[cv2.typing.Rect], cv2.typing.MatLike, cv2.typing.MatLike]: ...
+@_typing.overload
+def detectTextSWT(input: cv2.UMat, dark_on_light: bool, draw: cv2.UMat | None = ..., chainBBs: cv2.UMat | None = ...) -> tuple[_typing.Sequence[cv2.typing.Rect], cv2.UMat, cv2.UMat]: ...
+
+@_typing.overload
+def erGrouping(image: cv2.typing.MatLike, channel: cv2.typing.MatLike, regions: _typing.Sequence[_typing.Sequence[cv2.typing.Point]], method: int = ..., filename: str | os.PathLike[str] = ..., minProbablity: float = ...) -> _typing.Sequence[cv2.typing.Rect]: ...
+@_typing.overload
+def erGrouping(image: cv2.UMat, channel: cv2.UMat, regions: _typing.Sequence[_typing.Sequence[cv2.typing.Point]], method: int = ..., filename: str | os.PathLike[str] = ..., minProbablity: float = ...) -> _typing.Sequence[cv2.typing.Rect]: ...
+
+def loadClassifierNM1(filename: str | os.PathLike[str]) -> ERFilter.Callback: ...
+
+def loadClassifierNM2(filename: str | os.PathLike[str]) -> ERFilter.Callback: ...
+
+def loadOCRBeamSearchClassifierCNN(filename: str | os.PathLike[str]) -> OCRBeamSearchDecoder.ClassifierCallback: ...
+
+def loadOCRHMMClassifier(filename: str | os.PathLike[str], classifier: int) -> OCRHMMDecoder.ClassifierCallback: ...
+
+def loadOCRHMMClassifierCNN(filename: str | os.PathLike[str]) -> OCRHMMDecoder.ClassifierCallback: ...
+
+def loadOCRHMMClassifierNM(filename: str | os.PathLike[str]) -> OCRHMMDecoder.ClassifierCallback: ...
+
+

cv2/typing/__init__.py

@@ -0,0 +1,180 @@
+__all__ = [
+    "IntPointer",
+    "MatLike",
+    "MatShape",
+    "Size",
+    "Size2f",
+    "Scalar",
+    "Point",
+    "Point2i",
+    "Point2f",
+    "Point2d",
+    "Point3i",
+    "Point3f",
+    "Point3d",
+    "Range",
+    "Rect",
+    "Rect2i",
+    "Rect2f",
+    "Rect2d",
+    "Moments",
+    "RotatedRect",
+    "TermCriteria",
+    "Vec2i",
+    "Vec2f",
+    "Vec2d",
+    "Vec3i",
+    "Vec3f",
+    "Vec3d",
+    "Vec4i",
+    "Vec4f",
+    "Vec4d",
+    "Vec6f",
+    "FeatureDetector",
+    "DescriptorExtractor",
+    "FeatureExtractor",
+    "Matx33f",
+    "Matx33d",
+    "Matx44f",
+    "Matx44d",
+    "LayerId",
+    "LayerParams",
+    "IndexParams",
+    "SearchParams",
+    "map_string_and_string",
+    "map_string_and_int",
+    "map_string_and_vector_size_t",
+    "map_string_and_vector_float",
+    "map_int_and_double",
+    "GProtoArg",
+    "GProtoInputArgs",
+    "GProtoOutputArgs",
+    "GRunArg",
+    "GOptRunArg",
+    "GMetaArg",
+    "Prim",
+    "GTypeInfo",
+    "ExtractArgsCallback",
+    "ExtractMetaCallback",
+]
+
+import typing as _typing
+import cv2.gapi.wip.draw
+import cv2.dnn
+import cv2
+import cv2.mat_wrapper
+import numpy
+
+
+if _typing.TYPE_CHECKING:
+    NumPyArrayNumeric = numpy.ndarray[_typing.Any, numpy.dtype[numpy.integer[_typing.Any] | numpy.floating[_typing.Any]]]
+else:
+    NumPyArrayNumeric = numpy.ndarray
+
+
+if _typing.TYPE_CHECKING:
+    NumPyArrayFloat32 = numpy.ndarray[_typing.Any, numpy.dtype[numpy.float32]]
+else:
+    NumPyArrayFloat32 = numpy.ndarray
+
+
+if _typing.TYPE_CHECKING:
+    NumPyArrayFloat64 = numpy.ndarray[_typing.Any, numpy.dtype[numpy.float64]]
+else:
+    NumPyArrayFloat64 = numpy.ndarray
+
+
+if _typing.TYPE_CHECKING:
+    TermCriteria_Type = cv2.TermCriteria_Type
+else:
+    TermCriteria_Type = int
+
+
+IntPointer = int
+"""Represents an arbitrary pointer"""
+MatLike = _typing.Union[cv2.mat_wrapper.Mat, NumPyArrayNumeric]
+MatShape = _typing.Sequence[int]
+Size = _typing.Sequence[int]
+"""Required length is 2"""
+Size2f = _typing.Sequence[float]
+"""Required length is 2"""
+Scalar = _typing.Union[_typing.Sequence[float], float]
+"""Max sequence length is at most 4"""
+Point = _typing.Sequence[int]
+"""Required length is 2"""
+Point2i = Point
+Point2f = _typing.Sequence[float]
+"""Required length is 2"""
+Point2d = _typing.Sequence[float]
+"""Required length is 2"""
+Point3i = _typing.Sequence[int]
+"""Required length is 3"""
+Point3f = _typing.Sequence[float]
+"""Required length is 3"""
+Point3d = _typing.Sequence[float]
+"""Required length is 3"""
+Range = _typing.Sequence[int]
+"""Required length is 2"""
+Rect = _typing.Sequence[int]
+"""Required length is 4"""
+Rect2i = _typing.Sequence[int]
+"""Required length is 4"""
+Rect2f = _typing.Sequence[float]
+"""Required length is 4"""
+Rect2d = _typing.Sequence[float]
+"""Required length is 4"""
+Moments = _typing.Dict[str, float]
+RotatedRect = _typing.Tuple[Point2f, Size2f, float]
+"""Any type providing sequence protocol is supported"""
+TermCriteria = _typing.Tuple[TermCriteria_Type, int, float]
+"""Any type providing sequence protocol is supported"""
+Vec2i = _typing.Sequence[int]
+"""Required length is 2"""
+Vec2f = _typing.Sequence[float]
+"""Required length is 2"""
+Vec2d = _typing.Sequence[float]
+"""Required length is 2"""
+Vec3i = _typing.Sequence[int]
+"""Required length is 3"""
+Vec3f = _typing.Sequence[float]
+"""Required length is 3"""
+Vec3d = _typing.Sequence[float]
+"""Required length is 3"""
+Vec4i = _typing.Sequence[int]
+"""Required length is 4"""
+Vec4f = _typing.Sequence[float]
+"""Required length is 4"""
+Vec4d = _typing.Sequence[float]
+"""Required length is 4"""
+Vec6f = _typing.Sequence[float]
+"""Required length is 6"""
+FeatureDetector = cv2.Feature2D
+DescriptorExtractor = cv2.Feature2D
+FeatureExtractor = cv2.Feature2D
+Matx33f = NumPyArrayFloat32
+"""NDArray(shape=(3, 3), dtype=numpy.float32)"""
+Matx33d = NumPyArrayFloat64
+"""NDArray(shape=(3, 3), dtype=numpy.float64)"""
+Matx44f = NumPyArrayFloat32
+"""NDArray(shape=(4, 4), dtype=numpy.float32)"""
+Matx44d = NumPyArrayFloat64
+"""NDArray(shape=(4, 4), dtype=numpy.float64)"""
+LayerId = cv2.dnn.DictValue
+LayerParams = _typing.Dict[str, _typing.Union[int, float, str]]
+IndexParams = _typing.Dict[str, _typing.Union[bool, int, float, str]]
+SearchParams = _typing.Dict[str, _typing.Union[bool, int, float, str]]
+map_string_and_string = _typing.Dict[str, str]
+map_string_and_int = _typing.Dict[str, int]
+map_string_and_vector_size_t = _typing.Dict[str, _typing.Sequence[int]]
+map_string_and_vector_float = _typing.Dict[str, _typing.Sequence[float]]
+map_int_and_double = _typing.Dict[int, float]
+GProtoArg = _typing.Union[Scalar, cv2.GMat, cv2.GOpaqueT, cv2.GArrayT]
+GProtoInputArgs = _typing.Sequence[GProtoArg]
+GProtoOutputArgs = _typing.Sequence[GProtoArg]
+GRunArg = _typing.Union[MatLike, Scalar, cv2.GOpaqueT, cv2.GArrayT, _typing.Sequence[_typing.Any], None]
+GOptRunArg = _typing.Optional[GRunArg]
+GMetaArg = _typing.Union[cv2.GMat, Scalar, cv2.GOpaqueT, cv2.GArrayT]
+Prim = _typing.Union[cv2.gapi.wip.draw.Text, cv2.gapi.wip.draw.Circle, cv2.gapi.wip.draw.Image, cv2.gapi.wip.draw.Line, cv2.gapi.wip.draw.Rect, cv2.gapi.wip.draw.Mosaic, cv2.gapi.wip.draw.Poly]
+GTypeInfo = _typing.Union[cv2.GMat, Scalar, cv2.GOpaqueT, cv2.GArrayT]
+ExtractArgsCallback = _typing.Callable[[_typing.Sequence[GTypeInfo]], _typing.Sequence[GRunArg]]
+ExtractMetaCallback = _typing.Callable[[_typing.Sequence[GTypeInfo]], _typing.Sequence[GMetaArg]]

cv2/utils/__init__.py

@@ -0,0 +1,14 @@
+from collections import namedtuple
+
+import cv2
+
+
+NativeMethodPatchedResult = namedtuple("NativeMethodPatchedResult",
+                                       ("py", "native"))
+
+
+def testOverwriteNativeMethod(arg):
+    return NativeMethodPatchedResult(
+        arg + 1,
+        cv2.utils._native.testOverwriteNativeMethod(arg)
+    )

cv2/utils/__init__.pyi

@@ -0,0 +1,110 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+from cv2.utils import fs as fs
+from cv2.utils import logging as logging
+from cv2.utils import nested as nested
+
+
+# Classes
+class ClassWithKeywordProperties:
+    lambda_: int
+    @property
+    def except_(self) -> int: ...
+
+    # Functions
+    def __init__(self, lambda_arg: int = ..., except_arg: int = ...) -> None: ...
+
+
+
+# Functions
+@_typing.overload
+def copyMatAndDumpNamedArguments(src: cv2.typing.MatLike, dst: cv2.typing.MatLike | None = ..., lambda_: int = ..., sigma: float = ...) -> tuple[str, cv2.typing.MatLike]: ...
+@_typing.overload
+def copyMatAndDumpNamedArguments(src: cv2.UMat, dst: cv2.UMat | None = ..., lambda_: int = ..., sigma: float = ...) -> tuple[str, cv2.UMat]: ...
+
+def dumpBool(argument: bool) -> str: ...
+
+def dumpCString(argument: str) -> str: ...
+
+def dumpDouble(argument: float) -> str: ...
+
+def dumpFloat(argument: float) -> str: ...
+
+@_typing.overload
+def dumpInputArray(argument: cv2.typing.MatLike) -> str: ...
+@_typing.overload
+def dumpInputArray(argument: cv2.UMat) -> str: ...
+
+@_typing.overload
+def dumpInputArrayOfArrays(argument: _typing.Sequence[cv2.typing.MatLike]) -> str: ...
+@_typing.overload
+def dumpInputArrayOfArrays(argument: _typing.Sequence[cv2.UMat]) -> str: ...
+
+@_typing.overload
+def dumpInputOutputArray(argument: cv2.typing.MatLike) -> tuple[str, cv2.typing.MatLike]: ...
+@_typing.overload
+def dumpInputOutputArray(argument: cv2.UMat) -> tuple[str, cv2.UMat]: ...
+
+@_typing.overload
+def dumpInputOutputArrayOfArrays(argument: _typing.Sequence[cv2.typing.MatLike]) -> tuple[str, _typing.Sequence[cv2.typing.MatLike]]: ...
+@_typing.overload
+def dumpInputOutputArrayOfArrays(argument: _typing.Sequence[cv2.UMat]) -> tuple[str, _typing.Sequence[cv2.UMat]]: ...
+
+def dumpInt(argument: int) -> str: ...
+
+def dumpInt64(argument: int) -> str: ...
+
+def dumpRange(argument: cv2.typing.Range) -> str: ...
+
+def dumpRect(argument: cv2.typing.Rect) -> str: ...
+
+def dumpRotatedRect(argument: cv2.typing.RotatedRect) -> str: ...
+
+def dumpSizeT(argument: int) -> str: ...
+
+def dumpString(argument: str) -> str: ...
+
+def dumpTermCriteria(argument: cv2.typing.TermCriteria) -> str: ...
+
+def dumpVec2i(value: cv2.typing.Vec2i = ...) -> str: ...
+
+def dumpVectorOfDouble(vec: _typing.Sequence[float]) -> str: ...
+
+def dumpVectorOfInt(vec: _typing.Sequence[int]) -> str: ...
+
+def dumpVectorOfRect(vec: _typing.Sequence[cv2.typing.Rect]) -> str: ...
+
+def generateVectorOfInt(len: int) -> _typing.Sequence[int]: ...
+
+def generateVectorOfMat(len: int, rows: int, cols: int, dtype: int, vec: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> _typing.Sequence[cv2.typing.MatLike]: ...
+
+def generateVectorOfRect(len: int) -> _typing.Sequence[cv2.typing.Rect]: ...
+
+@_typing.overload
+def testAsyncArray(argument: cv2.typing.MatLike) -> cv2.AsyncArray: ...
+@_typing.overload
+def testAsyncArray(argument: cv2.UMat) -> cv2.AsyncArray: ...
+
+def testAsyncException() -> cv2.AsyncArray: ...
+
+@_typing.overload
+def testOverloadResolution(value: int, point: cv2.typing.Point = ...) -> str: ...
+@_typing.overload
+def testOverloadResolution(rect: cv2.typing.Rect) -> str: ...
+
+def testOverwriteNativeMethod(argument: int) -> int: ...
+
+def testRaiseGeneralException() -> None: ...
+
+def testReservedKeywordConversion(positional_argument: int, lambda_: int = ..., from_: int = ...) -> str: ...
+
+def testRotatedRect(x: float, y: float, w: float, h: float, angle: float) -> cv2.typing.RotatedRect: ...
+
+def testRotatedRectVector(x: float, y: float, w: float, h: float, angle: float) -> _typing.Sequence[cv2.typing.RotatedRect]: ...
+
+