cv2.cv2

(version 3.4.1)

Method resolution order:

AKAZE

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, descriptor_type[, descriptor_size[, descriptor_channels[, threshold[, nOctaves[, nOctaveLayers[, diffusivity]]]]]]]) -> retval
   @brief The AKAZE constructor
   
   @param descriptor_type Type of the extracted descriptor: DESCRIPTOR_KAZE,
   DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.
   @param descriptor_size Size of the descriptor in bits. 0 -\> Full size
   @param descriptor_channels Number of channels in the descriptor (1, 2, 3)
   @param threshold Detector response threshold to accept point
   @param nOctaves Maximum octave evolution of the image
   @param nOctaveLayers Default number of sublevels per scale level
   @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or
   DIFF_CHARBONNIER

getDefaultName(...)

getDefaultName() -> retval

getDescriptorChannels(...)

getDescriptorChannels() -> retval

getDescriptorSize(...)

getDescriptorSize() -> retval

getDescriptorType(...)

getDescriptorType() -> retval

getDiffusivity(...)

getDiffusivity() -> retval

getNOctaveLayers(...)

getNOctaveLayers() -> retval

getNOctaves(...)

getNOctaves() -> retval

getThreshold(...)

getThreshold() -> retval

setDescriptorChannels(...)

setDescriptorChannels(dch) -> None

setDescriptorSize(...)

setDescriptorSize(dsize) -> None

setDescriptorType(...)

setDescriptorType(dtype) -> None

setDiffusivity(...)

setDiffusivity(diff) -> None

setNOctaveLayers(...)

setNOctaveLayers(octaveLayers) -> None

setNOctaves(...)

setNOctaves(octaves) -> None

setThreshold(...)

setThreshold(threshold) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Method resolution order:

AffineTransformer

ShapeTransformer

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getFullAffine(...)

getFullAffine() -> retval

setFullAffine(...)

setFullAffine(fullAffine) -> None

---

Methods inherited from ShapeTransformer:

applyTransformation(...)

applyTransformation(input[, output]) -> retval, output
   @brief Apply a transformation, given a pre-estimated transformation parameters.
   
   @param input Contour (set of points) to apply the transformation.
   @param output Output contour.

estimateTransformation(...)

estimateTransformation(transformingShape, targetShape, matches) -> None
   @brief Estimate the transformation parameters of the current transformer algorithm, based on point matches.
   
   @param transformingShape Contour defining first shape.
   @param targetShape Contour defining second shape (Target).
   @param matches Standard vector of Matches between points.

warpImage(...)

warpImage(transformingImage[, output[, flags[, borderMode[, borderValue]]]]) -> output
   @brief Apply a transformation, given a pre-estimated transformation parameters, to an Image.
   
   @param transformingImage Input image.
   @param output Output image.
   @param flags Image interpolation method.
   @param borderMode border style.
   @param borderValue border value.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

AgastFeatureDetector

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, threshold[, nonmaxSuppression[, type]]]) -> retval

getDefaultName(...)

getDefaultName() -> retval

getNonmaxSuppression(...)

getNonmaxSuppression() -> retval

getThreshold(...)

getThreshold() -> retval

getType(...)

getType() -> retval

setNonmaxSuppression(...)

setNonmaxSuppression(f) -> None

setThreshold(...)

setThreshold(threshold) -> None

setType(...)

setType(type) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

AlignExposures

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

process(...)

process(src, dst, times, response) -> None
   @brief Aligns images
   
   @param src vector of input images
   @param dst vector of aligned images
   @param times vector of exposure time values for each image
   @param response 256x1 matrix with inverse camera response function for each pixel value, it should
   have the same number of channels as images.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

AlignMTB

AlignExposures

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

calculateShift(...)

calculateShift(img0, img1) -> retval
   @brief Calculates shift between two images, i. e. how to shift the second image to correspond it with the
   first.
   
   @param img0 first image
   @param img1 second image

computeBitmaps(...)

computeBitmaps(img[, tb[, eb]]) -> tb, eb
   @brief Computes median threshold and exclude bitmaps of given image.
   
   @param img input image
   @param tb median threshold bitmap
   @param eb exclude bitmap

getCut(...)

getCut() -> retval

getExcludeRange(...)

getExcludeRange() -> retval

getMaxBits(...)

getMaxBits() -> retval

process(...)

process(src, dst, times, response) -> None
   
 
 
 
process(src, dst) -> None
   @brief Short version of process, that doesn't take extra arguments.
   
   @param src vector of input images
   @param dst vector of aligned images

setCut(...)

setCut(value) -> None

setExcludeRange(...)

setExcludeRange(exclude_range) -> None

setMaxBits(...)

setMaxBits(max_bits) -> None

shiftMat(...)

shiftMat(src, shift[, dst]) -> dst
   @brief Helper function, that shift Mat filling new regions with zeros.
   
   @param src input image
   @param dst result image
   @param shift shift value

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

BFMatcher

DescriptorMatcher

Algorithm

builtins.object

---

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, normType[, crossCheck]]) -> retval
   @brief Brute-force matcher create method.
   @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and L2 norms are
   preferable choices for SIFT and SURF descriptors, NORM_HAMMING should be used with ORB, BRISK and
   BRIEF, NORM_HAMMING2 should be used with ORB when WTA_K==3 or 4 (see ORB::ORB constructor
   description).
   @param crossCheck If it is false, this is will be default BFMatcher behaviour when it finds the k
   nearest neighbors for each query descriptor. If crossCheck==true, then the knnMatch() method with
   k=1 will only return pairs (i,j) such that for i-th query descriptor the j-th descriptor in the
   matcher's collection is the nearest and vice versa, i.e. the BFMatcher will only return consistent
   pairs. Such technique usually produces best results with minimal number of outliers when there are
   enough matches. This is alternative to the ratio test, used by D. Lowe in SIFT paper.

---

Methods inherited from DescriptorMatcher:

add(...)

add(descriptors) -> None
   @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor
   collection.
   
   If the collection is not empty, the new descriptors are added to existing train descriptors.
   
   @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same
   train image.

clear(...)

clear() -> None
   @brief Clears the train descriptor collections.

clone(...)

clone([, emptyTrainData]) -> retval
   @brief Clones the matcher.
   
   @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,
   that is, copies both parameters and train data. If emptyTrainData is true, the method creates an
   object copy with the current parameters but with empty train data.

empty(...)

empty() -> retval
   @brief Returns true if there are no train descriptors in the both collections.

getTrainDescriptors(...)

getTrainDescriptors() -> retval
   @brief Returns a constant link to the train descriptor collection trainDescCollection .

isMaskSupported(...)

isMaskSupported() -> retval
   @brief Returns true if the descriptor matcher supports masking permissible matches.

knnMatch(...)

knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches
   @brief Finds the k best matches for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   
   These extended variants of DescriptorMatcher::match methods find several best matches for each query
   descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match
   for the details about query and train descriptors.
 
 
 
