View Source Evision.CUDA.ORB (Evision v0.1.34)
Summary
Functions
Variant 1:
compute
Variant 1:
compute
Variant 1:
Computes the descriptors for a set of keypoints detected in an image.
Variant 1:
Computes the descriptors for a set of keypoints detected in an image.
Variant 1:
convert
create
create
defaultNorm
descriptorSize
descriptorType
Variant 1:
detect
Variant 1:
detect
detectAndCompute
detectAndCompute
Variant 1:
detectAndComputeAsync
Variant 1:
detectAndComputeAsync
Variant 1:
Detects keypoints in an image.
Variant 1:
Detects keypoints in an image.
empty
getBlurForDescriptor
getDefaultName
getEdgeThreshold
getFastThreshold
getFirstLevel
getMaxFeatures
getNLevels
getPatchSize
getScaleFactor
getScoreType
getWTA_K
Variant 1:
read
setBlurForDescriptor
setEdgeThreshold
setFastThreshold
setFirstLevel
setMaxFeatures
setNLevels
setPatchSize
setScaleFactor
setScoreType
setWTA_K
write
write
Types
@type t() :: %Evision.CUDA.ORB{ref: reference()}
Type that represents an CUDA.ORB
struct.
ref.
reference()
The underlying erlang resource variable.
Functions
@spec compute(Evision.ORB.t(), [Evision.Mat.maybe_mat_in()], [[Evision.KeyPoint.t()]]) :: {[[Evision.KeyPoint.t()]], [Evision.Mat.t()]} | {:error, String.t()}
@spec compute(Evision.ORB.t(), Evision.Mat.maybe_mat_in(), [Evision.KeyPoint.t()]) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
Variant 1:
compute
Positional Arguments
self:
Evision.CUDA.ORB.t()
images:
[Evision.Mat]
.Image set.
Return
keypoints:
[[Evision.KeyPoint]]
.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).
descriptors:
[Evision.Mat]
.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.
Has overloading in C++
Python prototype (for reference only):
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
Variant 2:
Computes the descriptors for a set of keypoints detected in an image (first variant) or image set (second variant).
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Return
keypoints:
[Evision.KeyPoint]
.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).
descriptors:
Evision.Mat.t()
.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.
Python prototype (for reference only):
compute(image, keypoints[, descriptors]) -> keypoints, descriptors
@spec compute( Evision.ORB.t(), [Evision.Mat.maybe_mat_in()], [[Evision.KeyPoint.t()]], [{atom(), term()}, ...] | nil ) :: {[[Evision.KeyPoint.t()]], [Evision.Mat.t()]} | {:error, String.t()}
@spec compute( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), [Evision.KeyPoint.t()], [{atom(), term()}, ...] | nil ) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
Variant 1:
compute
Positional Arguments
self:
Evision.CUDA.ORB.t()
images:
[Evision.Mat]
.Image set.
Return
keypoints:
[[Evision.KeyPoint]]
.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).
descriptors:
[Evision.Mat]
.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.
Has overloading in C++
Python prototype (for reference only):
compute(images, keypoints[, descriptors]) -> keypoints, descriptors
Variant 2:
Computes the descriptors for a set of keypoints detected in an image (first variant) or image set (second variant).
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Return
keypoints:
[Evision.KeyPoint]
.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).
descriptors:
Evision.Mat.t()
.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.
Python prototype (for reference only):
compute(image, keypoints[, descriptors]) -> keypoints, descriptors
@spec computeAsync(Evision.ORB.t(), Evision.Mat.maybe_mat_in()) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
@spec computeAsync(Evision.ORB.t(), Evision.CUDA.GpuMat.t()) :: {Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t()} | {:error, String.t()}
Variant 1:
Computes the descriptors for a set of keypoints detected in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.Mat.t()
.Input collection of keypoints.
descriptors:
Evision.Mat.t()
.Computed descriptors. Row j is the descriptor for j-th keypoint.
Python prototype (for reference only):
computeAsync(image[, keypoints[, descriptors[, stream]]]) -> keypoints, descriptors
Variant 2:
Computes the descriptors for a set of keypoints detected in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.CUDA.GpuMat.t()
.Image.
Keyword Arguments
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.CUDA.GpuMat.t()
.Input collection of keypoints.
descriptors:
Evision.CUDA.GpuMat.t()
.Computed descriptors. Row j is the descriptor for j-th keypoint.
Python prototype (for reference only):
computeAsync(image[, keypoints[, descriptors[, stream]]]) -> keypoints, descriptors
@spec computeAsync( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
@spec computeAsync( Evision.ORB.t(), Evision.CUDA.GpuMat.t(), [{atom(), term()}, ...] | nil ) :: {Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t()} | {:error, String.t()}
Variant 1:
Computes the descriptors for a set of keypoints detected in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.Mat.t()
.Input collection of keypoints.
descriptors:
Evision.Mat.t()
.Computed descriptors. Row j is the descriptor for j-th keypoint.
Python prototype (for reference only):
computeAsync(image[, keypoints[, descriptors[, stream]]]) -> keypoints, descriptors
Variant 2:
Computes the descriptors for a set of keypoints detected in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.CUDA.GpuMat.t()
.Image.
Keyword Arguments
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.CUDA.GpuMat.t()
.Input collection of keypoints.
descriptors:
Evision.CUDA.GpuMat.t()
.Computed descriptors. Row j is the descriptor for j-th keypoint.
Python prototype (for reference only):
computeAsync(image[, keypoints[, descriptors[, stream]]]) -> keypoints, descriptors
@spec convert(Evision.ORB.t(), Evision.Mat.maybe_mat_in()) :: [Evision.KeyPoint.t()] | {:error, String.t()}
@spec convert(Evision.ORB.t(), Evision.CUDA.GpuMat.t()) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
convert
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- gpu_keypoints:
Evision.Mat.t()
Return
- keypoints:
[Evision.KeyPoint]
Converts keypoints array from internal representation to standard vector.
Python prototype (for reference only):
convert(gpu_keypoints) -> keypoints
Variant 2:
convert
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- gpu_keypoints:
Evision.CUDA.GpuMat.t()
Return
- keypoints:
[Evision.KeyPoint]
Converts keypoints array from internal representation to standard vector.
Python prototype (for reference only):
convert(gpu_keypoints) -> keypoints
create
Keyword Arguments
- nfeatures:
int
. - scaleFactor:
float
. - nlevels:
int
. - edgeThreshold:
int
. - firstLevel:
int
. - wTA_K:
int
. - scoreType:
int
. - patchSize:
int
. - fastThreshold:
int
. - blurForDescriptor:
bool
.
Return
- retval:
Evision.CUDA.ORB.t()
Python prototype (for reference only):
create([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold[, blurForDescriptor]]]]]]]]]]) -> retval
create
Keyword Arguments
- nfeatures:
int
. - scaleFactor:
float
. - nlevels:
int
. - edgeThreshold:
int
. - firstLevel:
int
. - wTA_K:
int
. - scoreType:
int
. - patchSize:
int
. - fastThreshold:
int
. - blurForDescriptor:
bool
.
Return
- retval:
Evision.CUDA.ORB.t()
Python prototype (for reference only):
create([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold[, blurForDescriptor]]]]]]]]]]) -> retval
@spec defaultNorm(Evision.ORB.t()) :: integer() | {:error, String.t()}
defaultNorm
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
defaultNorm() -> retval
@spec descriptorSize(Evision.ORB.t()) :: integer() | {:error, String.t()}
descriptorSize
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
descriptorSize() -> retval
@spec descriptorType(Evision.ORB.t()) :: integer() | {:error, String.t()}
descriptorType
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
descriptorType() -> retval
@spec detect(Evision.ORB.t(), [Evision.Mat.maybe_mat_in()]) :: [[Evision.KeyPoint.t()]] | {:error, String.t()}
@spec detect(Evision.ORB.t(), Evision.Mat.maybe_mat_in()) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
detect
Positional Arguments
self:
Evision.CUDA.ORB.t()
images:
[Evision.Mat]
.Image set.
Keyword Arguments
masks:
[Evision.Mat]
.Masks for each input image specifying where to look for keypoints (optional). masks[i] is a mask for images[i].
Return
keypoints:
[[Evision.KeyPoint]]
.The detected keypoints. In the second variant of the method keypoints[i] is a set of keypoints detected in images[i] .
Has overloading in C++
Python prototype (for reference only):
detect(images[, masks]) -> keypoints
Variant 2:
Detects keypoints in an image (first variant) or image set (second variant).
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
mask:
Evision.Mat.t()
.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.
Return
keypoints:
[Evision.KeyPoint]
.The detected keypoints. In the second variant of the method keypoints[i] is a set of keypoints detected in images[i] .
Python prototype (for reference only):
detect(image[, mask]) -> keypoints
@spec detect( Evision.ORB.t(), [Evision.Mat.maybe_mat_in()], [{atom(), term()}, ...] | nil ) :: [[Evision.KeyPoint.t()]] | {:error, String.t()}
@spec detect( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
detect
Positional Arguments
self:
Evision.CUDA.ORB.t()
images:
[Evision.Mat]
.Image set.
Keyword Arguments
masks:
[Evision.Mat]
.Masks for each input image specifying where to look for keypoints (optional). masks[i] is a mask for images[i].
Return
keypoints:
[[Evision.KeyPoint]]
.The detected keypoints. In the second variant of the method keypoints[i] is a set of keypoints detected in images[i] .
Has overloading in C++
Python prototype (for reference only):
detect(images[, masks]) -> keypoints
Variant 2:
Detects keypoints in an image (first variant) or image set (second variant).
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
mask:
Evision.Mat.t()
.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.
Return
keypoints:
[Evision.KeyPoint]
.The detected keypoints. In the second variant of the method keypoints[i] is a set of keypoints detected in images[i] .
Python prototype (for reference only):
detect(image[, mask]) -> keypoints
@spec detectAndCompute( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
detectAndCompute
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.Mat.t()
- mask:
Evision.Mat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat.t()
.
Detects keypoints and computes the descriptors
Python prototype (for reference only):
detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
@spec detectAndCompute( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
detectAndCompute
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.Mat.t()
- mask:
Evision.Mat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat.t()
.
Detects keypoints and computes the descriptors
Python prototype (for reference only):
detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
@spec detectAndComputeAsync( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in() ) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
@spec detectAndComputeAsync( Evision.ORB.t(), Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t() ) :: {Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t()} | {:error, String.t()}
Variant 1:
detectAndComputeAsync
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.Mat.t()
- mask:
Evision.Mat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
. - stream:
Evision.CUDA.Stream.t()
.
Return
- keypoints:
Evision.Mat.t()
. - descriptors:
Evision.Mat.t()
.
Detects keypoints and computes the descriptors.
Python prototype (for reference only):
detectAndComputeAsync(image, mask[, keypoints[, descriptors[, useProvidedKeypoints[, stream]]]]) -> keypoints, descriptors
Variant 2:
detectAndComputeAsync
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.CUDA.GpuMat.t()
- mask:
Evision.CUDA.GpuMat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
. - stream:
Evision.CUDA.Stream.t()
.
Return
- keypoints:
Evision.CUDA.GpuMat.t()
. - descriptors:
Evision.CUDA.GpuMat.t()
.
Detects keypoints and computes the descriptors.
Python prototype (for reference only):
detectAndComputeAsync(image, mask[, keypoints[, descriptors[, useProvidedKeypoints[, stream]]]]) -> keypoints, descriptors
@spec detectAndComputeAsync( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: {Evision.Mat.t(), Evision.Mat.t()} | {:error, String.t()}
@spec detectAndComputeAsync( Evision.ORB.t(), Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t(), [{atom(), term()}, ...] | nil ) :: {Evision.CUDA.GpuMat.t(), Evision.CUDA.GpuMat.t()} | {:error, String.t()}
Variant 1:
detectAndComputeAsync
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.Mat.t()
- mask:
Evision.Mat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
. - stream:
Evision.CUDA.Stream.t()
.
Return
- keypoints:
Evision.Mat.t()
. - descriptors:
Evision.Mat.t()
.
Detects keypoints and computes the descriptors.
Python prototype (for reference only):
detectAndComputeAsync(image, mask[, keypoints[, descriptors[, useProvidedKeypoints[, stream]]]]) -> keypoints, descriptors
Variant 2:
detectAndComputeAsync
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- image:
Evision.CUDA.GpuMat.t()
- mask:
Evision.CUDA.GpuMat.t()
Keyword Arguments
- useProvidedKeypoints:
bool
. - stream:
Evision.CUDA.Stream.t()
.
Return
- keypoints:
Evision.CUDA.GpuMat.t()
. - descriptors:
Evision.CUDA.GpuMat.t()
.
Detects keypoints and computes the descriptors.
Python prototype (for reference only):
detectAndComputeAsync(image, mask[, keypoints[, descriptors[, useProvidedKeypoints[, stream]]]]) -> keypoints, descriptors
@spec detectAsync(Evision.ORB.t(), Evision.Mat.maybe_mat_in()) :: Evision.Mat.t() | {:error, String.t()}
@spec detectAsync(Evision.ORB.t(), Evision.CUDA.GpuMat.t()) :: Evision.CUDA.GpuMat.t() | {:error, String.t()}
Variant 1:
Detects keypoints in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
mask:
Evision.Mat.t()
.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.
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.Mat.t()
.The detected keypoints.
Python prototype (for reference only):
detectAsync(image[, keypoints[, mask[, stream]]]) -> keypoints
Variant 2:
Detects keypoints in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.CUDA.GpuMat.t()
.Image.
Keyword Arguments
mask:
Evision.CUDA.GpuMat.t()
.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.
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.CUDA.GpuMat.t()
.The detected keypoints.
Python prototype (for reference only):
detectAsync(image[, keypoints[, mask[, stream]]]) -> keypoints
@spec detectAsync( Evision.ORB.t(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: Evision.Mat.t() | {:error, String.t()}
@spec detectAsync( Evision.ORB.t(), Evision.CUDA.GpuMat.t(), [{atom(), term()}, ...] | nil ) :: Evision.CUDA.GpuMat.t() | {:error, String.t()}
Variant 1:
Detects keypoints in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.Mat.t()
.Image.
Keyword Arguments
mask:
Evision.Mat.t()
.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.
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.Mat.t()
.The detected keypoints.
Python prototype (for reference only):
detectAsync(image[, keypoints[, mask[, stream]]]) -> keypoints
Variant 2:
Detects keypoints in an image.
Positional Arguments
self:
Evision.CUDA.ORB.t()
image:
Evision.CUDA.GpuMat.t()
.Image.
Keyword Arguments
mask:
Evision.CUDA.GpuMat.t()
.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.
stream:
Evision.CUDA.Stream.t()
.CUDA stream.
Return
keypoints:
Evision.CUDA.GpuMat.t()
.The detected keypoints.
Python prototype (for reference only):
detectAsync(image[, keypoints[, mask[, stream]]]) -> keypoints
@spec empty(Evision.ORB.t()) :: boolean() | {:error, String.t()}
empty
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
bool
Python prototype (for reference only):
empty() -> retval
@spec getBlurForDescriptor(Evision.ORB.t()) :: boolean() | {:error, String.t()}
getBlurForDescriptor
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
bool
Python prototype (for reference only):
getBlurForDescriptor() -> retval
@spec getDefaultName(Evision.ORB.t()) :: binary() | {:error, String.t()}
getDefaultName
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
String
Python prototype (for reference only):
getDefaultName() -> retval
@spec getEdgeThreshold(Evision.ORB.t()) :: integer() | {:error, String.t()}
getEdgeThreshold
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getEdgeThreshold() -> retval
@spec getFastThreshold(Evision.ORB.t()) :: integer() | {:error, String.t()}
getFastThreshold
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getFastThreshold() -> retval
@spec getFirstLevel(Evision.ORB.t()) :: integer() | {:error, String.t()}
getFirstLevel
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getFirstLevel() -> retval
@spec getMaxFeatures(Evision.ORB.t()) :: integer() | {:error, String.t()}
getMaxFeatures
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getMaxFeatures() -> retval
@spec getNLevels(Evision.ORB.t()) :: integer() | {:error, String.t()}
getNLevels
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getNLevels() -> retval
@spec getPatchSize(Evision.ORB.t()) :: integer() | {:error, String.t()}
getPatchSize
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getPatchSize() -> retval
@spec getScaleFactor(Evision.ORB.t()) :: number() | {:error, String.t()}
getScaleFactor
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
double
Python prototype (for reference only):
getScaleFactor() -> retval
@spec getScoreType(Evision.ORB.t()) :: integer() | {:error, String.t()}
getScoreType
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getScoreType() -> retval
@spec getWTA_K(Evision.ORB.t()) :: integer() | {:error, String.t()}
getWTA_K
Positional Arguments
- self:
Evision.CUDA.ORB.t()
Return
- retval:
int
Python prototype (for reference only):
getWTA_K() -> retval
@spec read(Evision.ORB.t(), Evision.FileNode.t()) :: Evision.ORB.t() | {:error, String.t()}
@spec read(Evision.ORB.t(), binary()) :: Evision.ORB.t() | {:error, String.t()}
Variant 1:
read
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- arg1:
Evision.FileNode.t()
Python prototype (for reference only):
read(arg1) -> None
Variant 2:
read
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- fileName:
String
Python prototype (for reference only):
read(fileName) -> None
@spec setBlurForDescriptor(Evision.ORB.t(), boolean()) :: Evision.ORB.t() | {:error, String.t()}
setBlurForDescriptor
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- blurForDescriptor:
bool
Python prototype (for reference only):
setBlurForDescriptor(blurForDescriptor) -> None
@spec setEdgeThreshold(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setEdgeThreshold
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- edgeThreshold:
int
Python prototype (for reference only):
setEdgeThreshold(edgeThreshold) -> None
@spec setFastThreshold(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setFastThreshold
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- fastThreshold:
int
Python prototype (for reference only):
setFastThreshold(fastThreshold) -> None
@spec setFirstLevel(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setFirstLevel
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- firstLevel:
int
Python prototype (for reference only):
setFirstLevel(firstLevel) -> None
@spec setMaxFeatures(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setMaxFeatures
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- maxFeatures:
int
Python prototype (for reference only):
setMaxFeatures(maxFeatures) -> None
@spec setNLevels(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setNLevels
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- nlevels:
int
Python prototype (for reference only):
setNLevels(nlevels) -> None
@spec setPatchSize(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setPatchSize
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- patchSize:
int
Python prototype (for reference only):
setPatchSize(patchSize) -> None
@spec setScaleFactor(Evision.ORB.t(), number()) :: Evision.ORB.t() | {:error, String.t()}
setScaleFactor
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- scaleFactor:
double
Python prototype (for reference only):
setScaleFactor(scaleFactor) -> None
@spec setScoreType(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setScoreType
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- scoreType:
int
Python prototype (for reference only):
setScoreType(scoreType) -> None
@spec setWTA_K(Evision.ORB.t(), integer()) :: Evision.ORB.t() | {:error, String.t()}
setWTA_K
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- wta_k:
int
Python prototype (for reference only):
setWTA_K(wta_k) -> None
@spec write(Evision.ORB.t(), binary()) :: Evision.ORB.t() | {:error, String.t()}
write
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- fileName:
String
Python prototype (for reference only):
write(fileName) -> None
@spec write(Evision.ORB.t(), Evision.FileStorage.t(), binary()) :: Evision.ORB.t() | {:error, String.t()}
write
Positional Arguments
- self:
Evision.CUDA.ORB.t()
- fs:
Evision.FileStorage.t()
- name:
String
Python prototype (for reference only):
write(fs, name) -> None