opencv-python-headless 4.11.0.86__cp37-abi3-win32.whl → 4.13.0.90__cp37-abi3-win32.whl

cv2/aruco/__init__.pyi

@@ -170,22 +170,39 @@ class RefineParameters:
 
 class ArucoDetector(cv2.Algorithm):
     # Functions
+    @_typing.overload
     def __init__(self, dictionary: Dictionary = ..., detectorParams: DetectorParameters = ..., refineParams: RefineParameters = ...) -> None: ...
+    @_typing.overload
+    def __init__(self, dictionaries: _typing.Sequence[Dictionary], detectorParams: DetectorParameters = ..., refineParams: RefineParameters = ...) -> None: ...
 
     @_typing.overload
     def detectMarkers(self, image: cv2.typing.MatLike, corners: _typing.Sequence[cv2.typing.MatLike] | None = ..., ids: cv2.typing.MatLike | None = ..., rejectedImgPoints: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike]]: ...
     @_typing.overload
     def detectMarkers(self, image: cv2.UMat, corners: _typing.Sequence[cv2.UMat] | None = ..., ids: cv2.UMat | None = ..., rejectedImgPoints: _typing.Sequence[cv2.UMat] | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat]]: ...
 
+    @_typing.overload
+    def detectMarkersWithConfidence(self, image: cv2.typing.MatLike, corners: _typing.Sequence[cv2.typing.MatLike] | None = ..., ids: cv2.typing.MatLike | None = ..., markersConfidence: cv2.typing.MatLike | None = ..., rejectedImgPoints: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike]]: ...
+    @_typing.overload
+    def detectMarkersWithConfidence(self, image: cv2.UMat, corners: _typing.Sequence[cv2.UMat] | None = ..., ids: cv2.UMat | None = ..., markersConfidence: cv2.UMat | None = ..., rejectedImgPoints: _typing.Sequence[cv2.UMat] | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, cv2.UMat, _typing.Sequence[cv2.UMat]]: ...
+
     @_typing.overload
     def refineDetectedMarkers(self, image: cv2.typing.MatLike, board: Board, detectedCorners: _typing.Sequence[cv2.typing.MatLike], detectedIds: cv2.typing.MatLike, rejectedCorners: _typing.Sequence[cv2.typing.MatLike], cameraMatrix: cv2.typing.MatLike | None = ..., distCoeffs: cv2.typing.MatLike | None = ..., recoveredIdxs: cv2.typing.MatLike | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike]: ...
     @_typing.overload
     def refineDetectedMarkers(self, image: cv2.UMat, board: Board, detectedCorners: _typing.Sequence[cv2.UMat], detectedIds: cv2.UMat, rejectedCorners: _typing.Sequence[cv2.UMat], cameraMatrix: cv2.UMat | None = ..., distCoeffs: cv2.UMat | None = ..., recoveredIdxs: cv2.UMat | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat], cv2.UMat]: ...
 
+    @_typing.overload
+    def detectMarkersMultiDict(self, image: cv2.typing.MatLike, corners: _typing.Sequence[cv2.typing.MatLike] | None = ..., ids: cv2.typing.MatLike | None = ..., rejectedImgPoints: _typing.Sequence[cv2.typing.MatLike] | None = ..., dictIndices: cv2.typing.MatLike | None = ...) -> tuple[_typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], cv2.typing.MatLike]: ...
+    @_typing.overload
+    def detectMarkersMultiDict(self, image: cv2.UMat, corners: _typing.Sequence[cv2.UMat] | None = ..., ids: cv2.UMat | None = ..., rejectedImgPoints: _typing.Sequence[cv2.UMat] | None = ..., dictIndices: cv2.UMat | None = ...) -> tuple[_typing.Sequence[cv2.UMat], cv2.UMat, _typing.Sequence[cv2.UMat], cv2.UMat]: ...
+
     def getDictionary(self) -> Dictionary: ...
 
     def setDictionary(self, dictionary: Dictionary) -> None: ...
 