knnMatch(queryDescriptors, k[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

match(...)

match(queryDescriptors, trainDescriptors[, mask]) -> matches
   @brief Finds the best match for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   In the first variant of this method, the train descriptors are passed as an input argument. In the
   second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is
   used. Optional mask (or masks) can be passed to specify which query and training descriptors can be
   matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if
   mask.at\<uchar\>(i,j) is non-zero.
 
 
 
match(queryDescriptors[, masks]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].

radiusMatch(...)

radiusMatch(queryDescriptors, trainDescriptors, maxDistance[, mask[, compactResult]]) -> matches
   @brief For each query descriptor, finds the training descriptors not farther than the specified distance.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Found matches.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   For each query descriptor, the methods find such training descriptors that the distance between the
   query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are
   returned in the distance increasing order.
 
 
 
radiusMatch(queryDescriptors, maxDistance[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Found matches.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

train(...)

train() -> None
   @brief Trains a descriptor matcher
   
   Trains a descriptor matcher (for example, the flann index). In all methods to match, the method
   train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)
   have an empty implementation of this method. Other matchers really train their inner structures (for
   example, FlannBasedMatcher trains flann::Index ).

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

compute(...)

compute(image, keypoints[, imgDescriptor]) -> imgDescriptor
   @overload
   @param keypointDescriptors Computed descriptors to match with vocabulary.
   @param imgDescriptor Computed output image descriptor.
   @param pointIdxsOfClusters Indices of keypoints that belong to the cluster. This means that
   pointIdxsOfClusters[i] are keypoint indices that belong to the i -th cluster (word of vocabulary)
   returned if it is non-zero.

descriptorSize(...)

descriptorSize() -> retval
   @brief Returns an image descriptor size if the vocabulary is set. Otherwise, it returns 0.

descriptorType(...)

descriptorType() -> retval
   @brief Returns an image descriptor type.

getVocabulary(...)

getVocabulary() -> retval
   @brief Returns the set vocabulary.

setVocabulary(...)

setVocabulary(vocabulary) -> None
   @brief Sets a visual vocabulary.
   
   @param vocabulary Vocabulary (can be trained using the inheritor of BOWTrainer ). Each row of the
   vocabulary is a visual word (cluster center).

Method resolution order:

BOWKMeansTrainer

BOWTrainer

builtins.object

---

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

cluster(...)

cluster() -> retval
   
 
 
 
cluster(descriptors) -> retval

---

Methods inherited from BOWTrainer:

add(...)

add(descriptors) -> None
   @brief Adds descriptors to a training set.
   
   @param descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a
   descriptor.
   
   The training set is clustered using clustermethod to construct the vocabulary.

clear(...)

clear() -> None

descriptorsCount(...)

descriptorsCount() -> retval
   @brief Returns the count of all descriptors stored in the training set.

getDescriptors(...)

getDescriptors() -> retval
   @brief Returns a training set of descriptors.

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

add(...)

add(descriptors) -> None
   @brief Adds descriptors to a training set.
   
   @param descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a
   descriptor.
   
   The training set is clustered using clustermethod to construct the vocabulary.

clear(...)

clear() -> None

cluster(...)

cluster() -> retval
   @overload
 
 
 
cluster(descriptors) -> retval
   @brief Clusters train descriptors.
   
   @param descriptors Descriptors to cluster. Each row of the descriptors matrix is a descriptor.
   Descriptors are not added to the inner train descriptor set.
   
   The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first
   variant of the method, train descriptors stored in the object are clustered. In the second variant,
   input descriptors are clustered.

descriptorsCount(...)

descriptorsCount() -> retval
   @brief Returns the count of all descriptors stored in the training set.

getDescriptors(...)

getDescriptors() -> retval
   @brief Returns a training set of descriptors.

Method resolution order:

BRISK

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, thresh[, octaves[, patternScale]]]) -> retval
   @brief The BRISK constructor
   
   @param thresh AGAST detection threshold score.
   @param octaves detection octaves. Use 0 to do single scale.
   @param patternScale apply this scale to the pattern used for sampling the neighbourhood of a
   keypoint.
 
 
 
create(radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval
   @brief The BRISK constructor for a custom pattern
   
   @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for
   keypoint scale 1).
   @param numberList defines the number of sampling points on the sampling circle. Must be the same
   size as radiusList..
   @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint
   scale 1).
   @param dMin threshold for the long pairings used for orientation determination (in pixels for
   keypoint scale 1).
   @param indexChange index remapping of the bits.
 
 
 
create(thresh, octaves, radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval
   @brief The BRISK constructor for a custom pattern, detection threshold and octaves
   
   @param thresh AGAST detection threshold score.
   @param octaves detection octaves. Use 0 to do single scale.
   @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for
   keypoint scale 1).
   @param numberList defines the number of sampling points on the sampling circle. Must be the same
   size as radiusList..
   @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint
   scale 1).
   @param dMin threshold for the long pairings used for orientation determination (in pixels for
   keypoint scale 1).
   @param indexChange index remapping of the bits.

getDefaultName(...)

getDefaultName() -> retval

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Method resolution order:

BackgroundSubtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

apply(...)

apply(image[, fgmask[, learningRate]]) -> fgmask
   @brief Computes a foreground mask.
   
   @param image Next video frame.
   @param fgmask The output foreground mask as an 8-bit binary image.
   @param learningRate The value between 0 and 1 that indicates how fast the background model is
   learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
   rate. 0 means that the background model is not updated at all, 1 means that the background model
   is completely reinitialized from the last frame.

getBackgroundImage(...)

getBackgroundImage([, backgroundImage]) -> backgroundImage
   @brief Computes a background image.
   
   @param backgroundImage The output background image.
   
   @note Sometimes the background image can be very blurry, as it contain the average background
   statistics.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

BackgroundSubtractorKNN

BackgroundSubtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getDetectShadows(...)

getDetectShadows() -> retval
   @brief Returns the shadow detection flag
   
   If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorKNN for
   details.

getDist2Threshold(...)

getDist2Threshold() -> retval
   @brief Returns the threshold on the squared distance between the pixel and the sample
   
   The threshold on the squared distance between the pixel and the sample to decide whether a pixel is
   close to a data sample.

getHistory(...)

getHistory() -> retval
   @brief Returns the number of last frames that affect the background model

getNSamples(...)

getNSamples() -> retval
   @brief Returns the number of data samples in the background model

getShadowThreshold(...)

getShadowThreshold() -> retval
   @brief Returns the shadow threshold
   
   A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in
   the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel
   is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,
   *Detecting Moving Shadows...*, IEEE PAMI,2003.

getShadowValue(...)

getShadowValue() -> retval
   @brief Returns the shadow value
   
   Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0
   in the mask always means background, 255 means foreground.

getkNNSamples(...)

getkNNSamples() -> retval
   @brief Returns the number of neighbours, the k in the kNN.
   
   K is the number of samples that need to be within dist2Threshold in order to decide that that
   pixel is matching the kNN background model.

setDetectShadows(...)

setDetectShadows(detectShadows) -> None
   @brief Enables or disables shadow detection

setDist2Threshold(...)

setDist2Threshold(_dist2Threshold) -> None
   @brief Sets the threshold on the squared distance

setHistory(...)

setHistory(history) -> None
   @brief Sets the number of last frames that affect the background model

setNSamples(...)

setNSamples(_nN) -> None
   @brief Sets the number of data samples in the background model.
   
   The model needs to be reinitalized to reserve memory.

setShadowThreshold(...)

setShadowThreshold(threshold) -> None
   @brief Sets the shadow threshold

setShadowValue(...)

setShadowValue(value) -> None
   @brief Sets the shadow value

setkNNSamples(...)

setkNNSamples(_nkNN) -> None
   @brief Sets the k in the kNN. How many nearest neighbours need to match.

