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

cv2/linemod/__init__.pyi

@@ -0,0 +1,151 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class Feature:
+    x: int
+    y: int
+    label: int
+
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, x: int, y: int, label: int) -> None: ...
+
+
+class Template:
+    @property
+    def width(self) -> int: ...
+    @property
+    def height(self) -> int: ...
+    @property
+    def pyramid_level(self) -> int: ...
+    @property
+    def features(self) -> _typing.Sequence[Feature]: ...
+
+class QuantizedPyramid:
+    # Functions
+    def quantize(self, dst: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+
+    def extractTemplate(self) -> tuple[bool, Template]: ...
+
+    def pyrDown(self) -> None: ...
+
+
+class Modality:
+    # Functions
+    def process(self, src: cv2.typing.MatLike, mask: cv2.typing.MatLike | None = ...) -> QuantizedPyramid: ...
+
+    def name(self) -> str: ...
+
+    def read(self, fn: cv2.FileNode) -> None: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, modality_type: str) -> Modality: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, fn: cv2.FileNode) -> Modality: ...
+
+
+class ColorGradient(Modality):
+    @property
+    def weak_threshold(self) -> float: ...
+    @property
+    def num_features(self) -> int: ...
+    @property
+    def strong_threshold(self) -> float: ...
+
+    # Functions
+    @classmethod
+    def create(cls, weak_threshold: float, num_features: int, strong_threshold: float) -> ColorGradient: ...
+
+
+class DepthNormal(Modality):
+    @property
+    def distance_threshold(self) -> int: ...
+    @property
+    def difference_threshold(self) -> int: ...
+    @property
+    def num_features(self) -> int: ...
+    @property
+    def extract_threshold(self) -> int: ...
+
+    # Functions
+    @classmethod
+    def create(cls, distance_threshold: int, difference_threshold: int, num_features: int, extract_threshold: int) -> DepthNormal: ...
+
+
+class Match:
+    x: int
+    y: int
+    similarity: float
+    class_id: str
+    template_id: int
+
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, x: int, y: int, similarity: float, class_id: str, template_id: int) -> None: ...
+
+
+class Detector:
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, modalities: _typing.Sequence[Modality], T_pyramid: _typing.Sequence[int]) -> None: ...
+
+    @_typing.overload
+    def match(self, sources: _typing.Sequence[cv2.typing.MatLike], threshold: float, class_ids: _typing.Sequence[str] = ..., quantized_images: _typing.Sequence[cv2.typing.MatLike] | None = ..., masks: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[_typing.Sequence[Match], _typing.Sequence[cv2.typing.MatLike]]: ...
+    @_typing.overload
+    def match(self, sources: _typing.Sequence[cv2.typing.MatLike], threshold: float, class_ids: _typing.Sequence[str] = ..., quantized_images: _typing.Sequence[cv2.UMat] | None = ..., masks: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> tuple[_typing.Sequence[Match], _typing.Sequence[cv2.UMat]]: ...
+
+    def addTemplate(self, sources: _typing.Sequence[cv2.typing.MatLike], class_id: str, object_mask: cv2.typing.MatLike) -> tuple[int, cv2.typing.Rect]: ...
+
+    def addSyntheticTemplate(self, templates: _typing.Sequence[Template], class_id: str) -> int: ...
+
+    def getModalities(self) -> _typing.Sequence[Modality]: ...
+
+    def getT(self, pyramid_level: int) -> int: ...
+
+    def pyramidLevels(self) -> int: ...
+
+    def getTemplates(self, class_id: str, template_id: int) -> _typing.Sequence[Template]: ...
+
+    @_typing.overload
+    def numTemplates(self) -> int: ...
+    @_typing.overload
+    def numTemplates(self, class_id: str) -> int: ...
+
+    def numClasses(self) -> int: ...
+
+    def classIds(self) -> _typing.Sequence[str]: ...
+
+    def read(self, fn: cv2.FileNode) -> None: ...
+
+    def readClasses(self, class_ids: _typing.Sequence[str], format: str = ...) -> None: ...
+
+    def writeClasses(self, format: str = ...) -> None: ...
+
+
+
+# Functions
+def colormap(quantized: cv2.typing.MatLike, dst: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+
+@_typing.overload
+def drawFeatures(img: cv2.typing.MatLike, templates: _typing.Sequence[Template], tl: cv2.typing.Point2i, size: int = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def drawFeatures(img: cv2.UMat, templates: _typing.Sequence[Template], tl: cv2.typing.Point2i, size: int = ...) -> cv2.UMat: ...
+
+def getDefaultLINE() -> Detector: ...
+
+def getDefaultLINEMOD() -> Detector: ...
+
+

cv2/load_config_py2.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+import sys
+
+if sys.version_info[:2] < (3, 0):
+    def exec_file_wrapper(fpath, g_vars, l_vars):
+        execfile(fpath, g_vars, l_vars)

cv2/load_config_py3.py

@@ -0,0 +1,9 @@
+# flake8: noqa
+import os
+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(), fpath, 'exec')
+            exec(code, g_vars, l_vars)

cv2/mat_wrapper/__init__.py

@@ -0,0 +1,40 @@
+__all__ = []
+
+import numpy as np
+import cv2 as cv
+from typing import TYPE_CHECKING, Any
+
+# Same as cv2.typing.NumPyArrayNumeric, but avoids circular dependencies
+if TYPE_CHECKING:
+    _NumPyArrayNumeric = np.ndarray[Any, np.dtype[np.integer[Any] | np.floating[Any]]]
+else:
+    _NumPyArrayNumeric = np.ndarray
+
+# NumPy documentation: https://numpy.org/doc/stable/user/basics.subclassing.html
+
+
+class Mat(_NumPyArrayNumeric):
+    '''
+    cv.Mat wrapper for numpy array.
+
+    Stores extra metadata information how to interpret and process of numpy array for underlying C++ code.
+    '''
+
+    def __new__(cls, arr, **kwargs):
+        obj = arr.view(Mat)
+        return obj
+
+    def __init__(self, arr, **kwargs):
+        self.wrap_channels = kwargs.pop('wrap_channels', getattr(arr, 'wrap_channels', False))
+        if len(kwargs) > 0:
+            raise TypeError('Unknown parameters: {}'.format(repr(kwargs)))
+
+    def __array_finalize__(self, obj):
+        if obj is None:
+            return
+        self.wrap_channels = getattr(obj, 'wrap_channels', None)
+
+
+Mat.__module__ = cv.__name__
+cv.Mat = Mat
+cv._registerMatType(Mat)

cv2/mcc/__init__.pyi

@@ -0,0 +1,109 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.dnn
+import cv2.typing
+import typing as _typing
+
+
+# Enumerations
+MCC24: int
+SG140: int
+VINYL18: int
+TYPECHART = int
+"""One of [MCC24, SG140, VINYL18]"""
+
+
+
+# Classes
+class DetectorParameters:
+    adaptiveThreshWinSizeMin: int
+    adaptiveThreshWinSizeMax: int
+    adaptiveThreshWinSizeStep: int
+    adaptiveThreshConstant: float
+    minContoursAreaRate: float
+    minContoursArea: float
+    confidenceThreshold: float
+    minContourSolidity: float
+    findCandidatesApproxPolyDPEpsMultiplier: float
+    borderWidth: int
+    B0factor: float
+    maxError: float
+    minContourPointsAllowed: int
+    minContourLengthAllowed: int
+    minInterContourDistance: int
+    minInterCheckerDistance: int
+    minImageSize: int
+    minGroupSize: int
+
+    # Functions
+    @classmethod
+    def create(cls) -> DetectorParameters: ...
+
+
+class CCheckerDetector(cv2.Algorithm):
+    # Functions
+    def setNet(self, net: cv2.dnn.Net) -> bool: ...
+
+    @_typing.overload
+    def processWithROI(self, image: cv2.typing.MatLike, chartType: TYPECHART, regionsOfInterest: _typing.Sequence[cv2.typing.Rect], nc: int = ..., useNet: bool = ..., params: DetectorParameters = ...) -> bool: ...
+    @_typing.overload
+    def processWithROI(self, image: cv2.UMat, chartType: TYPECHART, regionsOfInterest: _typing.Sequence[cv2.typing.Rect], nc: int = ..., useNet: bool = ..., params: DetectorParameters = ...) -> bool: ...
+
+    @_typing.overload
+    def process(self, image: cv2.typing.MatLike, chartType: TYPECHART, nc: int = ..., useNet: bool = ..., params: DetectorParameters = ...) -> bool: ...
+    @_typing.overload
+    def process(self, image: cv2.UMat, chartType: TYPECHART, nc: int = ..., useNet: bool = ..., params: DetectorParameters = ...) -> bool: ...
+
+    def getBestColorChecker(self) -> CChecker: ...
+
+    def getListColorChecker(self) -> _typing.Sequence[CChecker]: ...
+
+    @classmethod
+    def create(cls) -> CCheckerDetector: ...
+
+
+class CChecker:
+    # Functions
+    @classmethod
+    def create(cls) -> CChecker: ...
+
+    def setTarget(self, _target: TYPECHART) -> None: ...
+
+    def setBox(self, _box: _typing.Sequence[cv2.typing.Point2f]) -> None: ...
+
+    def setChartsRGB(self, _chartsRGB: cv2.typing.MatLike) -> None: ...
+
+    def setChartsYCbCr(self, _chartsYCbCr: cv2.typing.MatLike) -> None: ...
+
+    def setCost(self, _cost: float) -> None: ...
+
+    def setCenter(self, _center: cv2.typing.Point2f) -> None: ...
+
+    def getTarget(self) -> TYPECHART: ...
+
+    def getBox(self) -> _typing.Sequence[cv2.typing.Point2f]: ...
+
+    def getColorCharts(self) -> _typing.Sequence[cv2.typing.Point2f]: ...
+
+    def getChartsRGB(self) -> cv2.typing.MatLike: ...
+
+    def getChartsYCbCr(self) -> cv2.typing.MatLike: ...
+
+    def getCost(self) -> float: ...
+
+    def getCenter(self) -> cv2.typing.Point2f: ...
+
+
+class CCheckerDraw:
+    # Functions
+    @_typing.overload
+    def draw(self, img: cv2.typing.MatLike) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def draw(self, img: cv2.UMat) -> cv2.UMat: ...
+
+    @classmethod
+    def create(cls, pChecker: CChecker, color: cv2.typing.Scalar = ..., thickness: int = ...) -> CCheckerDraw: ...
+
+
+

cv2/misc/__init__.py

@@ -0,0 +1 @@
+from .version import get_ocv_version

cv2/misc/version.py

@@ -0,0 +1,5 @@
+import cv2
+
+
+def get_ocv_version():
+    return getattr(cv2, "__version__", "unavailable")