+    def getDictionaries(self) -> _typing.Sequence[Dictionary]: ...
+
+    def setDictionaries(self, dictionaries: _typing.Sequence[Dictionary]) -> None: ...
+
     def getDetectorParameters(self) -> DetectorParameters: ...
 
     def setDetectorParameters(self, detectorParameters: DetectorParameters) -> None: ...
@@ -230,7 +247,7 @@ class Dictionary:
     def getByteListFromBits(bits: cv2.typing.MatLike) -> cv2.typing.MatLike: ...
 
     @staticmethod
-    def getBitsFromByteList(byteList: cv2.typing.MatLike, markerSize: int) -> cv2.typing.MatLike: ...
+    def getBitsFromByteList(byteList: cv2.typing.MatLike, markerSize: int, rotationId: int = ...) -> cv2.typing.MatLike: ...
 
 
 class CharucoParameters:
@@ -238,6 +255,7 @@ class CharucoParameters:
     distCoeffs: cv2.typing.MatLike
     minMarkers: int
     tryRefineMarkers: bool
+    checkMarkers: bool
 
     # Functions
     def __init__(self) -> None: ...

cv2/barcode/__init__.pyi

@@ -2,6 +2,7 @@ __all__: list[str] = []
 
 import cv2
 import cv2.typing
+import os
 import typing as _typing
 
 
@@ -11,7 +12,7 @@ class BarcodeDetector(cv2.GraphicalCodeDetector):
     @_typing.overload
     def __init__(self) -> None: ...
     @_typing.overload
-    def __init__(self, prototxt_path: str, model_path: str) -> None: ...
+    def __init__(self, prototxt_path: str | os.PathLike[str], model_path: str | os.PathLike[str]) -> None: ...
 
     @_typing.overload
     def decodeWithType(self, img: cv2.typing.MatLike, points: cv2.typing.MatLike) -> tuple[bool, _typing.Sequence[str], _typing.Sequence[str]]: ...

cv2/config.py

@@ -1,5 +1,5 @@
 import os
 
 BINARIES_PATHS = [
-    os.path.join(os.path.join(LOADER_DIR, '../../'), 'x86/vc14/bin')
+    os.path.join(os.path.join(LOADER_DIR, '../../'), 'x86/vc17/bin')
 ] + BINARIES_PATHS

cv2/cuda/__init__.pyi

@@ -163,6 +163,8 @@ class GpuMat:
     @_typing.overload
     def setTo(self, s: cv2.typing.Scalar, mask: cv2.UMat, stream: Stream) -> GpuMat: ...
 
+    @_typing.overload
+    def convertTo(self, rtype: int, dst: GpuMat | None = ...) -> GpuMat: ...
     @_typing.overload
     def convertTo(self, rtype: int, stream: Stream, dst: GpuMat | None = ...) -> GpuMat: ...
     @_typing.overload

cv2/dnn/__init__.pyi

@@ -3,6 +3,7 @@ __all__: list[str] = []
 import cv2
 import cv2.typing
 import numpy
+import os
 import sys
 import typing as _typing
 if sys.version_info >= (3, 8):
@@ -112,7 +113,7 @@ class Net:
 
     @classmethod
     @_typing.overload
-    def readFromModelOptimizer(cls, xml: str, bin: str) -> Net: ...
+    def readFromModelOptimizer(cls, xml: str | os.PathLike[str], bin: str | os.PathLike[str]) -> Net: ...
     @classmethod
     @_typing.overload
     def readFromModelOptimizer(cls, bufferModelConfig: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferWeights: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]]) -> Net: ...
@@ -121,9 +122,9 @@ class Net:
 
     def dump(self) -> str: ...
 
-    def dumpToFile(self, path: str) -> None: ...
+    def dumpToFile(self, path: str | os.PathLike[str]) -> None: ...
 