---

Methods inherited from BackgroundSubtractor:

apply(...)

apply(image[, fgmask[, learningRate]]) -> fgmask
   @brief Computes a foreground mask.
   
   @param image Next video frame.
   @param fgmask The output foreground mask as an 8-bit binary image.
   @param learningRate The value between 0 and 1 that indicates how fast the background model is
   learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
   rate. 0 means that the background model is not updated at all, 1 means that the background model
   is completely reinitialized from the last frame.

getBackgroundImage(...)

getBackgroundImage([, backgroundImage]) -> backgroundImage
   @brief Computes a background image.
   
   @param backgroundImage The output background image.
   
   @note Sometimes the background image can be very blurry, as it contain the average background
   statistics.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

BackgroundSubtractorMOG2

BackgroundSubtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

apply(...)

apply(image[, fgmask[, learningRate]]) -> fgmask
   @brief Computes a foreground mask.
   
   @param image Next video frame. Floating point frame will be used without scaling and should be in range \f$[0,255]\f$.
   @param fgmask The output foreground mask as an 8-bit binary image.
   @param learningRate The value between 0 and 1 that indicates how fast the background model is
   learnt. Negative parameter value makes the algorithm to use some automatically chosen learning
   rate. 0 means that the background model is not updated at all, 1 means that the background model
   is completely reinitialized from the last frame.

getBackgroundRatio(...)

getBackgroundRatio() -> retval
   @brief Returns the "background ratio" parameter of the algorithm
   
   If a foreground pixel keeps semi-constant value for about backgroundRatio\*history frames, it's
   considered background and added to the model as a center of a new component. It corresponds to TB
   parameter in the paper.

getComplexityReductionThreshold(...)

getComplexityReductionThreshold() -> retval
   @brief Returns the complexity reduction threshold
   
   This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05
   is a default value for all the samples. By setting CT=0 you get an algorithm very similar to the
   standard Stauffer&Grimson algorithm.

getDetectShadows(...)

getDetectShadows() -> retval
   @brief Returns the shadow detection flag
   
   If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorMOG2 for
   details.

getHistory(...)

getHistory() -> retval
   @brief Returns the number of last frames that affect the background model

getNMixtures(...)

getNMixtures() -> retval
   @brief Returns the number of gaussian components in the background model

getShadowThreshold(...)

getShadowThreshold() -> retval
   @brief Returns the shadow threshold
   
   A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in
   the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel
   is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,
   *Detecting Moving Shadows...*, IEEE PAMI,2003.

getShadowValue(...)

getShadowValue() -> retval
   @brief Returns the shadow value
   
   Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0
   in the mask always means background, 255 means foreground.

getVarInit(...)

getVarInit() -> retval
   @brief Returns the initial variance of each gaussian component

getVarMax(...)

getVarMax() -> retval

getVarMin(...)

getVarMin() -> retval

getVarThreshold(...)

getVarThreshold() -> retval
   @brief Returns the variance threshold for the pixel-model match
   
   The main threshold on the squared Mahalanobis distance to decide if the sample is well described by
   the background model or not. Related to Cthr from the paper.

getVarThresholdGen(...)

getVarThresholdGen() -> retval
   @brief Returns the variance threshold for the pixel-model match used for new mixture component generation
   
   Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the
   existing components (corresponds to Tg in the paper). If a pixel is not close to any component, it
   is considered foreground or added as a new component. 3 sigma =\> Tg=3\*3=9 is default. A smaller Tg
   value generates more components. A higher Tg value may result in a small number of components but
   they can grow too large.

setBackgroundRatio(...)

setBackgroundRatio(ratio) -> None
   @brief Sets the "background ratio" parameter of the algorithm

setComplexityReductionThreshold(...)

setComplexityReductionThreshold(ct) -> None
   @brief Sets the complexity reduction threshold

setDetectShadows(...)

setDetectShadows(detectShadows) -> None
   @brief Enables or disables shadow detection

setHistory(...)

setHistory(history) -> None
   @brief Sets the number of last frames that affect the background model

setNMixtures(...)

setNMixtures(nmixtures) -> None
   @brief Sets the number of gaussian components in the background model.
   
   The model needs to be reinitalized to reserve memory.

setShadowThreshold(...)

setShadowThreshold(threshold) -> None
   @brief Sets the shadow threshold

setShadowValue(...)

setShadowValue(value) -> None
   @brief Sets the shadow value

setVarInit(...)

setVarInit(varInit) -> None
   @brief Sets the initial variance of each gaussian component

setVarMax(...)

setVarMax(varMax) -> None

setVarMin(...)

setVarMin(varMin) -> None

setVarThreshold(...)

setVarThreshold(varThreshold) -> None
   @brief Sets the variance threshold for the pixel-model match

setVarThresholdGen(...)

setVarThresholdGen(varThresholdGen) -> None
   @brief Sets the variance threshold for the pixel-model match used for new mixture component generation

---

Methods inherited from BackgroundSubtractor:

getBackgroundImage(...)

getBackgroundImage([, backgroundImage]) -> backgroundImage
   @brief Computes a background image.
   
   @param backgroundImage The output background image.
   
   @note Sometimes the background image can be very blurry, as it contain the average background
   statistics.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

BaseCascadeClassifier

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

CLAHE

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

apply(...)

apply(src[, dst]) -> dst
   @brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.
   
   @param src Source image with CV_8UC1 type.
   @param dst Destination image.

collectGarbage(...)

collectGarbage() -> None

getClipLimit(...)

getClipLimit() -> retval

getTilesGridSize(...)

getTilesGridSize() -> retval

setClipLimit(...)

setClipLimit(clipLimit) -> None
   @brief Sets threshold for contrast limiting.
   
   @param clipLimit threshold value.

setTilesGridSize(...)

setTilesGridSize(tileGridSize) -> None
   @brief Sets size of grid for histogram equalization. Input image will be divided into
   equally sized rectangular tiles.
   
   @param tileGridSize defines the number of tiles in row and column.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

CalibrateCRF

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

process(...)

process(src, times[, dst]) -> dst
   @brief Recovers inverse camera response.
   
   @param src vector of input images
   @param dst 256x1 matrix with inverse camera response function
   @param times vector of exposure time values for each image

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

CalibrateDebevec

CalibrateCRF

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getLambda(...)

getLambda() -> retval

getRandom(...)

getRandom() -> retval

getSamples(...)

getSamples() -> retval

setLambda(...)

setLambda(lambda) -> None

setRandom(...)

setRandom(random) -> None

setSamples(...)

setSamples(samples) -> None

---

Methods inherited from CalibrateCRF:

process(...)

process(src, times[, dst]) -> dst
   @brief Recovers inverse camera response.
   
   @param src vector of input images
   @param dst 256x1 matrix with inverse camera response function
   @param times vector of exposure time values for each image

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

CalibrateRobertson

CalibrateCRF

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getMaxIter(...)

getMaxIter() -> retval

getRadiance(...)

getRadiance() -> retval

getThreshold(...)

getThreshold() -> retval

setMaxIter(...)

setMaxIter(max_iter) -> None

setThreshold(...)

setThreshold(threshold) -> None

---

Methods inherited from CalibrateCRF:

process(...)

process(src, times[, dst]) -> dst
   @brief Recovers inverse camera response.
   
   @param src vector of input images
   @param dst 256x1 matrix with inverse camera response function
   @param times vector of exposure time values for each image

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

