View Source Evision.AKAZE (Evision v0.2.9)
Summary
Functions
Variant 1:
compute
Variant 1:
compute
The AKAZE constructor
The AKAZE constructor
defaultNorm
descriptorSize
descriptorType
Variant 1:
detect
Variant 1:
detect
detectAndCompute
detectAndCompute
empty
getDefaultName
getDescriptorChannels
getDescriptorSize
getDescriptorType
getDiffusivity
getMaxPoints
getNOctaveLayers
getNOctaves
getThreshold
Variant 1:
read
setDescriptorChannels
setDescriptorSize
setDescriptorType
setDiffusivity
setMaxPoints
setNOctaveLayers
setNOctaves
setThreshold
write
write
Types
@type t() :: %Evision.AKAZE{ref: reference()}
Type that represents an AKAZE
struct.
ref.
reference()
The underlying erlang resource variable.
Functions
@spec compute(t(), [Evision.Mat.maybe_mat_in()], [[Evision.KeyPoint.t()]]) :: {[[Evision.KeyPoint.t()]], [Evision.Mat.t()]} | {:error, String.t()}
@spec compute(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.AKAZE.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.AKAZE.t()
image:
Evision.Mat
.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( t(), [Evision.Mat.maybe_mat_in()], [[Evision.KeyPoint.t()]], [{atom(), term()}, ...] | nil ) :: {[[Evision.KeyPoint.t()]], [Evision.Mat.t()]} | {:error, String.t()}
@spec compute( 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.AKAZE.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.AKAZE.t()
image:
Evision.Mat
.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
The AKAZE constructor
Keyword Arguments
descriptor_type:
AKAZE_DescriptorType
.Type of the extracted descriptor: DESCRIPTOR_KAZE, DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.
descriptor_size:
integer()
.Size of the descriptor in bits. 0 -> Full size
descriptor_channels:
integer()
.Number of channels in the descriptor (1, 2, 3)
threshold:
float
.Detector response threshold to accept point
nOctaves:
integer()
.Maximum octave evolution of the image
nOctaveLayers:
integer()
.Default number of sublevels per scale level
diffusivity:
KAZE_DiffusivityType
.Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or DIFF_CHARBONNIER
max_points:
integer()
.Maximum amount of returned points. In case if image contains more features, then the features with highest response are returned. Negative value means no limitation.
Return
- retval:
Evision.AKAZE.t()
Python prototype (for reference only):
create([, descriptor_type[, descriptor_size[, descriptor_channels[, threshold[, nOctaves[, nOctaveLayers[, diffusivity[, max_points]]]]]]]]) -> retval
@spec create(Keyword.t()) :: any() | {:error, String.t()}
@spec create( [ descriptor_channels: term(), descriptor_size: term(), descriptor_type: term(), diffusivity: term(), max_points: term(), nOctaveLayers: term(), nOctaves: term(), threshold: term() ] | nil ) :: t() | {:error, String.t()}
The AKAZE constructor
Keyword Arguments
descriptor_type:
AKAZE_DescriptorType
.Type of the extracted descriptor: DESCRIPTOR_KAZE, DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.
descriptor_size:
integer()
.Size of the descriptor in bits. 0 -> Full size
descriptor_channels:
integer()
.Number of channels in the descriptor (1, 2, 3)
threshold:
float
.Detector response threshold to accept point
nOctaves:
integer()
.Maximum octave evolution of the image
nOctaveLayers:
integer()
.Default number of sublevels per scale level
diffusivity:
KAZE_DiffusivityType
.Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or DIFF_CHARBONNIER
max_points:
integer()
.Maximum amount of returned points. In case if image contains more features, then the features with highest response are returned. Negative value means no limitation.
Return
- retval:
Evision.AKAZE.t()
Python prototype (for reference only):
create([, descriptor_type[, descriptor_size[, descriptor_channels[, threshold[, nOctaves[, nOctaveLayers[, diffusivity[, max_points]]]]]]]]) -> retval
@spec defaultNorm(Keyword.t()) :: any() | {:error, String.t()}
@spec defaultNorm(t()) :: integer() | {:error, String.t()}
defaultNorm
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
defaultNorm() -> retval
@spec descriptorSize(Keyword.t()) :: any() | {:error, String.t()}
@spec descriptorSize(t()) :: integer() | {:error, String.t()}
descriptorSize
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
descriptorSize() -> retval
@spec descriptorType(Keyword.t()) :: any() | {:error, String.t()}
@spec descriptorType(t()) :: integer() | {:error, String.t()}
descriptorType
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
descriptorType() -> retval
@spec detect(t(), [Evision.Mat.maybe_mat_in()]) :: [[Evision.KeyPoint.t()]] | {:error, String.t()}
@spec detect(t(), Evision.Mat.maybe_mat_in()) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
detect
Positional Arguments
self:
Evision.AKAZE.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.AKAZE.t()
image:
Evision.Mat
.Image.
Keyword Arguments
mask:
Evision.Mat
.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(t(), [Evision.Mat.maybe_mat_in()], [{:masks, term()}] | nil) :: [[Evision.KeyPoint.t()]] | {:error, String.t()}
@spec detect(t(), Evision.Mat.maybe_mat_in(), [{:mask, term()}] | nil) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
detect
Positional Arguments
self:
Evision.AKAZE.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.AKAZE.t()
image:
Evision.Mat
.Image.
Keyword Arguments
mask:
Evision.Mat
.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(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.AKAZE.t()
- image:
Evision.Mat
- mask:
Evision.Mat
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( t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{:useProvidedKeypoints, term()}] | nil ) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
detectAndCompute
Positional Arguments
- self:
Evision.AKAZE.t()
- image:
Evision.Mat
- mask:
Evision.Mat
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 empty(Keyword.t()) :: any() | {:error, String.t()}
@spec empty(t()) :: boolean() | {:error, String.t()}
empty
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
bool
Python prototype (for reference only):
empty() -> retval
@spec getDefaultName(Keyword.t()) :: any() | {:error, String.t()}
@spec getDefaultName(t()) :: binary() | {:error, String.t()}
getDefaultName
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
String
Python prototype (for reference only):
getDefaultName() -> retval
@spec getDescriptorChannels(Keyword.t()) :: any() | {:error, String.t()}
@spec getDescriptorChannels(t()) :: integer() | {:error, String.t()}
getDescriptorChannels
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
getDescriptorChannels() -> retval
@spec getDescriptorSize(Keyword.t()) :: any() | {:error, String.t()}
@spec getDescriptorSize(t()) :: integer() | {:error, String.t()}
getDescriptorSize
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
getDescriptorSize() -> retval
@spec getDescriptorType(Keyword.t()) :: any() | {:error, String.t()}
@spec getDescriptorType(t()) :: Evision.AKAZE.DescriptorType.enum() | {:error, String.t()}
getDescriptorType
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
AKAZE::DescriptorType
Python prototype (for reference only):
getDescriptorType() -> retval
@spec getDiffusivity(Keyword.t()) :: any() | {:error, String.t()}
@spec getDiffusivity(t()) :: Evision.KAZE.DiffusivityType.enum() | {:error, String.t()}
getDiffusivity
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
KAZE::DiffusivityType
Python prototype (for reference only):
getDiffusivity() -> retval
@spec getMaxPoints(Keyword.t()) :: any() | {:error, String.t()}
@spec getMaxPoints(t()) :: integer() | {:error, String.t()}
getMaxPoints
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
getMaxPoints() -> retval
@spec getNOctaveLayers(Keyword.t()) :: any() | {:error, String.t()}
@spec getNOctaveLayers(t()) :: integer() | {:error, String.t()}
getNOctaveLayers
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
getNOctaveLayers() -> retval
@spec getNOctaves(Keyword.t()) :: any() | {:error, String.t()}
@spec getNOctaves(t()) :: integer() | {:error, String.t()}
getNOctaves
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
integer()
Python prototype (for reference only):
getNOctaves() -> retval
@spec getThreshold(Keyword.t()) :: any() | {:error, String.t()}
@spec getThreshold(t()) :: number() | {:error, String.t()}
getThreshold
Positional Arguments
- self:
Evision.AKAZE.t()
Return
- retval:
double
Python prototype (for reference only):
getThreshold() -> retval
@spec read(t(), Evision.FileNode.t()) :: t() | {:error, String.t()}
@spec read(t(), binary()) :: t() | {:error, String.t()}
Variant 1:
read
Positional Arguments
- self:
Evision.AKAZE.t()
- arg1:
Evision.FileNode
Python prototype (for reference only):
read(arg1) -> None
Variant 2:
read
Positional Arguments
- self:
Evision.AKAZE.t()
- fileName:
String
Python prototype (for reference only):
read(fileName) -> None
setDescriptorChannels
Positional Arguments
- self:
Evision.AKAZE.t()
- dch:
integer()
Python prototype (for reference only):
setDescriptorChannels(dch) -> None
setDescriptorSize
Positional Arguments
- self:
Evision.AKAZE.t()
- dsize:
integer()
Python prototype (for reference only):
setDescriptorSize(dsize) -> None
@spec setDescriptorType(t(), Evision.AKAZE.DescriptorType.enum()) :: t() | {:error, String.t()}
setDescriptorType
Positional Arguments
- self:
Evision.AKAZE.t()
- dtype:
AKAZE_DescriptorType
Python prototype (for reference only):
setDescriptorType(dtype) -> None
@spec setDiffusivity(t(), Evision.KAZE.DiffusivityType.enum()) :: t() | {:error, String.t()}
setDiffusivity
Positional Arguments
- self:
Evision.AKAZE.t()
- diff:
KAZE_DiffusivityType
Python prototype (for reference only):
setDiffusivity(diff) -> None
setMaxPoints
Positional Arguments
- self:
Evision.AKAZE.t()
- max_points:
integer()
Python prototype (for reference only):
setMaxPoints(max_points) -> None
setNOctaveLayers
Positional Arguments
- self:
Evision.AKAZE.t()
- octaveLayers:
integer()
Python prototype (for reference only):
setNOctaveLayers(octaveLayers) -> None
setNOctaves
Positional Arguments
- self:
Evision.AKAZE.t()
- octaves:
integer()
Python prototype (for reference only):
setNOctaves(octaves) -> None
setThreshold
Positional Arguments
- self:
Evision.AKAZE.t()
- threshold:
double
Python prototype (for reference only):
setThreshold(threshold) -> None
write
Positional Arguments
- self:
Evision.AKAZE.t()
- fileName:
String
Python prototype (for reference only):
write(fileName) -> None
@spec write(t(), Evision.FileStorage.t(), binary()) :: t() | {:error, String.t()}
write
Positional Arguments
- self:
Evision.AKAZE.t()
- fs:
Evision.FileStorage
- name:
String
Python prototype (for reference only):
write(fs, name) -> None