View Source Evision.SIFT (Evision v0.1.11)
Link to this section Summary
Types
Type that represents an Evision.SIFT
struct.
Functions
Variant 1:
Positional Arguments
images:
[Evision.Mat]
.
Variant 1:
Positional Arguments
images:
[Evision.Mat]
.
Keyword Arguments
nfeatures:
int
.
Keyword Arguments
nfeatures:
int
.
Create SIFT with specified descriptorType.
Return
- retval:
int
Python prototype (for reference):
Return
- retval:
int
Python prototype (for reference):
Return
- retval:
int
Python prototype (for reference):
Variant 1:
Positional Arguments
images:
[Evision.Mat]
.
Variant 1:
Positional Arguments
images:
[Evision.Mat]
.
Positional Arguments
- image:
Evision.Mat
- mask:
Evision.Mat
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat
.
Detects keypoints and computes the descriptors
Positional Arguments
- image:
Evision.Mat
- mask:
Evision.Mat
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat
.
Detects keypoints and computes the descriptors
Return
- retval:
bool
Python prototype (for reference):
Link to this section Types
@type t() :: %Evision.SIFT{ref: reference()}
Type that represents an Evision.SIFT
struct.
ref.
reference()
The underlying erlang resource variable.
Link to this section 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:
Positional Arguments
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):
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
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
.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):
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:
Positional Arguments
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):
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
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
.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):
compute(image, keypoints[, descriptors]) -> keypoints, descriptors
Keyword Arguments
nfeatures:
int
.The number of best features to retain. The features are ranked by their scores (measured in SIFT algorithm as the local contrast)
nOctaveLayers:
int
.The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution.
contrastThreshold:
double
.The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
edgeThreshold:
double
.The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).
sigma:
double
.The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.
Return
- retval:
Evision.SIFT
Note: The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set this argument to 0.09.
Python prototype (for reference):
create([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma]]]]]) -> retval
Keyword Arguments
nfeatures:
int
.The number of best features to retain. The features are ranked by their scores (measured in SIFT algorithm as the local contrast)
nOctaveLayers:
int
.The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution.
contrastThreshold:
double
.The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
edgeThreshold:
double
.The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).
sigma:
double
.The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.
Return
- retval:
Evision.SIFT
Note: The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set this argument to 0.09.
Python prototype (for reference):
create([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma]]]]]) -> retval
create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType)
View Source@spec create(integer(), integer(), number(), number(), number(), integer()) :: t() | {:error, String.t()}
Create SIFT with specified descriptorType.
Positional Arguments
nfeatures:
int
.The number of best features to retain. The features are ranked by their scores (measured in SIFT algorithm as the local contrast)
nOctaveLayers:
int
.The number of layers in each octave. 3 is the value used in D. Lowe paper. The number of octaves is computed automatically from the image resolution.
contrastThreshold:
double
.The contrast threshold used to filter out weak features in semi-uniform (low-contrast) regions. The larger the threshold, the less features are produced by the detector.
edgeThreshold:
double
.The threshold used to filter out edge-like features. Note that the its meaning is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are filtered out (more features are retained).
sigma:
double
.The sigma of the Gaussian applied to the input image at the octave #0. If your image is captured with a weak camera with soft lenses, you might want to reduce the number.
descriptorType:
int
.The type of descriptors. Only CV_32F and CV_8U are supported.
Return
- retval:
Evision.SIFT
Note: The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set this argument to 0.09.
Python prototype (for reference):
create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType) -> retval
Return
- retval:
int
Python prototype (for reference):
defaultNorm() -> retval
Return
- retval:
int
Python prototype (for reference):
descriptorSize() -> retval
Return
- retval:
int
Python prototype (for reference):
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:
Positional Arguments
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):
detect(images[, masks]) -> keypoints
Variant 2:
Detects keypoints in an image (first variant) or image set (second variant).
Positional Arguments
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):
detect(image[, mask]) -> keypoints
@spec detect(t(), [Evision.Mat.maybe_mat_in()], [{atom(), term()}, ...] | nil) :: [[Evision.KeyPoint.t()]] | {:error, String.t()}
@spec detect(t(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil) :: [Evision.KeyPoint.t()] | {:error, String.t()}
Variant 1:
Positional Arguments
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):
detect(images[, masks]) -> keypoints
Variant 2:
Detects keypoints in an image (first variant) or image set (second variant).
Positional Arguments
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):
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()}
Positional Arguments
- image:
Evision.Mat
- mask:
Evision.Mat
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat
.
Detects keypoints and computes the descriptors
Python prototype (for reference):
detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
@spec detectAndCompute( t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in(), [{atom(), term()}, ...] | nil ) :: {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
Positional Arguments
- image:
Evision.Mat
- mask:
Evision.Mat
Keyword Arguments
- useProvidedKeypoints:
bool
.
Return
- keypoints:
[Evision.KeyPoint]
- descriptors:
Evision.Mat
.
Detects keypoints and computes the descriptors
Python prototype (for reference):
detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
Return
- retval:
bool
Python prototype (for reference):
empty() -> retval
Return
- retval:
String
Python prototype (for reference):
getDefaultName() -> retval
@spec read(t(), Evision.FileNode.t()) :: :ok | {:error, String.t()}
@spec read(t(), binary()) :: :ok | {:error, String.t()}
Variant 1:
Positional Arguments
- arg1:
Evision.FileNode
Python prototype (for reference):
read(arg1) -> None
Variant 2:
Positional Arguments
- fileName:
String
Python prototype (for reference):
read(fileName) -> None
@spec write(t(), Evision.FileStorage.t()) :: :ok | {:error, String.t()}
@spec write(t(), binary()) :: :ok | {:error, String.t()}
Variant 1:
Positional Arguments
Keyword Arguments
- name:
String
.
Python prototype (for reference):
write(fs[, name]) -> None
Variant 2:
Positional Arguments
- fileName:
String
Python prototype (for reference):
write(fileName) -> None
@spec write(t(), Evision.FileStorage.t(), [{atom(), term()}, ...] | nil) :: :ok | {:error, String.t()}
Positional Arguments
Keyword Arguments
- name:
String
.
Python prototype (for reference):
write(fs[, name]) -> None