convert(...) from builtins.type

convert(oldcascade, newcascade) -> retval

detectMultiScale(...)

detectMultiScale(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects
   @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
   of rectangles.
   
   @param image Matrix of the type CV_8U containing an image where objects are detected.
   @param objects Vector of rectangles where each rectangle contains the detected object, the
   rectangles may be partially outside the original image.
   @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
   @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
   to retain it.
   @param flags Parameter with the same meaning for an old cascade as in the function
   cvHaarDetectObjects. It is not used for a new cascade.
   @param minSize Minimum possible object size. Objects smaller than that are ignored.
   @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.
   
   The function is parallelized with the TBB library.
   
   @note
   -   (Python) A face detection example using cascade classifiers can be found at
   opencv_source_code/samples/python/facedetect.py

detectMultiScale2(...)

detectMultiScale2(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects, numDetections
   @overload
   @param image Matrix of the type CV_8U containing an image where objects are detected.
   @param objects Vector of rectangles where each rectangle contains the detected object, the
   rectangles may be partially outside the original image.
   @param numDetections Vector of detection numbers for the corresponding objects. An object's number
   of detections is the number of neighboring positively classified rectangles that were joined
   together to form the object.
   @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.
   @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have
   to retain it.
   @param flags Parameter with the same meaning for an old cascade as in the function
   cvHaarDetectObjects. It is not used for a new cascade.
   @param minSize Minimum possible object size. Objects smaller than that are ignored.
   @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale.

detectMultiScale3(...)

detectMultiScale3(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize[, outputRejectLevels]]]]]]) -> objects, rejectLevels, levelWeights
   @overload
   This function allows you to retrieve the final stage decision certainty of classification.
   For this, one needs to set `outputRejectLevels` on true and provide the `rejectLevels` and `levelWeights` parameter.
   For each resulting detection, `levelWeights` will then contain the certainty of classification at the final stage.
   This value can then be used to separate strong from weaker classifications.
   
   A code sample on how to use it efficiently can be found below:
   @code
   Mat img;
   vector<double> weights;
   vector<int> levels;
   vector<Rect> detections;
   CascadeClassifier model("/path/to/your/model.xml");
   model.detectMultiScale(img, detections, levels, weights, 1.1, 3, 0, Size(), Size(), true);
   cerr << "Detection " << detections[0] << " with weight " << weights[0] << endl;
   @endcode

empty(...)

empty() -> retval
   @brief Checks whether the classifier has been loaded.

getFeatureType(...)

getFeatureType() -> retval

getOriginalWindowSize(...)

getOriginalWindowSize() -> retval

isOldFormatCascade(...)

isOldFormatCascade() -> retval

load(...)

load(filename) -> retval
   @brief Loads a classifier from a file.
   
   @param filename Name of the file from which the classifier is loaded. The file may contain an old
   HAAR classifier trained by the haartraining application or a new cascade classifier trained by the
   traincascade application.

read(...)

read(node) -> retval
   @brief Reads a classifier from a FileStorage node.
   
   @note The file may contain a new cascade classifier (trained traincascade application) only.

Method resolution order:

ChiHistogramCostExtractor

HistogramCostExtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Methods inherited from HistogramCostExtractor:

buildCostMatrix(...)

buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix

getDefaultCost(...)

getDefaultCost() -> retval

getNDummies(...)

getNDummies() -> retval

setDefaultCost(...)

setDefaultCost(defaultCost) -> None

setNDummies(...)

setNDummies(nDummies) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Data descriptors defined here:

convexHullFactor

convexHullFactor

densityNeighborhoodSize

densityNeighborhoodSize

edgeGain

edgeGain

edgePenalty

edgePenalty

existingVertexGain

existingVertexGain

keypointScale

keypointScale

kmeansAttempts

kmeansAttempts

minDensity

minDensity

minDistanceToAddKeypoint

minDistanceToAddKeypoint

minGraphConfidence

minGraphConfidence

minRNGEdgeSwitchDist

minRNGEdgeSwitchDist

vertexGain

vertexGain

vertexPenalty

vertexPenalty

Method resolution order:

CirclesGridFinderParameters2

CirclesGridFinderParameters

builtins.object

---

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Data descriptors defined here:

maxRectifiedDistance

maxRectifiedDistance

squareSize

squareSize

---

Data descriptors inherited from CirclesGridFinderParameters:

convexHullFactor

convexHullFactor

densityNeighborhoodSize

densityNeighborhoodSize

edgeGain

edgeGain

edgePenalty

edgePenalty

existingVertexGain

existingVertexGain

keypointScale

keypointScale

kmeansAttempts

kmeansAttempts

minDensity

minDensity

minDistanceToAddKeypoint

minDistanceToAddKeypoint

minGraphConfidence

minGraphConfidence

minRNGEdgeSwitchDist

minRNGEdgeSwitchDist

vertexGain

vertexGain

vertexPenalty

vertexPenalty

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Data descriptors defined here:

distance

distance

imgIdx

imgIdx

queryIdx

queryIdx

trainIdx

trainIdx

Method resolution order:

DenseOpticalFlow

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

calc(...)

calc(I0, I1, flow) -> flow
   @brief Calculates an optical flow.
   
   @param I0 first 8-bit single-channel input image.
   @param I1 second input image of the same size and the same type as prev.
   @param flow computed flow image that has the same size as prev and type CV_32FC2.

collectGarbage(...)

collectGarbage() -> None
   @brief Releases all inner buffers.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

DescriptorMatcher

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

add(...)

add(descriptors) -> None
   @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor
   collection.
   
   If the collection is not empty, the new descriptors are added to existing train descriptors.
   
   @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same
   train image.

clear(...)

clear() -> None
   @brief Clears the train descriptor collections.

clone(...)

clone([, emptyTrainData]) -> retval
   @brief Clones the matcher.
   
   @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,
   that is, copies both parameters and train data. If emptyTrainData is true, the method creates an
   object copy with the current parameters but with empty train data.

create(...) from builtins.type

create(descriptorMatcherType) -> retval
   @brief Creates a descriptor matcher of a given type with the default parameters (using default
   constructor).
   
   @param descriptorMatcherType Descriptor matcher type. Now the following matcher types are
   supported:
   -   `BruteForce` (it uses L2 )
   -   `BruteForce-L1`
   -   `BruteForce-Hamming`
   -   `BruteForce-Hamming(2)`
   -   `FlannBased`
 
 
 
create(matcherType) -> retval

empty(...)

empty() -> retval
   @brief Returns true if there are no train descriptors in the both collections.

getTrainDescriptors(...)

getTrainDescriptors() -> retval
   @brief Returns a constant link to the train descriptor collection trainDescCollection .

isMaskSupported(...)

isMaskSupported() -> retval
   @brief Returns true if the descriptor matcher supports masking permissible matches.

knnMatch(...)

knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches
   @brief Finds the k best matches for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   
   These extended variants of DescriptorMatcher::match methods find several best matches for each query
   descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match
   for the details about query and train descriptors.
 
 
 
