types-opencv-python 1.0.0__py3-none-any.whl

cv2/detail.pyi

@@ -0,0 +1,1029 @@
+'''
+encode: utf-8
+Date: 2026-02-19 15:09:25
+LastEditTime: 2026-02-19 15:09:25
+FilePath: /genout6/media/adminmaster/veracrypt3/Develop/td-opencv/dev/base.pyi
+'''
+import typing
+from typing import overload
+
+T0=typing.TypeVar("T0")
+T1=typing.TypeVar("T1")
+T2=typing.TypeVar("T2")
+T3=typing.TypeVar("T3")
+T4=typing.TypeVar("T4")
+T5=typing.TypeVar("T5")
+T6=typing.TypeVar("T6")
+T7=typing.TypeVar("T7")
+T8=typing.TypeVar("T8")
+
+retval=typing.Any
+readyIndex=int
+
+TEST_CUSTOM:int = ...
+TEST_EQ:int = ...
+TEST_NE:int = ...
+TEST_LE:int = ...
+TEST_LT:int = ...
+TEST_GE:int = ...
+TEST_GT:int = ...
+TrackerSamplerCSC_MODE_INIT_POS:int = ...
+TrackerSamplerCSC_MODE_INIT_NEG:int = ...
+TrackerSamplerCSC_MODE_TRACK_POS:int = ...
+TrackerSamplerCSC_MODE_TRACK_NEG:int = ...
+TrackerSamplerCSC_MODE_DETECT:int = ...
+OpaqueKind_CV_UNKNOWN:int = ...
+OpaqueKind_CV_BOOL:int = ...
+OpaqueKind_CV_INT:int = ...
+OpaqueKind_CV_INT64:int = ...
+OpaqueKind_CV_DOUBLE:int = ...
+OpaqueKind_CV_FLOAT:int = ...
+OpaqueKind_CV_UINT64:int = ...
+OpaqueKind_CV_STRING:int = ...
+OpaqueKind_CV_POINT:int = ...
+OpaqueKind_CV_POINT2F:int = ...
+OpaqueKind_CV_POINT3F:int = ...
+OpaqueKind_CV_SIZE:int = ...
+OpaqueKind_CV_RECT:int = ...
+OpaqueKind_CV_SCALAR:int = ...
+OpaqueKind_CV_MAT:int = ...
+OpaqueKind_CV_DRAW_PRIM:int = ...
+ArgKind_OPAQUE_VAL:int = ...
+ArgKind_OPAQUE:int = ...
+ArgKind_GOBJREF:int = ...
+ArgKind_GMAT:int = ...
+ArgKind_GMATP:int = ...
+ArgKind_GFRAME:int = ...
+ArgKind_GSCALAR:int = ...
+ArgKind_GARRAY:int = ...
+ArgKind_GOPAQUE:int = ...
+Blender_NO:int = ...
+Blender_FEATHER:int = ...
+Blender_MULTI_BAND:int = ...
+ExposureCompensator_NO:int = ...
+ExposureCompensator_GAIN:int = ...
+ExposureCompensator_GAIN_BLOCKS:int = ...
+ExposureCompensator_CHANNELS:int = ...
+ExposureCompensator_CHANNELS_BLOCKS:int = ...
+WAVE_CORRECT_HORIZ:int = ...
+WAVE_CORRECT_VERT:int = ...
+WAVE_CORRECT_AUTO:int = ...
+SeamFinder_NO:int = ...
+SeamFinder_VORONOI_SEAM:int = ...
+SeamFinder_DP_SEAM:int = ...
+DpSeamFinder_COLOR:int = ...
+DpSeamFinder_COLOR_GRAD:int = ...
+GraphCutSeamFinderBase_COST_COLOR:int = ...
+GraphCutSeamFinderBase_COST_COLOR_GRAD:int = ...
+Timelapser_AS_IS:int = ...
+Timelapser_CROP:int = ...
+class Blender:
+    @overload
+    def prepare(self,dst_roi) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @overload
+    def prepare(self,corners,sizes) -> None:
+        """
+        ```
+        Prepares the blender for blending. 
+        ```
+        ---
+        ```
+        Parameters:
+        corners:                    Source images top-left corners 
+        sizes:                      Source image sizes 
+        ```
+        """
+
+    def feed(self,img,mask,tl) -> None:
+        """
+        ```
+        Processes the image. 
+        ```
+        ---
+        ```
+        Parameters:
+        img:                        Source image 
+        mask:                       Source image mask 
+        tl:                         Source image top-left corners 
+        ```
+        """
+
+    @staticmethod
+    def createDefault(type:int,try_gpu:bool=...) -> Blender:
+        """
+        ```
+        
+        ```
+        """
+
+    def blend(self,dst:T0,dst_mask:T0) -> T0|T0:
+        """
+        ```
+        Blends and returns the final pano. 
+        ```
+        ---
+        ```
+        Parameters:
+        dst:                        Final pano 
+        dst_mask:                   Final pano mask 
+        ```
+        """
+
+class FeatherBlender(Blender):
+    def sharpness(self) -> retval: ...
+
+    def setSharpness(self,val:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def prepare(self,dst_roi) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def feed(self,img,mask,tl) -> None:
+        """
+        ```
+        Processes the image. 
+        ```
+        ---
+        ```
+        Parameters:
+        img:                        Source image 
+        mask:                       Source image mask 
+        tl:                         Source image top-left corners 
+        ```
+        """
+
+    def createWeightMaps(self,masks,corners,weight_maps:T0) -> retval|T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def blend(self,dst:T0,dst_mask:T0) -> T0|T0:
+        """
+        ```
+        Blends and returns the final pano. 
+        ```
+        ---
+        ```
+        Parameters:
+        dst:                        Final pano 
+        dst_mask:                   Final pano mask 
+        ```
+        """
+
+    @overload
+    def __init__(self,sharpness:float=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class MultiBandBlender(Blender):
+    def setNumBands(self,val:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def prepare(self,dst_roi) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def numBands(self) -> retval: ...
+
+    def feed(self,img,mask,tl) -> None:
+        """
+        ```
+        Processes the image. 
+        ```
+        ---
+        ```
+        Parameters:
+        img:                        Source image 
+        mask:                       Source image mask 
+        tl:                         Source image top-left corners 
+        ```
+        """
+
+    def blend(self,dst:T0,dst_mask:T0) -> T0|T0:
+        """
+        ```
+        Blends and returns the final pano. 
+        ```
+        ---
+        ```
+        Parameters:
+        dst:                        Final pano 
+        dst_mask:                   Final pano mask 
+        ```
+        """
+
+    @overload
+    def __init__(self,try_gpu:int=...,num_bands:int=...,weight_type:int=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class CameraParams:
+    def K(self) -> retval: ...
+
+class ExposureCompensator:
+    def setUpdateGain(self,b:bool) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setMatGains(self,arg1) -> None: ...
+
+    def getUpdateGain(self) -> retval: ...
+
+    def getMatGains(self,arg1:T0=...) -> T0: ...
+
+    def feed(self,corners,images,masks) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @staticmethod
+    def createDefault(type:int) -> ExposureCompensator:
+        """
+        ```
+        
+        ```
+        """
+
+    def apply(self,index:int,corner,image:T0,mask) -> T0:
+        """
+        ```
+        Compensate exposure in the specified image. 
+        ```
+        ---
+        ```
+        Parameters:
+        index:                      Image index 
+        corner:                     Image top-left corner 
+        image:                      Image to process 
+        mask:                       Image mask 
+        ```
+        """
+
+class NoExposureCompensator(ExposureCompensator):
+    def setMatGains(self,umv) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getMatGains(self,umv:T0=...) -> T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def apply(self,arg1,arg2,arg3:T0,arg4) -> T0: ...
+
+class GainCompensator(ExposureCompensator):
+    def setSimilarityThreshold(self,similarity_threshold:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setNrFeeds(self,nr_feeds:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setMatGains(self,umv) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getSimilarityThreshold(self) -> retval: ...
+
+    def getNrFeeds(self) -> retval: ...
+
+    def getMatGains(self,umv:T0=...) -> T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def apply(self,index:int,corner,image:T0,mask) -> T0:
+        """
+        ```
+        Compensate exposure in the specified image. 
+        ```
+        ---
+        ```
+        Parameters:
+        index:                      Image index 
+        corner:                     Image top-left corner 
+        image:                      Image to process 
+        mask:                       Image mask 
+        ```
+        """
+
+    @overload
+    def __init__(self,nr_feeds:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def __init__(self) -> None: ...
+
+class ChannelsCompensator(ExposureCompensator):
+    def setSimilarityThreshold(self,similarity_threshold:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setNrFeeds(self,nr_feeds:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setMatGains(self,umv) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getSimilarityThreshold(self) -> retval: ...
+
+    def getNrFeeds(self) -> retval: ...
+
+    def getMatGains(self,umv:T0=...) -> T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def apply(self,index:int,corner,image:T0,mask) -> T0:
+        """
+        ```
+        Compensate exposure in the specified image. 
+        ```
+        ---
+        ```
+        Parameters:
+        index:                      Image index 
+        corner:                     Image top-left corner 
+        image:                      Image to process 
+        mask:                       Image mask 
+        ```
+        """
+
+    @overload
+    def __init__(self,nr_feeds:int=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class BlocksCompensator(ExposureCompensator):
+    def setSimilarityThreshold(self,similarity_threshold:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setNrGainsFilteringIterations(self,nr_iterations:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setNrFeeds(self,nr_feeds:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setMatGains(self,umv) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @overload
+    def setBlockSize(self,size) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @overload
+    def setBlockSize(self,width:int,height:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getSimilarityThreshold(self) -> retval: ...
+
+    def getNrGainsFilteringIterations(self) -> retval: ...
+
+    def getNrFeeds(self) -> retval: ...
+
+    def getMatGains(self,umv:T0=...) -> T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def getBlockSize(self) -> retval: ...
+
+    def apply(self,index:int,corner,image:T0,mask) -> T0:
+        """
+        ```
+        Compensate exposure in the specified image. 
+        ```
+        ---
+        ```
+        Parameters:
+        index:                      Image index 
+        corner:                     Image top-left corner 
+        image:                      Image to process 
+        mask:                       Image mask 
+        ```
+        """
+
+class BlocksGainCompensator(BlocksCompensator):
+    def setMatGains(self,umv) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getMatGains(self,umv:T0=...) -> T0:
+        """
+        ```
+        
+        ```
+        """
+
+    def apply(self,index:int,corner,image:T0,mask) -> T0:
+        """
+        ```
+        Compensate exposure in the specified image. 
+        ```
+        ---
+        ```
+        Parameters:
+        index:                      Image index 
+        corner:                     Image top-left corner 
+        image:                      Image to process 
+        mask:                       Image mask 
+        ```
+        """
+
+    @overload
+    def __init__(self,bl_width:int,bl_height:int,nr_feeds:int) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @overload
+    def __init__(self,bl_width:int=...,bl_height:int=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class BlocksChannelsCompensator(BlocksCompensator):
+    @overload
+    def __init__(self,bl_width:int=...,bl_height:int=...,nr_feeds:int=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class ImageFeatures:
+    def getKeypoints(self) -> retval: ...
+
+class MatchesInfo:
+    def getMatches(self) -> retval: ...
+
+    def getInliers(self) -> retval: ...
+
+class FeaturesMatcher:
+    def isThreadSafe(self) -> retval: ...
+
+    def collectGarbage(self) -> None: ...
+
+    def apply2(self,features,mask=...) -> pairwise_matches: ...
+
+    def apply(self,features1,features2) -> matches_info: ...
+
+class BestOf2NearestMatcher(FeaturesMatcher):
+    @staticmethod
+    def create(try_use_gpu:bool=...,match_conf:float=...,num_matches_thresh1:int=...,num_matches_thresh2:int=...,matches_confindece_thresh:float=...) -> BestOf2NearestMatcher:
+        """
+        ```
+        
+        ```
+        """
+
+    def collectGarbage(self) -> None: ...
+
+    @overload
+    def __init__(self,try_use_gpu:bool=...,match_conf:float=...,num_matches_thresh1:int=...,num_matches_thresh2:int=...,matches_confindece_thresh:float=...) -> None:
+        """
+        ```
+        Constructs a "best of 2 nearest" matcher. 
+        ```
+        ---
+        ```
+        Parameters:
+        try_use_gpu:                Should try to use GPU or not 
+        match_conf:                 Match distances ration threshold 
+        num_matches_thresh1:        Minimum number of matches required for the 2D projective transform estimation used in the inliers classification step 
+        num_matches_thresh2:        Minimum number of matches required for the 2D projective transform re-estimation on inliers 
+        matches_confindece_thresh:  Matching confidence threshold to take the match into account. The threshold was determined experimentally and set to 3 by default. 
+        ```
+        """
+
+class BestOf2NearestRangeMatcher(BestOf2NearestMatcher):
+    @overload
+    def __init__(self,range_width:int=...,try_use_gpu:bool=...,match_conf:float=...,num_matches_thresh1:int=...,num_matches_thresh2:int=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class AffineBestOf2NearestMatcher(BestOf2NearestMatcher):
+    @overload
+    def __init__(self,full_affine:bool=...,try_use_gpu:bool=...,match_conf:float=...,num_matches_thresh1:int=...) -> None:
+        """
+        ```
+        Constructs a "best of 2 nearest" matcher that expects affine transformation between images. 
+        ```
+        ---
+        ```
+        Parameters:
+        full_affine:                whether to use full affine transformation with 6 degress of freedom or reduced transformation with 4 degrees of freedom using only rotation, translation and uniform scaling 
+        try_use_gpu:                Should try to use GPU or not 
+        match_conf:                 Match distances ration threshold 
+        num_matches_thresh1:        Minimum number of matches required for the 2D affine transform estimation used in the inliers classification step
+        ```
+        """
+
+class Estimator:
+    def apply(self,features,pairwise_matches,cameras:T0) -> retval|T0:
+        """
+        ```
+        Estimates camera parameters. 
+        ```
+        ---
+        ```
+        Parameters:
+        features:                   Features of images 
+        pairwise_matches:           Pairwise matches of images 
+        cameras:                    Estimated camera parameters 
+        ```
+        """
+
+class HomographyBasedEstimator(Estimator):
+    @overload
+    def __init__(self,is_focals_estimated:bool=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class AffineBasedEstimator(Estimator):
+    def __init__(self) -> None: ...
+
+class BundleAdjusterBase(Estimator):
+    def termCriteria(self) -> retval: ...
+
+    def setTermCriteria(self,term_criteria) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setRefinementMask(self,mask) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def setConfThresh(self,conf_thresh:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def refinementMask(self) -> retval: ...
+
+    def confThresh(self) -> retval: ...
+
+class NoBundleAdjuster(BundleAdjusterBase):
+    def __init__(self) -> None: ...
+
+class BundleAdjusterReproj(BundleAdjusterBase):
+    def __init__(self) -> None: ...
+
+class BundleAdjusterRay(BundleAdjusterBase):
+    def __init__(self) -> None: ...
+
+class BundleAdjusterAffine(BundleAdjusterBase):
+    def __init__(self) -> None: ...
+
+class BundleAdjusterAffinePartial(BundleAdjusterBase):
+    def __init__(self) -> None: ...
+
+class SeamFinder:
+    def find(self,src,corners,masks:T0) -> T0:
+        """
+        ```
+        Estimates seams. 
+        ```
+        ---
+        ```
+        Parameters:
+        src:                        Source images 
+        corners:                    Source image top-left corners 
+        masks:                      Source image masks to update 
+        ```
+        """
+
+    @staticmethod
+    def createDefault(type:int) -> SeamFinder:
+        """
+        ```
+        
+        ```
+        """
+
+class NoSeamFinder(SeamFinder):
+    def find(self,arg1,arg2,arg3:T0) -> T0: ...
+
+class PairwiseSeamFinder(SeamFinder):
+    def find(self,src,corners,masks:T0) -> T0:
+        """
+        ```
+        Estimates seams. 
+        ```
+        ---
+        ```
+        Parameters:
+        src:                        Source images 
+        corners:                    Source image top-left corners 
+        masks:                      Source image masks to update 
+        ```
+        """
+
+class VoronoiSeamFinder(PairwiseSeamFinder):
+    def find(self,src,corners,masks:T0) -> T0:
+        """
+        ```
+        Estimates seams. 
+        ```
+        ---
+        ```
+        Parameters:
+        src:                        Source images 
+        corners:                    Source image top-left corners 
+        masks:                      Source image masks to update 
+        ```
+        """
+
+class DpSeamFinder(SeamFinder):
+    def setCostFunction(self,val) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    @overload
+    def __init__(self,costFunc) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class GraphCutSeamFinder:
+    def find(self,src,corners,masks:T0) -> T0:
+        """
+        ```
+        Estimates seams. 
+        ```
+        ---
+        ```
+        Parameters:
+        src:                        Source images 
+        corners:                    Source image top-left corners 
+        masks:                      Source image masks to update 
+        ```
+        """
+
+    @overload
+    def __init__(self,cost_type:int,terminal_cost:float=...,bad_region_penalty:float=...) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+class Timelapser:
+    def process(self,img,mask,tl) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def initialize(self,corners,sizes) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def getDst(self) -> retval: ...
+
+    @staticmethod
+    def createDefault(type:int) -> Timelapser:
+        """
+        ```
+        
+        ```
+        """
+
+class TimelapserCrop(Timelapser): ...
+class ProjectorBase: ...
+class SphericalProjector(ProjectorBase):
+    def mapForward(self,x:float,y:float,u:float,v:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+    def mapBackward(self,u:float,v:float,x:float,y:float) -> None:
+        """
+        ```
+        
+        ```
+        """
+
+@staticmethod
+def BestOf2NearestMatcher_create(try_use_gpu:bool=...,match_conf:float=...,num_matches_thresh1:int=...,num_matches_thresh2:int=...,matches_confindece_thresh:float=...) -> BestOf2NearestMatcher:
+    """
+    ```
+    
+    ```
+    """
+
+@staticmethod
+def Blender_createDefault(type:int,try_gpu:bool=...) -> Blender:
+    """
+    ```
+    
+    ```
+    """
+
+@staticmethod
+def ExposureCompensator_createDefault(type:int) -> ExposureCompensator:
+    """
+    ```
+    
+    ```
+    """
+
+@staticmethod
+def SeamFinder_createDefault(type:int) -> SeamFinder:
+    """
+    ```
+    
+    ```
+    """
+
+@staticmethod
+def Timelapser_createDefault(type:int) -> Timelapser:
+    """
+    ```
+    
+    ```
+    """
+
+def calibrateRotatingCamera(Hs,K:T0=...) -> retval|T0:
+    """
+    ```
+    
+    ```
+    """
+
+def computeImageFeatures(featuresFinder,images,masks=...) -> features: ...
+
+def computeImageFeatures2(featuresFinder,image,mask=...) -> features: ...
+
+def createLaplacePyr(img,num_levels:int,pyr:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+def createLaplacePyrGpu(img,num_levels:int,pyr:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+def createWeightMap(mask,sharpness:float,weight:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+def focalsFromHomography(H,f0:float,f1:float,f0_ok:bool,f1_ok:bool) -> None:
+    """
+    ```
+    Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only. 
+    ```
+    ---
+    ```
+    Parameters:
+    H:                          Homography. 
+    f0:                         Estimated focal length along X axis. 
+    f1:                         Estimated focal length along Y axis. 
+    f0_ok:                      True, if f0 was estimated successfully, false otherwise. 
+    f1_ok:                      True, if f1 was estimated successfully, false otherwise.
+    ```
+    """
+
+def leaveBiggestComponent(features,pairwise_matches,conf_threshold:float) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def matchesGraphAsString(paths,pairwise_matches,conf_threshold:float) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def normalizeUsingWeightMap(weight,src:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+def overlapRoi(tl1,tl2,sz1,sz2,roi) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def restoreImageFromLaplacePyr(pyr:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+def restoreImageFromLaplacePyrGpu(pyr:T0) -> T0:
+    """
+    ```
+    
+    ```
+    """
+
+@overload
+def resultRoi(corners,images) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+@overload
+def resultRoi(corners,sizes) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def resultRoiIntersection(corners,sizes) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def resultTl(corners) -> retval:
+    """
+    ```
+    
+    ```
+    """
+
+def selectRandomSubset(count:int,size:int,subset) -> None:
+    """
+    ```
+    
+    ```
+    """
+
+def stitchingLogLevel() -> retval: ...
+
+def strip(params) -> retval: ...
+
+def waveCorrect(rmats:T0,kind) -> T0:
+    """
+    ```
+    Tries to make panorama more horizontal (or vertical). 
+    ```
+    ---
+    ```
+    Parameters:
+    rmats:                      Camera rotation matrices. 
+    kind:                       Correction kind, see detail::WaveCorrectKind. 
+    ```
+    """
+
+
+
+
+matches_info=typing.Any
+features=typing.Any
+pairwise_matches=typing.Any
+ExposureCompensator=typing.Any
+Timelapser=typing.Any
+Blender=typing.Any
+SeamFinder=typing.Any
+BestOf2NearestMatcher=typing.Any