opencv-contrib-python-headless 4.11.0.86__cp37-abi3-macosx_13_0_arm64.whl

cv2/optflow/__init__.pyi

@@ -0,0 +1,286 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Enumerations
+SR_FIXED: int
+SR_CROSS: int
+SupportRegionType = int
+"""One of [SR_FIXED, SR_CROSS]"""
+
+ST_STANDART: int
+ST_BILINEAR: int
+SolverType = int
+"""One of [ST_STANDART, ST_BILINEAR]"""
+
+INTERP_GEO: int
+INTERP_EPIC: int
+INTERP_RIC: int
+InterpolationType = int
+"""One of [INTERP_GEO, INTERP_EPIC, INTERP_RIC]"""
+
+GPC_DESCRIPTOR_DCT: int
+GPC_DESCRIPTOR_WHT: int
+GPCDescType = int
+"""One of [GPC_DESCRIPTOR_DCT, GPC_DESCRIPTOR_WHT]"""
+
+
+
+# Classes
+class DualTVL1OpticalFlow(cv2.DenseOpticalFlow):
+    # Functions
+    def getTau(self) -> float: ...
+
+    def setTau(self, val: float) -> None: ...
+
+    def getLambda(self) -> float: ...
+
+    def setLambda(self, val: float) -> None: ...
+
+    def getTheta(self) -> float: ...
+
+    def setTheta(self, val: float) -> None: ...
+
+    def getGamma(self) -> float: ...
+
+    def setGamma(self, val: float) -> None: ...
+
+    def getScalesNumber(self) -> int: ...
+
+    def setScalesNumber(self, val: int) -> None: ...
+
+    def getWarpingsNumber(self) -> int: ...
+
+    def setWarpingsNumber(self, val: int) -> None: ...
+
+    def getEpsilon(self) -> float: ...
+
+    def setEpsilon(self, val: float) -> None: ...
+
+    def getInnerIterations(self) -> int: ...
+
+    def setInnerIterations(self, val: int) -> None: ...
+
+    def getOuterIterations(self) -> int: ...
+
+    def setOuterIterations(self, val: int) -> None: ...
+
+    def getUseInitialFlow(self) -> bool: ...
+
+    def setUseInitialFlow(self, val: bool) -> None: ...
+
+    def getScaleStep(self) -> float: ...
+
+    def setScaleStep(self, val: float) -> None: ...
+
+    def getMedianFiltering(self) -> int: ...
+
+    def setMedianFiltering(self, val: int) -> None: ...
+
+    @classmethod
+    def create(cls, tau: float = ..., lambda_: float = ..., theta: float = ..., nscales: int = ..., warps: int = ..., epsilon: float = ..., innnerIterations: int = ..., outerIterations: int = ..., scaleStep: float = ..., gamma: float = ..., medianFiltering: int = ..., useInitialFlow: bool = ...) -> DualTVL1OpticalFlow: ...
+
+
+class PCAPrior:
+    ...
+
+class OpticalFlowPCAFlow(cv2.DenseOpticalFlow):
+    ...
+
+class RLOFOpticalFlowParameter:
+    # Functions
+    def setUseMEstimator(self, val: bool) -> None: ...
+
+    def setSolverType(self, val: SolverType) -> None: ...
+
+    def getSolverType(self) -> SolverType: ...
+
+    def setSupportRegionType(self, val: SupportRegionType) -> None: ...
+
+    def getSupportRegionType(self) -> SupportRegionType: ...
+
+    def setNormSigma0(self, val: float) -> None: ...
+
+    def getNormSigma0(self) -> float: ...
+
+    def setNormSigma1(self, val: float) -> None: ...
+
+    def getNormSigma1(self) -> float: ...
+
+    def setSmallWinSize(self, val: int) -> None: ...
+
+    def getSmallWinSize(self) -> int: ...
+
+    def setLargeWinSize(self, val: int) -> None: ...
+
+    def getLargeWinSize(self) -> int: ...
+
+    def setCrossSegmentationThreshold(self, val: int) -> None: ...
+
+    def getCrossSegmentationThreshold(self) -> int: ...
+
+    def setMaxLevel(self, val: int) -> None: ...
+
+    def getMaxLevel(self) -> int: ...
+
+    def setUseInitialFlow(self, val: bool) -> None: ...
+
+    def getUseInitialFlow(self) -> bool: ...
+
+    def setUseIlluminationModel(self, val: bool) -> None: ...
+
+    def getUseIlluminationModel(self) -> bool: ...
+
+    def setUseGlobalMotionPrior(self, val: bool) -> None: ...
+
+    def getUseGlobalMotionPrior(self) -> bool: ...
+
+    def setMaxIteration(self, val: int) -> None: ...
+
+    def getMaxIteration(self) -> int: ...
+
+    def setMinEigenValue(self, val: float) -> None: ...
+
+    def getMinEigenValue(self) -> float: ...
+
+    def setGlobalMotionRansacThreshold(self, val: float) -> None: ...
+
+    def getGlobalMotionRansacThreshold(self) -> float: ...
+
+    @classmethod
+    def create(cls) -> RLOFOpticalFlowParameter: ...
+
+
+class DenseRLOFOpticalFlow(cv2.DenseOpticalFlow):
+    # Functions
+    def setRLOFOpticalFlowParameter(self, val: RLOFOpticalFlowParameter) -> None: ...
+
+    def getRLOFOpticalFlowParameter(self) -> RLOFOpticalFlowParameter: ...
+
+    def setForwardBackward(self, val: float) -> None: ...
+
+    def getForwardBackward(self) -> float: ...
+
+    def getGridStep(self) -> cv2.typing.Size: ...
+
+    def setGridStep(self, val: cv2.typing.Size) -> None: ...
+
+    def setInterpolation(self, val: InterpolationType) -> None: ...
+
+    def getInterpolation(self) -> InterpolationType: ...
+
+    def getEPICK(self) -> int: ...
+
+    def setEPICK(self, val: int) -> None: ...
+
+    def getEPICSigma(self) -> float: ...
+
+    def setEPICSigma(self, val: float) -> None: ...
+
+    def getEPICLambda(self) -> float: ...
+
+    def setEPICLambda(self, val: float) -> None: ...
+
+    def getFgsLambda(self) -> float: ...
+
+    def setFgsLambda(self, val: float) -> None: ...
+
+    def getFgsSigma(self) -> float: ...
+
+    def setFgsSigma(self, val: float) -> None: ...
+
+    def setUsePostProc(self, val: bool) -> None: ...
+
+    def getUsePostProc(self) -> bool: ...
+
+    def setUseVariationalRefinement(self, val: bool) -> None: ...
+
+    def getUseVariationalRefinement(self) -> bool: ...
+
+    def setRICSPSize(self, val: int) -> None: ...
+
+    def getRICSPSize(self) -> int: ...
+
+    def setRICSLICType(self, val: int) -> None: ...
+
+    def getRICSLICType(self) -> int: ...
+
+    @classmethod
+    def create(cls, rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ..., gridStep: cv2.typing.Size = ..., interp_type: InterpolationType = ..., epicK: int = ..., epicSigma: float = ..., epicLambda: float = ..., ricSPSize: int = ..., ricSLICType: int = ..., use_post_proc: bool = ..., fgsLambda: float = ..., fgsSigma: float = ..., use_variational_refinement: bool = ...) -> DenseRLOFOpticalFlow: ...
+
+
+class SparseRLOFOpticalFlow(cv2.SparseOpticalFlow):
+    # Functions
+    def setRLOFOpticalFlowParameter(self, val: RLOFOpticalFlowParameter) -> None: ...
+
+    def getRLOFOpticalFlowParameter(self) -> RLOFOpticalFlowParameter: ...
+
+    def setForwardBackward(self, val: float) -> None: ...
+
+    def getForwardBackward(self) -> float: ...
+
+    @classmethod
+    def create(cls, rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ...) -> SparseRLOFOpticalFlow: ...
+
+
+class GPCPatchDescriptor:
+    ...
+
+class GPCPatchSample:
+    ...
+
+class GPCTrainingSamples:
+    ...
+
+class GPCTree(cv2.Algorithm):
+    ...
+
+class GPCDetails:
+    ...
+
+
+# Functions
+@_typing.overload
+def calcOpticalFlowDenseRLOF(I0: cv2.typing.MatLike, I1: cv2.typing.MatLike, flow: cv2.typing.MatLike, rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ..., gridStep: cv2.typing.Size = ..., interp_type: InterpolationType = ..., epicK: int = ..., epicSigma: float = ..., epicLambda: float = ..., ricSPSize: int = ..., ricSLICType: int = ..., use_post_proc: bool = ..., fgsLambda: float = ..., fgsSigma: float = ..., use_variational_refinement: bool = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def calcOpticalFlowDenseRLOF(I0: cv2.UMat, I1: cv2.UMat, flow: cv2.UMat, rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ..., gridStep: cv2.typing.Size = ..., interp_type: InterpolationType = ..., epicK: int = ..., epicSigma: float = ..., epicLambda: float = ..., ricSPSize: int = ..., ricSLICType: int = ..., use_post_proc: bool = ..., fgsLambda: float = ..., fgsSigma: float = ..., use_variational_refinement: bool = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def calcOpticalFlowSF(from_: cv2.typing.MatLike, to: cv2.typing.MatLike, layers: int, averaging_block_size: int, max_flow: int, flow: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def calcOpticalFlowSF(from_: cv2.UMat, to: cv2.UMat, layers: int, averaging_block_size: int, max_flow: int, flow: cv2.UMat | None = ...) -> cv2.UMat: ...
+@_typing.overload
+def calcOpticalFlowSF(from_: cv2.typing.MatLike, to: cv2.typing.MatLike, layers: int, averaging_block_size: int, max_flow: int, sigma_dist: float, sigma_color: float, postprocess_window: int, sigma_dist_fix: float, sigma_color_fix: float, occ_thr: float, upscale_averaging_radius: int, upscale_sigma_dist: float, upscale_sigma_color: float, speed_up_thr: float, flow: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def calcOpticalFlowSF(from_: cv2.UMat, to: cv2.UMat, layers: int, averaging_block_size: int, max_flow: int, sigma_dist: float, sigma_color: float, postprocess_window: int, sigma_dist_fix: float, sigma_color_fix: float, occ_thr: float, upscale_averaging_radius: int, upscale_sigma_dist: float, upscale_sigma_color: float, speed_up_thr: float, flow: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+@_typing.overload
+def calcOpticalFlowSparseRLOF(prevImg: cv2.typing.MatLike, nextImg: cv2.typing.MatLike, prevPts: cv2.typing.MatLike, nextPts: cv2.typing.MatLike, status: cv2.typing.MatLike | None = ..., err: cv2.typing.MatLike | None = ..., rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ...) -> tuple[cv2.typing.MatLike, cv2.typing.MatLike, cv2.typing.MatLike]: ...
+@_typing.overload
+def calcOpticalFlowSparseRLOF(prevImg: cv2.UMat, nextImg: cv2.UMat, prevPts: cv2.UMat, nextPts: cv2.UMat, status: cv2.UMat | None = ..., err: cv2.UMat | None = ..., rlofParam: RLOFOpticalFlowParameter = ..., forwardBackwardThreshold: float = ...) -> tuple[cv2.UMat, cv2.UMat, cv2.UMat]: ...
+
+@_typing.overload
+def calcOpticalFlowSparseToDense(from_: cv2.typing.MatLike, to: cv2.typing.MatLike, flow: cv2.typing.MatLike | None = ..., grid_step: int = ..., k: int = ..., sigma: float = ..., use_post_proc: bool = ..., fgs_lambda: float = ..., fgs_sigma: float = ...) -> cv2.typing.MatLike: ...
+@_typing.overload
+def calcOpticalFlowSparseToDense(from_: cv2.UMat, to: cv2.UMat, flow: cv2.UMat | None = ..., grid_step: int = ..., k: int = ..., sigma: float = ..., use_post_proc: bool = ..., fgs_lambda: float = ..., fgs_sigma: float = ...) -> cv2.UMat: ...
+
+def createOptFlow_DeepFlow() -> cv2.DenseOpticalFlow: ...
+
+def createOptFlow_DenseRLOF() -> cv2.DenseOpticalFlow: ...
+
+def createOptFlow_DualTVL1() -> DualTVL1OpticalFlow: ...
+
+def createOptFlow_Farneback() -> cv2.DenseOpticalFlow: ...
+
+def createOptFlow_PCAFlow() -> cv2.DenseOpticalFlow: ...
+
+def createOptFlow_SimpleFlow() -> cv2.DenseOpticalFlow: ...
+
+def createOptFlow_SparseRLOF() -> cv2.SparseOpticalFlow: ...
+
+def createOptFlow_SparseToDense() -> cv2.DenseOpticalFlow: ...
+
+

cv2/parallel/__init__.pyi

@@ -0,0 +1,6 @@
+__all__: list[str] = []
+
+# Functions
+def setParallelForBackend(backendName: str, propagateNumThreads: bool = ...) -> bool: ...
+
+

cv2/phase_unwrapping/__init__.pyi

@@ -0,0 +1,41 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class HistogramPhaseUnwrapping(PhaseUnwrapping):
+    # Classes
+    class Params:
+        width: int
+        height: int
+        histThresh: float
+        nbrOfSmallBins: int
+        nbrOfLargeBins: int
+
+        # Functions
+        def __init__(self) -> None: ...
+
+
+
+    # Functions
+    @classmethod
+    def create(cls, parameters: HistogramPhaseUnwrapping.Params = ...) -> HistogramPhaseUnwrapping: ...
+
+    @_typing.overload
+    def getInverseReliabilityMap(self, reliabilityMap: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getInverseReliabilityMap(self, reliabilityMap: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+
+class PhaseUnwrapping(cv2.Algorithm):
+    # Functions
+    @_typing.overload
+    def unwrapPhaseMap(self, wrappedPhaseMap: cv2.typing.MatLike, unwrappedPhaseMap: cv2.typing.MatLike | None = ..., shadowMask: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def unwrapPhaseMap(self, wrappedPhaseMap: cv2.UMat, unwrappedPhaseMap: cv2.UMat | None = ..., shadowMask: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+
+

cv2/plot/__init__.pyi

@@ -0,0 +1,64 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class Plot2d(cv2.Algorithm):
+    # Functions
+    def setMinX(self, _plotMinX: float) -> None: ...
+
+    def setMinY(self, _plotMinY: float) -> None: ...
+
+    def setMaxX(self, _plotMaxX: float) -> None: ...
+
+    def setMaxY(self, _plotMaxY: float) -> None: ...
+
+    def setPlotLineWidth(self, _plotLineWidth: int) -> None: ...
+
+    def setNeedPlotLine(self, _needPlotLine: bool) -> None: ...
+
+    def setPlotLineColor(self, _plotLineColor: cv2.typing.Scalar) -> None: ...
+
+    def setPlotBackgroundColor(self, _plotBackgroundColor: cv2.typing.Scalar) -> None: ...
+
+    def setPlotAxisColor(self, _plotAxisColor: cv2.typing.Scalar) -> None: ...
+
+    def setPlotGridColor(self, _plotGridColor: cv2.typing.Scalar) -> None: ...
+
+    def setPlotTextColor(self, _plotTextColor: cv2.typing.Scalar) -> None: ...
+
+    def setPlotSize(self, _plotSizeWidth: int, _plotSizeHeight: int) -> None: ...
+
+    def setShowGrid(self, needShowGrid: bool) -> None: ...
+
+    def setShowText(self, needShowText: bool) -> None: ...
+
+    def setGridLinesNumber(self, gridLinesNumber: int) -> None: ...
+
+    def setInvertOrientation(self, _invertOrientation: bool) -> None: ...
+
+    def setPointIdxToPrint(self, pointIdx: int) -> None: ...
+
+    @_typing.overload
+    def render(self, _plotResult: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def render(self, _plotResult: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, data: cv2.typing.MatLike) -> Plot2d: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, data: cv2.UMat) -> Plot2d: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, dataX: cv2.typing.MatLike, dataY: cv2.typing.MatLike) -> Plot2d: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, dataX: cv2.UMat, dataY: cv2.UMat) -> Plot2d: ...
+
+
+

cv2/ppf_match_3d/__init__.pyi

@@ -0,0 +1,90 @@
+__all__: list[str] = []
+
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class ICP:
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, iterations: int, tolerence: float = ..., rejectionScale: float = ..., numLevels: int = ..., sampleType: int = ..., numMaxCorr: int = ...) -> None: ...
+
+    @_typing.overload
+    def registerModelToScene(self, srcPC: cv2.typing.MatLike, dstPC: cv2.typing.MatLike) -> tuple[int, float, cv2.typing.Matx44d]: ...
+    @_typing.overload
+    def registerModelToScene(self, srcPC: cv2.typing.MatLike, dstPC: cv2.typing.MatLike, poses: _typing.Sequence[Pose3D]) -> tuple[int, _typing.Sequence[Pose3D]]: ...
+
+
+class Pose3D:
+    @property
+    def alpha(self) -> float: ...
+    @property
+    def residual(self) -> float: ...
+    @property
+    def modelIndex(self) -> int: ...
+    @property
+    def numVotes(self) -> int: ...
+    @property
+    def pose(self) -> cv2.typing.Matx44d: ...
+    @property
+    def angle(self) -> float: ...
+    @property
+    def t(self) -> cv2.typing.Vec3d: ...
+    @property
+    def q(self) -> cv2.typing.Vec4d: ...
+
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, Alpha: float, ModelIndex: int = ..., NumVotes: int = ...) -> None: ...
+
+    @_typing.overload
+    def updatePose(self, NewPose: cv2.typing.Matx44d) -> None: ...
+    @_typing.overload
+    def updatePose(self, NewR: cv2.typing.Matx33d, NewT: cv2.typing.Vec3d) -> None: ...
+
+    def updatePoseQuat(self, Q: cv2.typing.Vec4d, NewT: cv2.typing.Vec3d) -> None: ...
+
+    def appendPose(self, IncrementalPose: cv2.typing.Matx44d) -> None: ...
+
+    def printPose(self) -> None: ...
+
+
+class PoseCluster3D:
+    ...
+
+class PPF3DDetector:
+    # Functions
+    @_typing.overload
+    def __init__(self) -> None: ...
+    @_typing.overload
+    def __init__(self, relativeSamplingStep: float, relativeDistanceStep: float = ..., numAngles: float = ...) -> None: ...
+
+    def trainModel(self, Model: cv2.typing.MatLike) -> None: ...
+
+    def match(self, scene: cv2.typing.MatLike, relativeSceneSampleStep: float = ..., relativeSceneDistance: float = ...) -> _typing.Sequence[Pose3D]: ...
+
+
+
+# Functions
+def addNoisePC(pc: cv2.typing.MatLike, scale: float) -> cv2.typing.MatLike: ...
+
+def computeNormalsPC3d(PC: cv2.typing.MatLike, NumNeighbors: int, FlipViewpoint: bool, viewpoint: cv2.typing.Vec3f, PCNormals: cv2.typing.MatLike | None = ...) -> tuple[int, cv2.typing.MatLike]: ...
+
+def getRandomPose(Pose: cv2.typing.Matx44d) -> None: ...
+
+def loadPLYSimple(fileName: str, withNormals: int = ...) -> cv2.typing.MatLike: ...
+
+def samplePCByQuantization(pc: cv2.typing.MatLike, xrange: cv2.typing.Vec2f, yrange: cv2.typing.Vec2f, zrange: cv2.typing.Vec2f, sample_step_relative: float, weightByCenter: int = ...) -> cv2.typing.MatLike: ...
+
+def transformPCPose(pc: cv2.typing.MatLike, Pose: cv2.typing.Matx44d) -> cv2.typing.MatLike: ...
+
+def writePLY(PC: cv2.typing.MatLike, fileName: str) -> None: ...
+
+def writePLYVisibleNormals(PC: cv2.typing.MatLike, fileName: str) -> None: ...
+
+

cv2/quality/__init__.pyi

@@ -0,0 +1,149 @@
+__all__: list[str] = []
+
+import cv2
+import cv2.ml
+import cv2.typing
+import typing as _typing
+
+
+# Classes
+class QualityBase(cv2.Algorithm):
+    # Functions
+    @_typing.overload
+    def compute(self, img: cv2.typing.MatLike) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, img: cv2.UMat) -> cv2.typing.Scalar: ...
+
+    @_typing.overload
+    def getQualityMap(self, dst: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @_typing.overload
+    def getQualityMap(self, dst: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+    def clear(self) -> None: ...
+
+    def empty(self) -> bool: ...
+
+
+class QualityBRISQUE(QualityBase):
+    # Functions
+    @_typing.overload
+    def compute(self, img: cv2.typing.MatLike) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, img: cv2.UMat) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, img: cv2.typing.MatLike, model_file_path: str, range_file_path: str) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, img: cv2.UMat, model_file_path: str, range_file_path: str) -> cv2.typing.Scalar: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, model_file_path: str, range_file_path: str) -> QualityBRISQUE: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, model: cv2.ml.SVM, range: cv2.typing.MatLike) -> QualityBRISQUE: ...
+
+    @staticmethod
+    @_typing.overload
+    def computeFeatures(img: cv2.typing.MatLike, features: cv2.typing.MatLike | None = ...) -> cv2.typing.MatLike: ...
+    @staticmethod
+    @_typing.overload
+    def computeFeatures(img: cv2.UMat, features: cv2.UMat | None = ...) -> cv2.UMat: ...
+
+
+class QualityGMSD(QualityBase):
+    # Functions
+    @_typing.overload
+    def compute(self, cmp: cv2.typing.MatLike) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, cmp: cv2.UMat) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, ref: cv2.typing.MatLike, cmp: cv2.typing.MatLike, qualityMap: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.Scalar, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def compute(self, ref: cv2.UMat, cmp: cv2.UMat, qualityMap: cv2.UMat | None = ...) -> tuple[cv2.typing.Scalar, cv2.UMat]: ...
+
+    def empty(self) -> bool: ...
+
+    def clear(self) -> None: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.typing.MatLike) -> QualityGMSD: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.UMat) -> QualityGMSD: ...
+
+
+class QualityMSE(QualityBase):
+    # Functions
+    @_typing.overload
+    def compute(self, cmpImgs: _typing.Sequence[cv2.typing.MatLike]) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, cmpImgs: _typing.Sequence[cv2.UMat]) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, ref: cv2.typing.MatLike, cmp: cv2.typing.MatLike, qualityMap: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.Scalar, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def compute(self, ref: cv2.UMat, cmp: cv2.UMat, qualityMap: cv2.UMat | None = ...) -> tuple[cv2.typing.Scalar, cv2.UMat]: ...
+
+    def empty(self) -> bool: ...
+
+    def clear(self) -> None: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.typing.MatLike) -> QualityMSE: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.UMat) -> QualityMSE: ...
+
+
+class QualityPSNR(QualityBase):
+    # Functions
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.typing.MatLike, maxPixelValue: float = ...) -> QualityPSNR: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.UMat, maxPixelValue: float = ...) -> QualityPSNR: ...
+
+    @_typing.overload
+    def compute(self, cmp: cv2.typing.MatLike) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, cmp: cv2.UMat) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, ref: cv2.typing.MatLike, cmp: cv2.typing.MatLike, qualityMap: cv2.typing.MatLike | None = ..., maxPixelValue: float = ...) -> tuple[cv2.typing.Scalar, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def compute(self, ref: cv2.UMat, cmp: cv2.UMat, qualityMap: cv2.UMat | None = ..., maxPixelValue: float = ...) -> tuple[cv2.typing.Scalar, cv2.UMat]: ...
+
+    def empty(self) -> bool: ...
+
+    def clear(self) -> None: ...
+
+    def getMaxPixelValue(self) -> float: ...
+
+    def setMaxPixelValue(self, val: float) -> None: ...
+
+
+class QualitySSIM(QualityBase):
+    # Functions
+    @_typing.overload
+    def compute(self, cmp: cv2.typing.MatLike) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, cmp: cv2.UMat) -> cv2.typing.Scalar: ...
+    @_typing.overload
+    def compute(self, ref: cv2.typing.MatLike, cmp: cv2.typing.MatLike, qualityMap: cv2.typing.MatLike | None = ...) -> tuple[cv2.typing.Scalar, cv2.typing.MatLike]: ...
+    @_typing.overload
+    def compute(self, ref: cv2.UMat, cmp: cv2.UMat, qualityMap: cv2.UMat | None = ...) -> tuple[cv2.typing.Scalar, cv2.UMat]: ...
+
+    def empty(self) -> bool: ...
+
+    def clear(self) -> None: ...
+
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.typing.MatLike) -> QualitySSIM: ...
+    @classmethod
+    @_typing.overload
+    def create(cls, ref: cv2.UMat) -> QualitySSIM: ...
+
+
+