knnMatch(queryDescriptors, k[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

match(...)

match(queryDescriptors, trainDescriptors[, mask]) -> matches
   @brief Finds the best match for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   In the first variant of this method, the train descriptors are passed as an input argument. In the
   second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is
   used. Optional mask (or masks) can be passed to specify which query and training descriptors can be
   matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if
   mask.at\<uchar\>(i,j) is non-zero.
 
 
 
match(queryDescriptors[, masks]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].

radiusMatch(...)

radiusMatch(queryDescriptors, trainDescriptors, maxDistance[, mask[, compactResult]]) -> matches
   @brief For each query descriptor, finds the training descriptors not farther than the specified distance.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Found matches.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   For each query descriptor, the methods find such training descriptors that the distance between the
   query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are
   returned in the distance increasing order.
 
 
 
radiusMatch(queryDescriptors, maxDistance[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Found matches.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

train(...)

train() -> None
   @brief Trains a descriptor matcher
   
   Trains a descriptor matcher (for example, the flann index). In all methods to match, the method
   train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)
   have an empty implementation of this method. Other matchers really train their inner structures (for
   example, FlannBasedMatcher trains flann::Index ).

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Method resolution order:

DualTVL1OpticalFlow

DenseOpticalFlow

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, tau[, lambda[, theta[, nscales[, warps[, epsilon[, innnerIterations[, outerIterations[, scaleStep[, gamma[, medianFiltering[, useInitialFlow]]]]]]]]]]]]) -> retval
   @brief Creates instance of cv::DualTVL1OpticalFlow

getEpsilon(...)

getEpsilon() -> retval
   @see setEpsilon

getGamma(...)

getGamma() -> retval
   @see setGamma

getInnerIterations(...)

getInnerIterations() -> retval
   @see setInnerIterations

getLambda(...)

getLambda() -> retval
   @see setLambda

getMedianFiltering(...)

getMedianFiltering() -> retval
   @see setMedianFiltering

getOuterIterations(...)

getOuterIterations() -> retval
   @see setOuterIterations

getScaleStep(...)

getScaleStep() -> retval
   @see setScaleStep

getScalesNumber(...)

getScalesNumber() -> retval
   @see setScalesNumber

getTau(...)

getTau() -> retval
   @see setTau

getTheta(...)

getTheta() -> retval
   @see setTheta

getUseInitialFlow(...)

getUseInitialFlow() -> retval
   @see setUseInitialFlow

getWarpingsNumber(...)

getWarpingsNumber() -> retval
   @see setWarpingsNumber

setEpsilon(...)

setEpsilon(val) -> None
   @copybrief getEpsilon @see getEpsilon

setGamma(...)

setGamma(val) -> None
   @copybrief getGamma @see getGamma

setInnerIterations(...)

setInnerIterations(val) -> None
   @copybrief getInnerIterations @see getInnerIterations

setLambda(...)

setLambda(val) -> None
   @copybrief getLambda @see getLambda

setMedianFiltering(...)

setMedianFiltering(val) -> None
   @copybrief getMedianFiltering @see getMedianFiltering

setOuterIterations(...)

setOuterIterations(val) -> None
   @copybrief getOuterIterations @see getOuterIterations

setScaleStep(...)

setScaleStep(val) -> None
   @copybrief getScaleStep @see getScaleStep

setScalesNumber(...)

setScalesNumber(val) -> None
   @copybrief getScalesNumber @see getScalesNumber

setTau(...)

setTau(val) -> None
   @copybrief getTau @see getTau

setTheta(...)

setTheta(val) -> None
   @copybrief getTheta @see getTheta

setUseInitialFlow(...)

setUseInitialFlow(val) -> None
   @copybrief getUseInitialFlow @see getUseInitialFlow

setWarpingsNumber(...)

setWarpingsNumber(val) -> None
   @copybrief getWarpingsNumber @see getWarpingsNumber

---

Methods inherited from DenseOpticalFlow:

calc(...)

calc(I0, I1, flow) -> flow
   @brief Calculates an optical flow.
   
   @param I0 first 8-bit single-channel input image.
   @param I1 second input image of the same size and the same type as prev.
   @param flow computed flow image that has the same size as prev and type CV_32FC2.

collectGarbage(...)

collectGarbage() -> None
   @brief Releases all inner buffers.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

EMDHistogramCostExtractor

HistogramCostExtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getNormFlag(...)

getNormFlag() -> retval

setNormFlag(...)

setNormFlag(flag) -> None

---

Methods inherited from HistogramCostExtractor:

buildCostMatrix(...)

buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix

getDefaultCost(...)

getDefaultCost() -> retval

getNDummies(...)

getNDummies() -> retval

setDefaultCost(...)

setDefaultCost(defaultCost) -> None

setNDummies(...)

setNDummies(nDummies) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

EMDL1HistogramCostExtractor

HistogramCostExtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

---

Methods inherited from HistogramCostExtractor:

buildCostMatrix(...)

buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix

getDefaultCost(...)

getDefaultCost() -> retval

getNDummies(...)

getNDummies() -> retval

setDefaultCost(...)

setDefaultCost(defaultCost) -> None

setNDummies(...)

setNDummies(nDummies) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

FarnebackOpticalFlow

DenseOpticalFlow

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, numLevels[, pyrScale[, fastPyramids[, winSize[, numIters[, polyN[, polySigma[, flags]]]]]]]]) -> retval

getFastPyramids(...)

getFastPyramids() -> retval

getFlags(...)

getFlags() -> retval

getNumIters(...)

getNumIters() -> retval

getNumLevels(...)

getNumLevels() -> retval

getPolyN(...)

getPolyN() -> retval

getPolySigma(...)

getPolySigma() -> retval

getPyrScale(...)

getPyrScale() -> retval

getWinSize(...)

getWinSize() -> retval

setFastPyramids(...)

setFastPyramids(fastPyramids) -> None

setFlags(...)

setFlags(flags) -> None

setNumIters(...)

setNumIters(numIters) -> None

setNumLevels(...)

setNumLevels(numLevels) -> None

setPolyN(...)

setPolyN(polyN) -> None

setPolySigma(...)

setPolySigma(polySigma) -> None

setPyrScale(...)

setPyrScale(pyrScale) -> None

setWinSize(...)

setWinSize(winSize) -> None

---

Methods inherited from DenseOpticalFlow:

calc(...)

calc(I0, I1, flow) -> flow
   @brief Calculates an optical flow.
   
   @param I0 first 8-bit single-channel input image.
   @param I1 second input image of the same size and the same type as prev.
   @param flow computed flow image that has the same size as prev and type CV_32FC2.

collectGarbage(...)

collectGarbage() -> None
   @brief Releases all inner buffers.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

FastFeatureDetector

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, threshold[, nonmaxSuppression[, type]]]) -> retval

getDefaultName(...)

getDefaultName() -> retval

getNonmaxSuppression(...)

getNonmaxSuppression() -> retval

getThreshold(...)

getThreshold() -> retval

getType(...)

getType() -> retval

setNonmaxSuppression(...)

setNonmaxSuppression(f) -> None

setThreshold(...)

setThreshold(threshold) -> None

setType(...)

setType(type) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Method resolution order:

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

getDefaultName(...)

getDefaultName() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

at(...)

at(i) -> retval
   @overload
   @param i Index of an element in the sequence node.

empty(...)

empty() -> retval

getNode(...)

getNode(nodename) -> retval
   @overload
   @param nodename Name of an element in the mapping node.

isInt(...)

isInt() -> retval

isMap(...)

isMap() -> retval

isNamed(...)