-    def dumpToPbtxt(self, path: str) -> None: ...
+    def dumpToPbtxt(self, path: str | os.PathLike[str]) -> None: ...
 
     def addLayer(self, name: str, type: str, dtype: int, params: cv2.typing.LayerParams) -> int: ...
 
@@ -142,6 +143,8 @@ class Net:
 
     def connect(self, outPin: str, inpPin: str) -> None: ...
 
+    def registerOutput(self, outputName: str, layerId: int, outputPort: int) -> int: ...
+
     def setInputsNames(self, inputBlobNames: _typing.Sequence[str]) -> None: ...
 
     def setInputShape(self, inputName: str, shape: cv2.typing.MatShape) -> None: ...
@@ -251,7 +254,7 @@ class Image2BlobParams:
 class Model:
     # Functions
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
 
@@ -287,7 +290,7 @@ class Model:
 class ClassificationModel(Model):
     # Functions
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
 
@@ -304,7 +307,7 @@ class ClassificationModel(Model):
 class KeypointsModel(Model):
     # Functions
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
 
@@ -317,7 +320,7 @@ class KeypointsModel(Model):
 class SegmentationModel(Model):
     # Functions
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
 
@@ -330,7 +333,7 @@ class SegmentationModel(Model):
 class DetectionModel(Model):
     # Functions
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
 
@@ -349,7 +352,7 @@ class TextRecognitionModel(Model):
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
 
     def setDecodeType(self, decodeType: str) -> TextRecognitionModel: ...
 
@@ -397,7 +400,7 @@ class TextDetectionModel_EAST(TextDetectionModel):
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
 
     def setConfidenceThreshold(self, confThreshold: float) -> TextDetectionModel_EAST: ...
 
@@ -413,7 +416,7 @@ class TextDetectionModel_DB(TextDetectionModel):
     @_typing.overload
     def __init__(self, network: Net) -> None: ...
     @_typing.overload
-    def __init__(self, model: str, config: str = ...) -> None: ...
+    def __init__(self, model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> None: ...
 
     def setBinaryThreshold(self, binaryThreshold: float) -> TextDetectionModel_DB: ...
 
@@ -479,56 +482,68 @@ def blobFromImagesWithParams(images: _typing.Sequence[cv2.UMat], blob: cv2.UMat
 
 def getAvailableTargets(be: Backend) -> _typing.Sequence[Target]: ...
 
+def getInferenceEngineBackendType() -> str: ...
+
+def getInferenceEngineCPUType() -> str: ...
+
+def getInferenceEngineVPUType() -> str: ...
+
 @_typing.overload
 def imagesFromBlob(blob_: cv2.typing.MatLike, images_: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> _typing.Sequence[cv2.typing.MatLike]: ...
 @_typing.overload
 def imagesFromBlob(blob_: cv2.typing.MatLike, images_: _typing.Sequence[cv2.UMat] | None = ...) -> _typing.Sequence[cv2.UMat]: ...
 
 @_typing.overload
-def readNet(model: str, config: str = ..., framework: str = ...) -> Net: ...
+def readNet(model: str | os.PathLike[str], config: str | os.PathLike[str] = ..., framework: str = ...) -> Net: ...
 @_typing.overload
 def readNet(framework: str, bufferModel: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferConfig: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]] = ...) -> Net: ...
 
 @_typing.overload
-def readNetFromCaffe(prototxt: str, caffeModel: str = ...) -> Net: ...
+def readNetFromCaffe(prototxt: str | os.PathLike[str], caffeModel: str | os.PathLike[str] = ...) -> Net: ...
 @_typing.overload
 def readNetFromCaffe(bufferProto: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferModel: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]] = ...) -> Net: ...
 
 @_typing.overload
-def readNetFromDarknet(cfgFile: str, darknetModel: str = ...) -> Net: ...
+def readNetFromDarknet(cfgFile: str | os.PathLike[str], darknetModel: str | os.PathLike[str] = ...) -> Net: ...
 @_typing.overload
 def readNetFromDarknet(bufferCfg: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferModel: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]] = ...) -> Net: ...
 
 @_typing.overload
