View Source Evision.SIFT (Evision v0.1.13)

Link to this section Summary

Types

t()

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.

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
Keyword Arguments
  • useProvidedKeypoints: bool.
Return

Detects keypoints and computes the descriptors

Positional Arguments
Keyword Arguments
  • useProvidedKeypoints: bool.
Return

Detects keypoints and computes the descriptors

Return
  • retval: bool

Python prototype (for reference):

Return

Python prototype (for reference):

Variant 1:

Positional Arguments

Python prototype (for reference):

Variant 1:

Positional Arguments
Keyword Arguments

Python prototype (for reference):

Positional Arguments
Keyword Arguments

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

Link to this function

compute(self, images, keypoints)

View Source
@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
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
Link to this function

compute(self, images, keypoints, opts)

View Source
@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
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 create() :: t() | {:error, String.t()}
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

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
@spec create([{atom(), term()}, ...] | nil) :: t() | {:error, String.t()}
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

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
Link to this function

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

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
@spec defaultNorm(t()) :: integer() | {:error, String.t()}
Return
  • retval: int

Python prototype (for reference):

defaultNorm() -> retval
@spec descriptorSize(t()) :: integer() | {:error, String.t()}
Return
  • retval: int

Python prototype (for reference):

descriptorSize() -> retval
@spec descriptorType(t()) :: integer() | {:error, String.t()}
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
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
Link to this function

detect(self, images, opts)

View Source
@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
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
Link to this function

detectAndCompute(self, image, mask)

View Source
@spec detectAndCompute(t(), Evision.Mat.maybe_mat_in(), Evision.Mat.maybe_mat_in()) ::
  {[Evision.KeyPoint.t()], Evision.Mat.t()} | {:error, String.t()}
Positional Arguments
Keyword Arguments
  • useProvidedKeypoints: bool.
Return

Detects keypoints and computes the descriptors

Python prototype (for reference):

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
Link to this function

detectAndCompute(self, image, mask, opts)

View Source
@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
Keyword Arguments
  • useProvidedKeypoints: bool.
Return

Detects keypoints and computes the descriptors

Python prototype (for reference):

detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors
@spec empty(t()) :: boolean() | {:error, String.t()}
Return
  • retval: bool

Python prototype (for reference):

empty() -> retval
@spec getDefaultName(t()) :: binary() | {:error, String.t()}
Return

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

Python prototype (for reference):

read(arg1) -> None

Variant 2:

Positional Arguments

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

Python prototype (for reference):

write(fs[, name]) -> None

Variant 2:

Positional Arguments

Python prototype (for reference):

write(fileName) -> None
@spec write(t(), Evision.FileStorage.t(), [{atom(), term()}, ...] | nil) ::
  :ok | {:error, String.t()}
Positional Arguments
Keyword Arguments

Python prototype (for reference):

write(fs[, name]) -> None