isNamed() -> retval

isNone(...)

isNone() -> retval

isReal(...)

isReal() -> retval

isSeq(...)

isSeq() -> retval

isString(...)

isString() -> retval

mat(...)

mat() -> retval

name(...)

name() -> retval

real(...)

real() -> retval
   @brief Reads node elements to the buffer with the specified format.
   
   Usually it is more convenient to use operator `>>` instead of this method.
   @param fmt Specification of each array element. See @ref format_spec "format specification"
   @param vec Pointer to the destination array.
   @param len Number of elements to read. If it is greater than number of remaining elements then all
   of them will be read.

size(...)

size() -> retval

string(...)

string() -> retval

type(...)

type() -> retval
   @brief Returns type of the node.
   @returns Type of the node. See FileNode::Type

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getFirstTopLevelNode(...)

getFirstTopLevelNode() -> retval
   @brief Returns the first element of the top-level mapping.
   @returns The first element of the top-level mapping.

getFormat(...)

getFormat() -> retval
   @brief Returns the current format.
   * @returns The current format, see FileStorage::Mode

getNode(...)

getNode(nodename) -> retval
   @overload

isOpened(...)

isOpened() -> retval
   @brief Checks whether the file is opened.
   
   @returns true if the object is associated with the current file and false otherwise. It is a
   good practice to call this method after you tried to open a file.

open(...)

open(filename, flags[, encoding]) -> retval
   @brief Opens a file.
   
   See description of parameters in FileStorage::FileStorage. The method calls FileStorage::release
   before opening the file.
   @param filename Name of the file to open or the text string to read the data from.
   Extension of the file (.xml, .yml/.yaml or .json) determines its format (XML, YAML or JSON
   respectively). Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both
   FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify
   the output file format (e.g. mydata.xml, .yml etc.). A file name can also contain parameters.
   You can use this format, "*?base64" (e.g. "file.json?base64" (case sensitive)), as an alternative to
   FileStorage::BASE64 flag.
   @param flags Mode of operation. One of FileStorage::Mode
   @param encoding Encoding of the file. Note that UTF-16 XML encoding is not supported currently and
   you should use 8-bit encoding instead of it.

release(...)

release() -> None
   @brief Closes the file and releases all the memory buffers.
   
   Call this method after all I/O operations with the storage are finished.

releaseAndGetString(...)

releaseAndGetString() -> retval
   @brief Closes the file and releases all the memory buffers.
   
   Call this method after all I/O operations with the storage are finished. If the storage was
   opened for writing data and FileStorage::WRITE was specified

root(...)

root([, streamidx]) -> retval
   @brief Returns the top-level mapping
   @param streamidx Zero-based index of the stream. In most cases there is only one stream in the file.
   However, YAML supports multiple streams and so there can be several.
   @returns The top-level mapping.

write(...)

write(name, val) -> None
   * @brief Simplified writing API to use with bindings.
   * @param name Name of the written object
   * @param val Value of the written object

writeComment(...)

writeComment(comment[, append]) -> None
   @brief Writes a comment.
   
   The function writes a comment into file storage. The comments are skipped when the storage is read.
   @param comment The written comment, single-line or multi-line
   @param append If true, the function tries to put the comment at the end of current line.
   Else if the comment is multi-line, or if it does not fit at the end of the current
   line, the comment starts a new line.

Method resolution order:

FlannBasedMatcher

DescriptorMatcher

Algorithm

builtins.object

---

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create() -> retval

---

Methods inherited from DescriptorMatcher:

add(...)

add(descriptors) -> None
   @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor
   collection.
   
   If the collection is not empty, the new descriptors are added to existing train descriptors.
   
   @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same
   train image.

clear(...)

clear() -> None
   @brief Clears the train descriptor collections.

clone(...)

clone([, emptyTrainData]) -> retval
   @brief Clones the matcher.
   
   @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,
   that is, copies both parameters and train data. If emptyTrainData is true, the method creates an
   object copy with the current parameters but with empty train data.

empty(...)

empty() -> retval
   @brief Returns true if there are no train descriptors in the both collections.

getTrainDescriptors(...)

getTrainDescriptors() -> retval
   @brief Returns a constant link to the train descriptor collection trainDescCollection .

isMaskSupported(...)

isMaskSupported() -> retval
   @brief Returns true if the descriptor matcher supports masking permissible matches.

knnMatch(...)

knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches
   @brief Finds the k best matches for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   
   These extended variants of DescriptorMatcher::match methods find several best matches for each query
   descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match
   for the details about query and train descriptors.
 
 
 
knnMatch(queryDescriptors, k[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.
   @param k Count of best matches found per each query descriptor or less if a query descriptor has
   less than k possible matches in total.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

match(...)

match(queryDescriptors, trainDescriptors[, mask]) -> matches
   @brief Finds the best match for each descriptor from a query set.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   In the first variant of this method, the train descriptors are passed as an input argument. In the
   second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is
   used. Optional mask (or masks) can be passed to specify which query and training descriptors can be
   matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if
   mask.at\<uchar\>(i,j) is non-zero.
 
 
 
match(queryDescriptors[, masks]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Matches. If a query descriptor is masked out in mask , no match is added for this
   descriptor. So, matches size may be smaller than the query descriptors count.
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].

radiusMatch(...)

radiusMatch(queryDescriptors, trainDescriptors, maxDistance[, mask[, compactResult]]) -> matches
   @brief For each query descriptor, finds the training descriptors not farther than the specified distance.
   
   @param queryDescriptors Query set of descriptors.
   @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors
   collection stored in the class object.
   @param matches Found matches.
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param mask Mask specifying permissible matches between an input query and train matrices of
   descriptors.
   
   For each query descriptor, the methods find such training descriptors that the distance between the
   query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are
   returned in the distance increasing order.
 
 
 
radiusMatch(queryDescriptors, maxDistance[, masks[, compactResult]]) -> matches
   @overload
   @param queryDescriptors Query set of descriptors.
   @param matches Found matches.
   @param maxDistance Threshold for the distance between matched descriptors. Distance means here
   metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured
   in Pixels)!
   @param masks Set of masks. Each masks[i] specifies permissible matches between the input query
   descriptors and stored train descriptors from the i-th image trainDescCollection[i].
   @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is
   false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,
   the matches vector does not contain matches for fully masked-out query descriptors.

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

train(...)

train() -> None
   @brief Trains a descriptor matcher
   
   Trains a descriptor matcher (for example, the flann index). In all methods to match, the method
   train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)
   have an empty implementation of this method. Other matchers really train their inner structures (for
   example, FlannBasedMatcher trains flann::Index ).

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Method resolution order:

GFTTDetector

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, maxCorners[, qualityLevel[, minDistance[, blockSize[, useHarrisDetector[, k]]]]]]) -> retval
   
 
 
 
create(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize[, useHarrisDetector[, k]]) -> retval

getBlockSize(...)

getBlockSize() -> retval

getDefaultName(...)

getDefaultName() -> retval

getHarrisDetector(...)

getHarrisDetector() -> retval

getK(...)

getK() -> retval

getMaxFeatures(...)

getMaxFeatures() -> retval

getMinDistance(...)

getMinDistance() -> retval

getQualityLevel(...)

getQualityLevel() -> retval

setBlockSize(...)

setBlockSize(blockSize) -> None

setHarrisDetector(...)