-def readNetFromModelOptimizer(xml: str, bin: str = ...) -> Net: ...
+def readNetFromModelOptimizer(xml: str | os.PathLike[str], bin: str | os.PathLike[str] = ...) -> Net: ...
 @_typing.overload
 def readNetFromModelOptimizer(bufferModelConfig: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferWeights: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]]) -> Net: ...
 
 @_typing.overload
-def readNetFromONNX(onnxFile: str) -> Net: ...
+def readNetFromONNX(onnxFile: str | os.PathLike[str]) -> Net: ...
 @_typing.overload
 def readNetFromONNX(buffer: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]]) -> Net: ...
 
 @_typing.overload
-def readNetFromTFLite(model: str) -> Net: ...
+def readNetFromTFLite(model: str | os.PathLike[str]) -> Net: ...
 @_typing.overload
 def readNetFromTFLite(bufferModel: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]]) -> Net: ...
 
 @_typing.overload
-def readNetFromTensorflow(model: str, config: str = ...) -> Net: ...
+def readNetFromTensorflow(model: str | os.PathLike[str], config: str | os.PathLike[str] = ...) -> Net: ...
 @_typing.overload
 def readNetFromTensorflow(bufferModel: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]], bufferConfig: numpy.ndarray[_typing.Any, numpy.dtype[numpy.uint8]] = ...) -> Net: ...
 
-def readNetFromTorch(model: str, isBinary: bool = ..., evaluate: bool = ...) -> Net: ...
+def readNetFromTorch(model: str | os.PathLike[str], isBinary: bool = ..., evaluate: bool = ...) -> Net: ...
+
+def readTensorFromONNX(path: str | os.PathLike[str]) -> cv2.typing.MatLike: ...
+
+def readTorchBlob(filename: str | os.PathLike[str], isBinary: bool = ...) -> cv2.typing.MatLike: ...
+
+def releaseHDDLPlugin() -> None: ...
 
-def readTensorFromONNX(path: str) -> cv2.typing.MatLike: ...
+def resetMyriadDevice() -> None: ...
 
-def readTorchBlob(filename: str, isBinary: bool = ...) -> cv2.typing.MatLike: ...
+def setInferenceEngineBackendType(newBackendType: str) -> str: ...
 
-def shrinkCaffeModel(src: str, dst: str, layersTypes: _typing.Sequence[str] = ...) -> None: ...
+def shrinkCaffeModel(src: str | os.PathLike[str], dst: str | os.PathLike[str], layersTypes: _typing.Sequence[str] = ...) -> None: ...
 
 def softNMSBoxes(bboxes: _typing.Sequence[cv2.typing.Rect], scores: _typing.Sequence[float], score_threshold: float, nms_threshold: float, top_k: int = ..., sigma: float = ..., method: SoftNMSMethod = ...) -> tuple[_typing.Sequence[float], _typing.Sequence[int]]: ...
 
-def writeTextGraph(model: str, output: str) -> None: ...
+def writeTextGraph(model: str | os.PathLike[str], output: str | os.PathLike[str]) -> None: ...
 
 

cv2/fisheye/__init__.pyi

