org.bytedeco.opencv.opencv_core

Class KeyPoint

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.opencv.opencv_core.KeyPoint

All Implemented Interfaces:

AutoCloseable

Direct Known Subclasses:

Elliptic_KeyPoint

@Namespace(value="cv")
 @NoOffset
 @Properties(inherit=opencv_core.class)
public class KeyPoint
extends Pointer

\brief Data structure for salient point detectors.

The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint detectors, such as Harris corner detector, #FAST, %StarDetector, %SURF, %SIFT etc.

The keypoint is characterized by the 2D position, scale (proportional to the diameter of the neighborhood that needs to be taken into account), orientation and some other parameters. The keypoint neighborhood is then analyzed by another algorithm that builds a descriptor (usually represented as a feature vector). The keypoints representing the same object in different images can then be matched using %KDTree or another method.

Nested Class Summary

Nested classes/interfaces inherited from class org.bytedeco.javacpp.Pointer

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator, Pointer.ReferenceCounter

Field Summary

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
KeyPoint() the default constructor
KeyPoint(float x, float y, float _size)
KeyPoint(float x, float y, float _size, float _angle, float _response, int _octave, int _class_id)
KeyPoint(long size) Native array allocator.
KeyPoint(Point2f _pt, float _size)
KeyPoint(Point2f _pt, float _size, float _angle, float _response, int _octave, int _class_id)
KeyPoint(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
float	angle() computed orientation of the keypoint (-1 if not applicable); it's in [0,360) degrees and measured relative to image coordinate system, ie in clockwise.
KeyPoint	angle(float setter)
int	class_id() object class (if the keypoints need to be clustered by an object they belong to)
KeyPoint	class_id(int setter)
static void	convert(KeyPointVector keypoints, Point2fVector points2f)
static void	convert(KeyPointVector keypoints, Point2fVector points2f, int[] keypointIndexes)
static void	convert(KeyPointVector keypoints, Point2fVector points2f, IntBuffer keypointIndexes)
static void	convert(KeyPointVector keypoints, Point2fVector points2f, IntPointer keypointIndexes) 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.
static void	convert(Point2fVector points2f, KeyPointVector keypoints)
static void	convert(Point2fVector points2f, KeyPointVector keypoints, float size, float response, int octave, int class_id) \overload
long	hash()
int	octave() octave (pyramid layer) from which the keypoint has been extracted
KeyPoint	octave(int setter)
static float	overlap(KeyPoint kp1, KeyPoint kp2) This method computes overlap for pair of keypoints.
KeyPoint	position(long position)
Point2f	pt() coordinates of the keypoints
KeyPoint	pt(Point2f setter)
float	response() the response by which the most strong keypoints have been selected.
KeyPoint	response(float setter)
float	size() diameter of the meaningful keypoint neighborhood
KeyPoint	size(float setter)

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, availablePhysicalBytes, calloc, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, formatBytes, free, hashCode, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, parseBytes, physicalBytes, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, toString, totalBytes, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

KeyPoint

public KeyPoint(Pointer p)

Pointer cast constructor. Invokes Pointer.Pointer(Pointer).

KeyPoint

public KeyPoint(long size)

Native array allocator. Access with Pointer.position(long).

KeyPoint

public KeyPoint()

the default constructor

KeyPoint

public KeyPoint(@ByVal
                Point2f _pt,
                float _size,
                float _angle,
                float _response,
                int _octave,
                int _class_id)

Parameters:

_pt - x & y coordinates of the keypoint

_size - keypoint diameter

_angle - keypoint orientation

_response - keypoint detector response on the keypoint (that is, strength of the keypoint)

_octave - pyramid octave in which the keypoint has been detected

_class_id - object id

KeyPoint

public KeyPoint(@ByVal
                Point2f _pt,
                float _size)

KeyPoint

public KeyPoint(float x,
                float y,
                float _size,
                float _angle,
                float _response,
                int _octave,
                int _class_id)

Parameters:

x - x-coordinate of the keypoint

y - y-coordinate of the keypoint

_size - keypoint diameter

_angle - keypoint orientation

_response - keypoint detector response on the keypoint (that is, strength of the keypoint)

_octave - pyramid octave in which the keypoint has been detected

_class_id - object id

KeyPoint

public KeyPoint(float x,
                float y,
                float _size)

Method Detail

position

public KeyPoint position(long position)

Overrides:

position in class Pointer

hash

@Cast(value="size_t")
public long hash()

convert

public static void convert(@Const @ByRef
                           KeyPointVector keypoints,
                           @ByRef
                           Point2fVector points2f,
                           @StdVector
                           IntPointer keypointIndexes)

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.

Parameters:

keypoints - Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB

points2f - Array of (x,y) coordinates of each keypoint

keypointIndexes - Array of indexes of keypoints to be converted to points. (Acts like a mask to convert only specified keypoints)

convert

public static void convert(@Const @ByRef
                           KeyPointVector keypoints,
                           @ByRef
                           Point2fVector points2f)

convert

public static void convert(@Const @ByRef
                           KeyPointVector keypoints,
                           @ByRef
                           Point2fVector points2f,
                           @StdVector
                           IntBuffer keypointIndexes)

convert

public static void convert(@Const @ByRef
                           KeyPointVector keypoints,
                           @ByRef
                           Point2fVector points2f,
                           @StdVector
                           int[] keypointIndexes)

convert

public static void convert(@Const @ByRef
                           Point2fVector points2f,
                           @ByRef
                           KeyPointVector keypoints,
                           float size,
                           float response,
                           int octave,
                           int class_id)

\overload

Parameters:

points2f - Array of (x,y) coordinates of each keypoint

keypoints - Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB

size - keypoint diameter

response - keypoint detector response on the keypoint (that is, strength of the keypoint)

octave - pyramid octave in which the keypoint has been detected

class_id - object id

convert

public static void convert(@Const @ByRef
                           Point2fVector points2f,
                           @ByRef
                           KeyPointVector keypoints)

overlap

public static float overlap(@Const @ByRef
                            KeyPoint kp1,
                            @Const @ByRef
                            KeyPoint kp2)

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.

Parameters:

kp1 - First keypoint

kp2 - Second keypoint

pt

@ByRef
public Point2f pt()

coordinates of the keypoints

pt

public KeyPoint pt(Point2f setter)

size

public float size()

diameter of the meaningful keypoint neighborhood

size

public KeyPoint size(float setter)

angle

public float angle()

computed orientation of the keypoint (-1 if not applicable); it's in [0,360) degrees and measured relative to image coordinate system, ie in clockwise.

angle

public KeyPoint angle(float setter)

response

public float response()

the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling

response

public KeyPoint response(float setter)

octave

public int octave()

octave (pyramid layer) from which the keypoint has been extracted

octave

public KeyPoint octave(int setter)

class_id

public int class_id()

object class (if the keypoints need to be clustered by an object they belong to)

class_id

public KeyPoint class_id(int setter)