setHarrisDetector(val) -> None

setK(...)

setK(k) -> None

setMaxFeatures(...)

setMaxFeatures(maxFeatures) -> None

setMinDistance(...)

setMinDistance(minDistance) -> None

setQualityLevel(...)

setQualityLevel(qlevel) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

checkDetectorSize(...)

checkDetectorSize() -> retval
   @brief Checks if detector size equal to descriptor size.

compute(...)

compute(img[, winStride[, padding[, locations]]]) -> descriptors
   @brief Computes HOG descriptors of given image.
   @param img Matrix of the type CV_8U containing an image where HOG features will be calculated.
   @param descriptors Matrix of the type CV_32F
   @param winStride Window stride. It must be a multiple of block stride.
   @param padding Padding
   @param locations Vector of Point

computeGradient(...)

computeGradient(img[, grad[, angleOfs[, paddingTL[, paddingBR]]]]) -> grad, angleOfs
   @brief  Computes gradients and quantized gradient orientations.
   @param img Matrix contains the image to be computed
   @param grad Matrix of type CV_32FC2 contains computed gradients
   @param angleOfs Matrix of type CV_8UC2 contains quantized gradient orientations
   @param paddingTL Padding from top-left
   @param paddingBR Padding from bottom-right

detect(...)

detect(img[, hitThreshold[, winStride[, padding[, searchLocations]]]]) -> foundLocations, weights
   @brief Performs object detection without a multi-scale window.
   @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
   @param foundLocations Vector of point where each point contains left-top corner point of detected object boundaries.
   @param weights Vector that will contain confidence values for each detected object.
   @param hitThreshold Threshold for the distance between features and SVM classifying plane.
   Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
   But if the free coefficient is omitted (which is allowed), you can specify it manually here.
   @param winStride Window stride. It must be a multiple of block stride.
   @param padding Padding
   @param searchLocations Vector of Point includes set of requested locations to be evaluated.

detectMultiScale(...)

detectMultiScale(img[, hitThreshold[, winStride[, padding[, scale[, finalThreshold[, useMeanshiftGrouping]]]]]]) -> foundLocations, foundWeights
   @brief Detects objects of different sizes in the input image. The detected objects are returned as a list
   of rectangles.
   @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.
   @param foundLocations Vector of rectangles where each rectangle contains the detected object.
   @param foundWeights Vector that will contain confidence values for each detected object.
   @param hitThreshold Threshold for the distance between features and SVM classifying plane.
   Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).
   But if the free coefficient is omitted (which is allowed), you can specify it manually here.
   @param winStride Window stride. It must be a multiple of block stride.
   @param padding Padding
   @param scale Coefficient of the detection window increase.
   @param finalThreshold Final threshold
   @param useMeanshiftGrouping indicates grouping algorithm

getDaimlerPeopleDetector(...) from builtins.type

getDaimlerPeopleDetector() -> retval
   @brief Returns coefficients of the classifier trained for people detection (for 48x96 windows).

getDefaultPeopleDetector(...) from builtins.type

getDefaultPeopleDetector() -> retval
   @brief Returns coefficients of the classifier trained for people detection (for 64x128 windows).

getDescriptorSize(...)

getDescriptorSize() -> retval
   @brief Returns the number of coefficients required for the classification.

getWinSigma(...)

getWinSigma() -> retval
   @brief Returns winSigma value

load(...)

load(filename[, objname]) -> retval
   @brief loads coefficients for the linear SVM classifier from a file
   @param filename Name of the file to read.
   @param objname The optional name of the node to read (if empty, the first top-level node will be used).

save(...)

save(filename[, objname]) -> None
   @brief saves coefficients for the linear SVM classifier to a file
   @param filename File name
   @param objname Object name

setSVMDetector(...)

setSVMDetector(_svmdetector) -> None
   @brief Sets coefficients for the linear SVM classifier.
   @param _svmdetector coefficients for the linear SVM classifier.

---

Data descriptors defined here:

L2HysThreshold

L2HysThreshold

blockSize

blockSize

blockStride

blockStride

cellSize

cellSize

derivAperture

derivAperture

gammaCorrection

gammaCorrection

histogramNormType

histogramNormType

nbins

nbins

nlevels

nlevels

signedGradient

signedGradient

svmDetector

svmDetector

winSigma

winSigma

winSize

winSize

Method resolution order:

HausdorffDistanceExtractor

ShapeDistanceExtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

getDistanceFlag(...)

getDistanceFlag() -> retval

getRankProportion(...)

getRankProportion() -> retval

setDistanceFlag(...)

setDistanceFlag(distanceFlag) -> None
   @brief Set the norm used to compute the Hausdorff value between two shapes. It can be L1 or L2 norm.
   
   @param distanceFlag Flag indicating which norm is used to compute the Hausdorff distance
   (NORM_L1, NORM_L2).

setRankProportion(...)

setRankProportion(rankProportion) -> None
   @brief This method sets the rank proportion (or fractional value) that establish the Kth ranked value of
   the partial Hausdorff distance. Experimentally had been shown that 0.6 is a good value to compare
   shapes.
   
   @param rankProportion fractional value (between 0 and 1).

---

Methods inherited from ShapeDistanceExtractor:

computeDistance(...)

computeDistance(contour1, contour2) -> retval
   @brief Compute the shape distance between two shapes defined by its contours.
   
   @param contour1 Contour defining first shape.
   @param contour2 Contour defining second shape.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

HistogramCostExtractor

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

buildCostMatrix(...)

buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix

getDefaultCost(...)

getDefaultCost() -> retval

getNDummies(...)

getNDummies() -> retval

setDefaultCost(...)

setDefaultCost(defaultCost) -> None

setNDummies(...)

setNDummies(nDummies) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

KAZE

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, extended[, upright[, threshold[, nOctaves[, nOctaveLayers[, diffusivity]]]]]]) -> retval
   @brief The KAZE constructor
   
   @param extended Set to enable extraction of extended (128-byte) descriptor.
   @param upright Set to enable use of upright descriptors (non rotation-invariant).
   @param threshold Detector response threshold to accept point
   @param nOctaves Maximum octave evolution of the image
   @param nOctaveLayers Default number of sublevels per scale level
   @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or
   DIFF_CHARBONNIER

getDefaultName(...)

getDefaultName() -> retval

getDiffusivity(...)

getDiffusivity() -> retval

getExtended(...)

getExtended() -> retval

getNOctaveLayers(...)

getNOctaveLayers() -> retval

getNOctaves(...)

getNOctaves() -> retval

getThreshold(...)

getThreshold() -> retval

getUpright(...)

getUpright() -> retval

setDiffusivity(...)

setDiffusivity(diff) -> None

setExtended(...)

setExtended(extended) -> None

setNOctaveLayers(...)

setNOctaveLayers(octaveLayers) -> None

setNOctaves(...)

setNOctaves(octaves) -> None

setThreshold(...)

setThreshold(threshold) -> None

setUpright(...)

setUpright(upright) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

correct(...)

correct(measurement) -> retval
   @brief Updates the predicted state from the measurement.
   
   @param measurement The measured system parameters

predict(...)

predict([, control]) -> retval
   @brief Computes a predicted state.
   
   @param control The optional input control

---

Data descriptors defined here:

controlMatrix

controlMatrix

errorCovPost

errorCovPost

errorCovPre

errorCovPre

gain

gain

