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

cv2/hfs/__init__.pyi

@@ -0,0 +1,53 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class HfsSegment(cv2.Algorithm):
+    # Functions
+    def setSegEgbThresholdI(self, c: float) -> None: ...
+
+    def getSegEgbThresholdI(self) -> float: ...
+
+    def setMinRegionSizeI(self, n: int) -> None: ...
+
+    def getMinRegionSizeI(self) -> int: ...
+
+    def setSegEgbThresholdII(self, c: float) -> None: ...
+
+    def getSegEgbThresholdII(self) -> float: ...
+
+    def setMinRegionSizeII(self, n: int) -> None: ...
+
+    def getMinRegionSizeII(self) -> int: ...
+
+    def setSpatialWeight(self, w: float) -> None: ...
+
+    def getSpatialWeight(self) -> float: ...
+
+    def setSlicSpixelSize(self, n: int) -> None: ...
+
+    def getSlicSpixelSize(self) -> int: ...
+
+    def setNumSlicIter(self, n: int) -> None: ...
+
+    def getNumSlicIter(self) -> int: ...
+
+    @_typing.overload
+    def performSegmentGpu(self, src: cv2.typing.MatLike, ifDraw: bool = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def performSegmentGpu(self, src: cv2.UMat, ifDraw: bool = ...) -> cv2.typing.MatLike: ...
+
+    @_typing.overload
+    def performSegmentCpu(self, src: cv2.typing.MatLike, ifDraw: bool = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def performSegmentCpu(self, src: cv2.UMat, ifDraw: bool = ...) -> cv2.typing.MatLike: ...
+
+    @classmethod
+    def create(cls, height: int, width: int, segEgbThresholdI: float = ..., minRegionSizeI: int = ..., segEgbThresholdII: float = ..., minRegionSizeII: int = ..., spatialWeight: float = ..., slicSpixelSize: int = ..., numSlicIter: int = ...) -> HfsSegment: ...
+
+
+

cv2/img_hash/__init__.pyi

@@ -0,0 +1,116 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Enumerations
+BLOCK_MEAN_HASH_MODE_0: int
+BLOCK_MEAN_HASH_MODE_1: int
+BlockMeanHashMode = int
+"""One of [BLOCK_MEAN_HASH_MODE_0, BLOCK_MEAN_HASH_MODE_1]"""
+
+
+
+# Classes
+class AverageHash(ImgHashBase):
+    # Functions
+    @classmethod
+    def create(cls) -> AverageHash: ...
+
+
+class ImgHashBase(cv2.Algorithm):
+    # Functions
+    @_typing.overload
+    def compute(self, inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def compute(self, inputArr: cv2.UMat, outputArr: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def compare(self, hashOne: cv2.typing.MatLike, hashTwo: cv2.typing.MatLike) -> float: ...
+    @_typing.overload
+    def compare(self, hashOne: cv2.UMat, hashTwo: cv2.UMat) -> float: ...
+
+
+class BlockMeanHash(ImgHashBase):
+    # Functions
+    def setMode(self, mode: int) -> None: ...
+
+    def getMean(self) -> _typing.Sequence[float]: ...
+
+    @classmethod
+    def create(cls, mode: int = ...) -> BlockMeanHash: ...
+
+
+class ColorMomentHash(ImgHashBase):
+    # Functions
+    @classmethod
+    def create(cls) -> ColorMomentHash: ...
+
+
+class MarrHildrethHash(ImgHashBase):
+    # Functions
+    def getAlpha(self) -> float: ...
+
+    def getScale(self) -> float: ...
+
+    def setKernelParam(self, alpha: float, scale: float) -> None: ...
+
+    @classmethod
+    def create(cls, alpha: float = ..., scale: float = ...) -> MarrHildrethHash: ...
+
+
+class PHash(ImgHashBase):
+    # Functions
+    @classmethod
+    def create(cls) -> PHash: ...
+
+
+class RadialVarianceHash(ImgHashBase):
+    # Functions
+    @classmethod
+    def create(cls, sigma: float = ..., numOfAngleLine: int = ...) -> RadialVarianceHash: ...
+
+    def getNumOfAngleLine(self) -> int: ...
+
+    def getSigma(self) -> float: ...
+
+    def setNumOfAngleLine(self, value: int) -> None: ...
+
+    def setSigma(self, value: float) -> None: ...
+
+
+
+# Functions
+@_typing.overload
+def averageHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def averageHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def blockMeanHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ..., mode: int = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def blockMeanHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ..., mode: int = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def colorMomentHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def colorMomentHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def marrHildrethHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ..., alpha: float = ..., scale: float = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def marrHildrethHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ..., alpha: float = ..., scale: float = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def pHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def pHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def radialVarianceHash(inputArr: cv2.typing.MatLike, outputArr: cv2.typing.MatLike | None = ..., sigma: float = ..., numOfAngleLine: int = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def radialVarianceHash(inputArr: cv2.UMat, outputArr: cv2.UMat | None = ..., sigma: float = ..., numOfAngleLine: int = ...) -> cv2.UMat: ...
+
+

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/intensity_transform/__init__.pyi

@@ -0,0 +1,27 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Functions
+@_typing.overload
+def BIMEF(input: cv2.typing.MatLike, output: cv2.typing.MatLike | None = ..., mu: float = ..., a: float = ..., b: float = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def BIMEF(input: cv2.UMat, output: cv2.UMat | None = ..., mu: float = ..., a: float = ..., b: float = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def BIMEF2(input: cv2.typing.MatLike, k: float, mu: float, a: float, b: float, output: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def BIMEF2(input: cv2.UMat, k: float, mu: float, a: float, b: float, output: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+def autoscaling(input: cv2.typing.MatLike, output: cv2.typing.MatLike) -> None: ...
+
+def contrastStretching(input: cv2.typing.MatLike, output: cv2.typing.MatLike, r1: int, s1: int, r2: int, s2: int) -> None: ...
+
+def gammaCorrection(input: cv2.typing.MatLike, output: cv2.typing.MatLike, gamma: float) -> None: ...
+
+def logTransform(input: cv2.typing.MatLike, output: cv2.typing.MatLike) -> None: ...
+
+

cv2/ipp/__init__.pyi

@@ -0,0 +1,14 @@
+__all__: list[str] = []
+
+# Functions
+def getIppVersion() -> str: ...
+
+def setUseIPP(flag: bool) -> None: ...
+
+def setUseIPP_NotExact(flag: bool) -> None: ...
+
+def useIPP() -> bool: ...
+
+def useIPP_NotExact() -> bool: ...
+
+

cv2/kinfu/__init__.pyi

@@ -0,0 +1,133 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+from cv2.kinfu import detail as detail
+
+
+# Enumerations
+VolumeType_TSDF: int
+VOLUME_TYPE_TSDF: int
+VolumeType_HASHTSDF: int
+VOLUME_TYPE_HASHTSDF: int
+VolumeType_COLOREDTSDF: int
+VOLUME_TYPE_COLOREDTSDF: int
+VolumeType = int
+"""One of [VolumeType_TSDF, VOLUME_TYPE_TSDF, VolumeType_HASHTSDF, VOLUME_TYPE_HASHTSDF, VolumeType_COLOREDTSDF, VOLUME_TYPE_COLOREDTSDF]"""
+
+
+
+# Classes
+class Params:
+    frameSize: cv2.typing.Size
+    volumeType: VolumeType
+    intr: cv2.typing.Matx33f
+    rgb_intr: cv2.typing.Matx33f
+    depthFactor: float
+    bilateral_sigma_depth: float
+    bilateral_sigma_spatial: float
+    bilateral_kernel_size: int
+    pyramidLevels: int
+    volumeDims: cv2.typing.Vec3i
+    voxelSize: float
+    tsdf_min_camera_movement: float
+    tsdf_trunc_dist: float
+    tsdf_max_weight: int
+    raycast_step_factor: float
+    lightPose: cv2.typing.Vec3f
+    icpDistThresh: float
+    icpAngleThresh: float
+    icpIterations: _typing.Sequence[int]
+    truncateThreshold: float
+
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, volumeInitialPoseRot: cv2.typing.Matx33f, volumeInitialPoseTransl: cv2.typing.Vec3f) -> None: ...
+    @_typing.overload
+    def __init__(self, volumeInitialPose: cv2.typing.Matx44f) -> None: ...
+
+    @_typing.overload
+    def setInitialVolumePose(self, R: cv2.typing.Matx33f, t: cv2.typing.Vec3f) -> None: ...
+    @_typing.overload
+    def setInitialVolumePose(self, homogen_tf: cv2.typing.Matx44f) -> None: ...
+
+    @classmethod
+    def defaultParams(cls) -> Params: ...
+
+    @classmethod
+    def coarseParams(cls) -> Params: ...
+
+    @classmethod
+    def hashTSDFParams(cls, isCoarse: bool) -> Params: ...
+
+    @classmethod
+    def coloredTSDFParams(cls, isCoarse: bool) -> Params: ...
+
+
+class KinFu:
+    # Functions
+    @classmethod
+    def create(cls, _params: Params) -> KinFu: ...
+
+    @_typing.overload
+    def render(self, image: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def render(self, image: cv2.UMat | None = ...) -> cv2.UMat: ...
+    @_typing.overload
+    def render(self, cameraPose: cv2.typing.Matx44f, image: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def render(self, cameraPose: cv2.typing.Matx44f, image: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def getCloud(self, points: cv2.typing.MatLike | None = ..., normals: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def getCloud(self, points: cv2.UMat | None = ..., normals: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
+
+    @_typing.overload
+    def getPoints(self, points: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getPoints(self, points: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def getNormals(self, points: cv2.typing.MatLike, normals: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getNormals(self, points: cv2.UMat, normals: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    def reset(self) -> None: ...
+
+    @_typing.overload
+    def update(self, depth: cv2.typing.MatLike) -> bool: ...
+    @_typing.overload
+    def update(self, depth: cv2.UMat) -> bool: ...
+
+
+class Volume:
+    ...
+
+class VolumeParams:
+    type: VolumeType
+    resolution: cv2.typing.Vec3i
+    voxelSize: float
+    tsdfTruncDist: float
+    maxWeight: int
+    depthTruncThreshold: float
+    raycastStepFactor: float
+
+    # Functions
+    @classmethod
+    def defaultParams(cls, _volumeType: VolumeType) -> VolumeParams: ...
+
+    @classmethod
+    def coarseParams(cls, _volumeType: VolumeType) -> VolumeParams: ...
+
+
+
+# Functions
+def makeVolume(_volumeType: VolumeType, _voxelSize: float, _pose: cv2.typing.Matx44f, _raycastStepFactor: float, _truncDist: float, _maxWeight: int, _truncateThreshold: float, _resolution: cv2.typing.Vec3i) -> Volume: ...
+
+

cv2/kinfu/detail/__init__.pyi

@@ -0,0 +1,7 @@
+__all__: list[str] = []
+
+# Classes
+class PoseGraph:
+    ...
+
+

cv2/large_kinfu/__init__.pyi

@@ -0,0 +1,73 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class Params:
+    frameSize: cv2.typing.Size
+    intr: cv2.typing.Matx33f
+    rgb_intr: cv2.typing.Matx33f
+    depthFactor: float
+    bilateral_sigma_depth: float
+    bilateral_sigma_spatial: float
+    bilateral_kernel_size: int
+    pyramidLevels: int
+    tsdf_min_camera_movement: float
+    lightPose: cv2.typing.Vec3f
+    icpDistThresh: float
+    icpAngleThresh: float
+    icpIterations: _typing.Sequence[int]
+    truncateThreshold: float
+
+    # Functions
+    @classmethod
+    def defaultParams(cls) -> Params: ...
+
+    @classmethod
+    def coarseParams(cls) -> Params: ...
+
+    @classmethod
+    def hashTSDFParams(cls, isCoarse: bool) -> Params: ...
+
+
+class LargeKinfu:
+    # Functions
+    @classmethod
+    def create(cls, _params: Params) -> LargeKinfu: ...
+
+    @_typing.overload
+    def render(self, image: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def render(self, image: cv2.UMat | None = ...) -> cv2.UMat: ...
+    @_typing.overload
+    def render(self, cameraPose: cv2.typing.Matx44f, image: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def render(self, cameraPose: cv2.typing.Matx44f, image: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def getCloud(self, points: cv2.typing.MatLike | None = ..., normals: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def getCloud(self, points: cv2.UMat | None = ..., normals: cv2.UMat | None = ...) -> tuple[cv2.UMat, cv2.UMat]: ...
+
+    @_typing.overload
+    def getPoints(self, points: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getPoints(self, points: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @_typing.overload
+    def getNormals(self, points: cv2.typing.MatLike, normals: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getNormals(self, points: cv2.UMat, normals: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    def reset(self) -> None: ...
+
+    @_typing.overload
+    def update(self, depth: cv2.typing.MatLike) -> bool: ...
+    @_typing.overload
+    def update(self, depth: cv2.UMat) -> bool: ...
+
+
+

cv2/legacy/__init__.pyi

@@ -0,0 +1,93 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class Tracker(cv2.Algorithm):
+    # Functions
+    @_typing.overload
+    def init(self, image: cv2.typing.MatLike, boundingBox: cv2.typing.Rect2d) -> bool: ...
+    @_typing.overload
+    def init(self, image: cv2.UMat, boundingBox: cv2.typing.Rect2d) -> bool: ...
+
+    @_typing.overload
+    def update(self, image: cv2.typing.MatLike) -> tuple[bool, cv2.typing.Rect2d]: ...
+    @_typing.overload
+    def update(self, image: cv2.UMat) -> tuple[bool, cv2.typing.Rect2d]: ...
+
+
+class TrackerMIL(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerMIL: ...
+
+
+class TrackerBoosting(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerBoosting: ...
+
+
+class TrackerMedianFlow(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerMedianFlow: ...
+
+
+class TrackerTLD(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerTLD: ...
+
+
+class TrackerKCF(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerKCF: ...
+
+
+class TrackerMOSSE(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerMOSSE: ...
+
+
+class MultiTracker(cv2.Algorithm):
+    # Functions
+    def __init__(self) -> None: ...
+
+    @_typing.overload
+    def add(self, newTracker: Tracker, image: cv2.typing.MatLike, boundingBox: cv2.typing.Rect2d) -> bool: ...
+    @_typing.overload
+    def add(self, newTracker: Tracker, image: cv2.UMat, boundingBox: cv2.typing.Rect2d) -> bool: ...
+
+    @_typing.overload
+    def update(self, image: cv2.typing.MatLike) -> tuple[bool, _typing.Sequence[cv2.typing.Rect2d]]: ...
+    @_typing.overload
+    def update(self, image: cv2.UMat) -> tuple[bool, _typing.Sequence[cv2.typing.Rect2d]]: ...
+
+    def getObjects(self) -> _typing.Sequence[cv2.typing.Rect2d]: ...
+
+    @classmethod
+    def create(cls) -> MultiTracker: ...
+
+
+class TrackerCSRT(Tracker):
+    # Functions
+    @classmethod
+    def create(cls) -> TrackerCSRT: ...
+
+    @_typing.overload
+    def setInitialMask(self, mask: cv2.typing.MatLike) -> None: ...
+    @_typing.overload
+    def setInitialMask(self, mask: cv2.UMat) -> None: ...
+
+
+
+# Functions
+def upgradeTrackingAPI(legacy_tracker: Tracker) -> Tracker: ...
+
+

cv2/line_descriptor/__init__.pyi

@@ -0,0 +1,112 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class KeyLine:
+    angle: float
+    class_id: int
+    octave: int
+    pt: cv2.typing.Point2f
+    response: float
+    size: float
+    startPointX: float
+    startPointY: float
+    endPointX: float
+    endPointY: float
+    sPointInOctaveX: float
+    sPointInOctaveY: float
+    ePointInOctaveX: float
+    ePointInOctaveY: float
+    lineLength: float
+    numOfPixels: int
+
+    # Functions
+    def __init__(self) -> None: ...
+
+    def getStartPoint(self) -> cv2.typing.Point2f: ...
+
+    def getEndPoint(self) -> cv2.typing.Point2f: ...
+
+    def getStartPointInOctave(self) -> cv2.typing.Point2f: ...
+
+    def getEndPointInOctave(self) -> cv2.typing.Point2f: ...
+
+
+class BinaryDescriptor(cv2.Algorithm):
+    # Functions
+    @classmethod
+    def createBinaryDescriptor(cls) -> BinaryDescriptor: ...
+
+    def getNumOfOctaves(self) -> int: ...
+
+    def setNumOfOctaves(self, octaves: int) -> None: ...
+
+    def getWidthOfBand(self) -> int: ...
+
+    def setWidthOfBand(self, width: int) -> None: ...
+
+    def getReductionRatio(self) -> int: ...
+
+    def setReductionRatio(self, rRatio: int) -> None: ...
+
+    def detect(self, image: cv2.typing.MatLike, mask: cv2.typing.MatLike | None = ...) -> _typing.Sequence[KeyLine]: ...
+
+    def compute(self, image: cv2.typing.MatLike, keylines: _typing.Sequence[KeyLine], descriptors: cv2.typing.MatLike | None = ..., returnFloatDescr: bool = ...) -> tuple[_typing.Sequence[KeyLine], cv2.typing.MatLike]: ...
+
+
+class LSDParam:
+    scale: float
+    sigma_scale: float
+    quant: float
+    ang_th: float
+    log_eps: float
+    density_th: float
+    n_bins: int
+
+    # Functions
+    def __init__(self) -> None: ...
+
+
+class LSDDetector(cv2.Algorithm):
+    # Functions
+    def __init__(self, _params: LSDParam) -> None: ...
+
+    @classmethod
+    def createLSDDetector(cls) -> LSDDetector: ...
+
+    @classmethod
+    def createLSDDetectorWithParams(cls, params: LSDParam) -> LSDDetector: ...
+
+    @_typing.overload
+    def detect(self, image: cv2.typing.MatLike, scale: int, numOctaves: int, mask: cv2.typing.MatLike | None = ...) -> _typing.Sequence[KeyLine]: ...
+    @_typing.overload
+    def detect(self, images: _typing.Sequence[cv2.typing.MatLike], keylines: _typing.Sequence[_typing.Sequence[KeyLine]], scale: int, numOctaves: int, masks: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> None: ...
+
+
+class BinaryDescriptorMatcher(cv2.Algorithm):
+    # Functions
+    def __init__(self) -> None: ...
+
+    def match(self, queryDescriptors: cv2.typing.MatLike, trainDescriptors: cv2.typing.MatLike, mask: cv2.typing.MatLike | None = ...) -> _typing.Sequence[cv2.DMatch]: ...
+
+    def matchQuery(self, queryDescriptors: cv2.typing.MatLike, masks: _typing.Sequence[cv2.typing.MatLike] | None = ...) -> _typing.Sequence[cv2.DMatch]: ...
+
+    def knnMatch(self, queryDescriptors: cv2.typing.MatLike, trainDescriptors: cv2.typing.MatLike, k: int, mask: cv2.typing.MatLike | None = ..., compactResult: bool = ...) -> _typing.Sequence[_typing.Sequence[cv2.DMatch]]: ...
+
+    def knnMatchQuery(self, queryDescriptors: cv2.typing.MatLike, matches: _typing.Sequence[_typing.Sequence[cv2.DMatch]], k: int, masks: _typing.Sequence[cv2.typing.MatLike] | None = ..., compactResult: bool = ...) -> None: ...
+
+
+class DrawLinesMatchesFlags:
+    ...
+
+
+# Functions
+def drawKeylines(image: cv2.typing.MatLike, keylines: _typing.Sequence[KeyLine], outImage: cv2.typing.MatLike | None = ..., color: cv2.typing.Scalar = ..., flags: int = ...) -> cv2.typing.MatLike: ...
+
+def drawLineMatches(img1: cv2.typing.MatLike, keylines1: _typing.Sequence[KeyLine], img2: cv2.typing.MatLike, keylines2: _typing.Sequence[KeyLine], matches1to2: _typing.Sequence[cv2.DMatch], outImg: cv2.typing.MatLike | None = ..., matchColor: cv2.typing.Scalar = ..., singleLineColor: cv2.typing.Scalar = ..., matchesMask: _typing.Sequence[str] = ..., flags: int = ...) -> cv2.typing.MatLike: ...
+
+