@@ -42,9 +42,9 @@ def estimateNewCameraMatrixForUndistortRectify(K: cv2.typing.MatLike, D: cv2.typ
 def estimateNewCameraMatrixForUndistortRectify(K: cv2.UMat, D: cv2.UMat, image_size: cv2.typing.Size, R: cv2.UMat, P: cv2.UMat | None = ..., balance: float = ..., new_size: cv2.typing.Size = ..., fov_scale: float = ...) -> cv2.UMat: ...
 
 @_typing.overload
-def initUndistortRectifyMap(K: cv2.typing.MatLike, D: cv2.typing.MatLike, R: cv2.typing.MatLike, P: cv2.typing.MatLike, size: cv2.typing.Size, m1type: int, map1: cv2.typing.MatLike | None = ..., map2: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+def initUndistortRectifyMap(K: cv2.typing.MatLike, D: cv2.typing.MatLike | None, R: cv2.typing.MatLike, P: cv2.typing.MatLike, size: cv2.typing.Size, m1type: int, map1: cv2.typing.MatLike | None = ..., map2: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
 @_typing.overload
-def initUndistortRectifyMap(K: cv2.UMat, D: cv2.UMat, R: cv2.UMat, P: cv2.UMat, size: cv2.typing.Size, m1type: int, map1: cv2.UMat | None = ..., map2: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
+def initUndistortRectifyMap(K: cv2.UMat, D: cv2.UMat | None, R: cv2.UMat, P: cv2.UMat, size: cv2.typing.Size, m1type: int, map1: cv2.UMat | None = ..., map2: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
 
 @_typing.overload
 def projectPoints(objectPoints: cv2.typing.MatLike, rvec: cv2.typing.MatLike, tvec: cv2.typing.MatLike, K: cv2.typing.MatLike, D: cv2.typing.MatLike, imagePoints: cv2.typing.MatLike | None = ..., alpha: float = ..., jacobian: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
@@ -56,6 +56,11 @@ def solvePnP(objectPoints: cv2.typing.MatLike, imagePoints: cv2.typing.MatLike,
 @_typing.overload
 def solvePnP(objectPoints: cv2.UMat, imagePoints: cv2.UMat, cameraMatrix: cv2.UMat, distCoeffs: cv2.UMat, rvec: cv2.UMat | None = ..., tvec: cv2.UMat | None = ..., useExtrinsicGuess: bool = ..., flags: int = ..., criteria: cv2.typing.TermCriteria = ...) -> tuple[bool, cv2.UMat, cv2.UMat]: ...
 
+@_typing.overload
+def solvePnPRansac(objectPoints: cv2.typing.MatLike, imagePoints: cv2.typing.MatLike, cameraMatrix: cv2.typing.MatLike, distCoeffs: cv2.typing.MatLike, rvec: cv2.typing.MatLike | None = ..., tvec: cv2.typing.MatLike | None = ..., useExtrinsicGuess: bool = ..., iterationsCount: int = ..., reprojectionError: float = ..., confidence: float = ..., inliers: cv2.typing.MatLike | None = ..., flags: int = ..., criteria: cv2.typing.TermCriteria = ...) -> tuple[bool, cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike]: ...
+@_typing.overload
+def solvePnPRansac(objectPoints: cv2.UMat, imagePoints: cv2.UMat, cameraMatrix: cv2.UMat, distCoeffs: cv2.UMat, rvec: cv2.UMat | None = ..., tvec: cv2.UMat | None = ..., useExtrinsicGuess: bool = ..., iterationsCount: int = ..., reprojectionError: float = ..., confidence: float = ..., inliers: cv2.UMat | None = ..., flags: int = ..., criteria: cv2.typing.TermCriteria = ...) -> tuple[bool, cv2.UMat, cv2.UMat, cv2.UMat]: ...
+
 @_typing.overload
 def stereoCalibrate(objectPoints: _typing.Sequence[cv2.typing.MatLike], imagePoints1: _typing.Sequence[cv2.typing.MatLike], imagePoints2: _typing.Sequence[cv2.typing.MatLike], K1: cv2.typing.MatLike, D1: cv2.typing.MatLike, K2: cv2.typing.MatLike, D2: cv2.typing.MatLike, imageSize: cv2.typing.Size, R: cv2.typing.MatLike | None = ..., T: cv2.typing.MatLike | None = ..., rvecs: _typing.Sequence[cv2.typing.MatLike] | None = ..., tvecs: _typing.Sequence[cv2.typing.MatLike] | None = ..., flags: int = ..., criteria: cv2.typing.TermCriteria = ...) -> tuple[float, cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike, _typing.Sequence[cv2.typing.MatLike], _typing.Sequence[cv2.typing.MatLike]]: ...
 @_typing.overload

cv2/flann/__init__.pyi

@@ -2,6 +2,7 @@ __all__: list[str] = []
 
 import cv2
 import cv2.typing
+import os
 import typing as _typing
 
 
@@ -47,12 +48,12 @@ class Index:
     @_typing.overload
     def radiusSearch(self, query: cv2.UMat, radius: float, maxResults: int, indices: cv2.UMat | None = ..., dists: cv2.UMat | None = ..., params: cv2.typing.SearchParams = ...) -> tuple[int, cv2.UMat, cv2.UMat]: ...
 
-    def save(self, filename: str) -> None: ...
+    def save(self, filename: str | os.PathLike[str]) -> None: ...
 
     @_typing.overload
-    def load(self, features: cv2.typing.MatLike, filename: str) -> bool: ...
+    def load(self, features: cv2.typing.MatLike, filename: str | os.PathLike[str]) -> bool: ...
     @_typing.overload
-    def load(self, features: cv2.UMat, filename: str) -> bool: ...
+    def load(self, features: cv2.UMat, filename: str | os.PathLike[str]) -> bool: ...
 
     def release(self) -> None: ...
 

cv2/gapi/wip/__init__.pyi

@@ -38,4 +38,6 @@ def make_capture_src(id: int, properties: cv2.typing.map_int_and_double = ...) -
 
 def make_gst_src(pipeline: str, outputType: cv2.gapi.wip.gst.GStreamerSource_OutputType = ...) -> IStreamSource: ...
 
+def make_py_src(src: IStreamSource) -> IStreamSource: ...
+
 

cv2/instr/__init__.pyi

@@ -0,0 +1,24 @@
+__all__: list[str] = []
+
+# Enumerations
+TYPE_GENERAL: int
+TYPE_MARKER: int
+TYPE_WRAPPER: int
+TYPE_FUN: int
+TYPE = int
+"""One of [TYPE_GENERAL, TYPE_MARKER, TYPE_WRAPPER, TYPE_FUN]"""
+
+IMPL_PLAIN: int
+IMPL_IPP: int
+IMPL_OPENCL: int
+IMPL = int
+"""One of [IMPL_PLAIN, IMPL_IPP, IMPL_OPENCL]"""
+
+FLAGS_NONE: int
+FLAGS_MAPPING: int
+FLAGS_EXPAND_SAME_NAMES: int
+FLAGS = int
+"""One of [FLAGS_NONE, FLAGS_MAPPING, FLAGS_EXPAND_SAME_NAMES]"""
+
+
+

cv2/load_config_py3.py

@@ -5,5 +5,5 @@ import sys
 if sys.version_info[:2] >= (3, 0):
     def exec_file_wrapper(fpath, g_vars, l_vars):
         with open(fpath) as f:
-            code = compile(f.read(), os.path.basename(fpath), 'exec')
+            code = compile(f.read(), fpath, 'exec')
             exec(code, g_vars, l_vars)

cv2/ml/__init__.pyi

@@ -2,6 +2,7 @@ __all__: list[str] = []
 
 import cv2
 import cv2.typing
+import os
 import typing as _typing
 
 
@@ -294,7 +295,7 @@ class NormalBayesClassifier(StatModel):
     def create(cls) -> NormalBayesClassifier: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> NormalBayesClassifier: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> NormalBayesClassifier: ...
 
 
 class KNearest(StatModel):
@@ -324,7 +325,7 @@ class KNearest(StatModel):
     def create(cls) -> KNearest: ...
 
     @classmethod
-    def load(cls, filepath: str) -> KNearest: ...
+    def load(cls, filepath: str | os.PathLike[str]) -> KNearest: ...
 
 
 class SVM(StatModel):
@@ -390,7 +391,7 @@ class SVM(StatModel):
     def create(cls) -> SVM: ...
 
     @classmethod
-    def load(cls, filepath: str) -> SVM: ...
+    def load(cls, filepath: str | os.PathLike[str]) -> SVM: ...
 
 
 class EM(StatModel):
@@ -442,7 +443,7 @@ class EM(StatModel):
     def create(cls) -> EM: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> EM: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> EM: ...
 
 
 class DTrees(StatModel):
@@ -487,7 +488,7 @@ class DTrees(StatModel):
     def create(cls) -> DTrees: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> DTrees: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> DTrees: ...
 
 
 class RTrees(DTrees):
@@ -517,7 +518,7 @@ class RTrees(DTrees):
     def create(cls) -> RTrees: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> RTrees: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> RTrees: ...
 
 
 class Boost(DTrees):
@@ -538,7 +539,7 @@ class Boost(DTrees):
     def create(cls) -> Boost: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> Boost: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> Boost: ...
 
 
 class ANN_MLP(StatModel):
@@ -610,7 +611,7 @@ class ANN_MLP(StatModel):
     def create(cls) -> ANN_MLP: ...
 
     @classmethod
-    def load(cls, filepath: str) -> ANN_MLP: ...
+    def load(cls, filepath: str | os.PathLike[str]) -> ANN_MLP: ...
 
 
 class LogisticRegression(StatModel):
@@ -650,7 +651,7 @@ class LogisticRegression(StatModel):
     def create(cls) -> LogisticRegression: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> LogisticRegression: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> LogisticRegression: ...
 
 
 class SVMSGD(StatModel):
@@ -663,7 +664,7 @@ class SVMSGD(StatModel):
     def create(cls) -> SVMSGD: ...
 
     @classmethod
-    def load(cls, filepath: str, nodeName: str = ...) -> SVMSGD: ...
+    def load(cls, filepath: str | os.PathLike[str], nodeName: str = ...) -> SVMSGD: ...
 
     def setOptimalParameters(self, svmsgdType: int = ..., marginType: int = ...) -> None: ...
 

cv2/typing/__init__.py

@@ -58,12 +58,12 @@ __all__ = [
     "ExtractMetaCallback",
 ]
 
+import numpy
+import typing as _typing
 import cv2.dnn
+import cv2
 import cv2.gapi.wip.draw
-import typing as _typing
 import cv2.mat_wrapper
-import numpy
-import cv2
 
 
 if _typing.TYPE_CHECKING:
@@ -98,8 +98,8 @@ Size = _typing.Sequence[int]
 """Required length is 2"""
 Size2f = _typing.Sequence[float]
 """Required length is 2"""
-Scalar = _typing.Sequence[float]
-"""Required length is at most 4"""
+Scalar = _typing.Union[_typing.Sequence[float], float]
+"""Max sequence length is at most 4"""
 Point = _typing.Sequence[int]
 """Required length is 2"""
 Point2i = Point

cv2/utils/__init__.pyi

@@ -6,6 +6,7 @@ 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
 
 

cv2/utils/logging/__init__.pyi

@@ -0,0 +1,22 @@
+__all__: list[str] = []
+
+# Enumerations
+LOG_LEVEL_SILENT: int
+LOG_LEVEL_FATAL: int
+LOG_LEVEL_ERROR: int
+LOG_LEVEL_WARNING: int
+LOG_LEVEL_INFO: int
+LOG_LEVEL_DEBUG: int
+LOG_LEVEL_VERBOSE: int
+ENUM_LOG_LEVEL_FORCE_INT: int
+LogLevel = int
+"""One of [LOG_LEVEL_SILENT, LOG_LEVEL_FATAL, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, ENUM_LOG_LEVEL_FORCE_INT]"""
+
+
+
+# Functions
+def getLogLevel() -> LogLevel: ...
+
+def setLogLevel(logLevel: LogLevel) -> LogLevel: ...
+
+

cv2/version.py

@@ -1,4 +1,4 @@
-opencv_version = "4.11.0.86"
+opencv_version = "4.13.0.90"
 contrib = False
 headless = True
 rolling = False