measurementMatrix

measurementMatrix

measurementNoiseCov

measurementNoiseCov

processNoiseCov

processNoiseCov

statePost

statePost

statePre

statePre

transitionMatrix

transitionMatrix

Methods defined here:

__init__(self, /, *args, **kwargs)

Initialize self.  See help(type(self)) for accurate signature.

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

convert(...) from builtins.type

convert(keypoints[, keypointIndexes]) -> points2f
   This method converts vector of keypoints to vector of points or the reverse, where each keypoint is
   assigned the same size and the same orientation.
   
   @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
   @param points2f Array of (x,y) coordinates of each keypoint
   @param keypointIndexes Array of indexes of keypoints to be converted to points. (Acts like a mask to
   convert only specified keypoints)
 
 
 
convert(points2f[, size[, response[, octave[, class_id]]]]) -> keypoints
   @overload
   @param points2f Array of (x,y) coordinates of each keypoint
   @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
   @param size keypoint diameter
   @param response keypoint detector response on the keypoint (that is, strength of the keypoint)
   @param octave pyramid octave in which the keypoint has been detected
   @param class_id object id

overlap(...) from builtins.type

overlap(kp1, kp2) -> retval
   This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint
   regions' intersection and area of keypoint regions' union (considering keypoint region as circle).
   If they don't overlap, we get zero. If they coincide at same location with same size, we get 1.
   @param kp1 First keypoint
   @param kp2 Second keypoint

---

Data descriptors defined here:

angle

angle

class_id

class_id

octave

octave

pt

pt

response

response

size

size

Method resolution order:

LineSegmentDetector

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

compareSegments(...)

compareSegments(size, lines1, lines2[, _image]) -> retval, _image
   @brief Draws two groups of lines in blue and red, counting the non overlapping (mismatching) pixels.
   
   @param size The size of the image, where lines1 and lines2 were found.
   @param lines1 The first group of lines that needs to be drawn. It is visualized in blue color.
   @param lines2 The second group of lines. They visualized in red color.
   @param _image Optional image, where the lines will be drawn. The image should be color(3-channel)
   in order for lines1 and lines2 to be drawn in the above mentioned colors.

detect(...)

detect(_image[, _lines[, width[, prec[, nfa]]]]) -> _lines, width, prec, nfa
   @brief Finds lines in the input image.
   
   This is the output of the default parameters of the algorithm on the above shown image.
   
   
   
   @param _image A grayscale (CV_8UC1) input image. If only a roi needs to be selected, use:
   `lsd_ptr-\>detect(image(roi), lines, ...); lines += Scalar(roi.x, roi.y, roi.x, roi.y);`
   @param _lines A vector of Vec4i or Vec4f elements specifying the beginning and ending point of a line. Where
   Vec4i/Vec4f is (x1, y1, x2, y2), point 1 is the start, point 2 - end. Returned lines are strictly
   oriented depending on the gradient.
   @param width Vector of widths of the regions, where the lines are found. E.g. Width of line.
   @param prec Vector of precisions with which the lines are found.
   @param nfa Vector containing number of false alarms in the line region, with precision of 10%. The
   bigger the value, logarithmically better the detection.
   - -1 corresponds to 10 mean false alarms
   - 0 corresponds to 1 mean false alarm
   - 1 corresponds to 0.1 mean false alarms
   This vector will be calculated only when the objects type is #LSD_REFINE_ADV.

drawSegments(...)

drawSegments(_image, lines) -> _image
   @brief Draws the line segments on a given image.
   @param _image The image, where the lines will be drawn. Should be bigger or equal to the image,
   where the lines were found.
   @param lines A vector of the lines that needed to be drawn.

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

empty(...)

empty() -> retval
   @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read

getDefaultName(...)

getDefaultName() -> retval
   Returns the algorithm string identifier.
   This string is used as top level xml/yml node tag when the object is saved to a file or string.

read(...)

read(fn) -> None
   @brief Reads algorithm parameters from a file storage

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).

write(...)

write(fs[, name]) -> None
   @brief simplified API for language bindings
   * @overload

Method resolution order:

MSER

Feature2D

Algorithm

builtins.object

---

Methods defined here:

__new__(*args, **kwargs) from builtins.type

Create and return a new object.  See help(type) for accurate signature.

__repr__(self, /)

Return repr(self).

create(...) from builtins.type

create([, _delta[, _min_area[, _max_area[, _max_variation[, _min_diversity[, _max_evolution[, _area_threshold[, _min_margin[, _edge_blur_size]]]]]]]]]) -> retval
   @brief Full consturctor for %MSER detector
   
   @param _delta it compares \f$(size_{i}-size_{i-delta})/size_{i-delta}\f$
   @param _min_area prune the area which smaller than minArea
   @param _max_area prune the area which bigger than maxArea
   @param _max_variation prune the area have similar size to its children
   @param _min_diversity for color image, trace back to cut off mser with diversity less than min_diversity
   @param _max_evolution  for color image, the evolution steps
   @param _area_threshold for color image, the area threshold to cause re-initialize
   @param _min_margin for color image, ignore too small margin
   @param _edge_blur_size for color image, the aperture size for edge blur

detectRegions(...)

detectRegions(image) -> msers, bboxes
   @brief Detect %MSER regions
   
   @param image input image (8UC1, 8UC3 or 8UC4, must be greater or equal than 3x3)
   @param msers resulting list of point sets
   @param bboxes resulting bounding boxes

getDefaultName(...)

getDefaultName() -> retval

getDelta(...)

getDelta() -> retval

getMaxArea(...)

getMaxArea() -> retval

getMinArea(...)

getMinArea() -> retval

getPass2Only(...)

getPass2Only() -> retval

setDelta(...)

setDelta(delta) -> None

setMaxArea(...)

setMaxArea(maxArea) -> None

setMinArea(...)

setMinArea(minArea) -> None

setPass2Only(...)

setPass2Only(f) -> None

---

Methods inherited from Feature2D:

compute(...)

compute(image, keypoints[, descriptors]) -> keypoints, descriptors
   @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set
   (second variant).
   
   @param image Image.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.
 
 
 
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
   @overload
   
   @param images Image set.
   @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be
   computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint
   with several dominant orientations (for each orientation).
   @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are
   descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the
   descriptor for keypoint j-th keypoint.

defaultNorm(...)

defaultNorm() -> retval

descriptorSize(...)

descriptorSize() -> retval

descriptorType(...)

descriptorType() -> retval

detect(...)

detect(image[, mask]) -> keypoints
   @brief Detects keypoints in an image (first variant) or image set (second variant).
   
   @param image Image.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer
   matrix with non-zero values in the region of interest.
 
 
 
detect(images[, masks]) -> keypoints
   @overload
   @param images Image set.
   @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set
   of keypoints detected in images[i] .
   @param masks Masks for each input image specifying where to look for keypoints (optional).
   masks[i] is a mask for images[i].

detectAndCompute(...)

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
   Detects keypoints and computes the descriptors

empty(...)

empty() -> retval

read(...)

read(fileName) -> None
   
 
 
 
read(arg1) -> None

write(...)

write(fileName) -> None
   
 
 
 
write(fs[, name]) -> None

---

Methods inherited from Algorithm:

clear(...)

clear() -> None
   @brief Clears the algorithm state

save(...)

save(filename) -> None
   Saves the algorithm to a file.
   In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs).