Class VectorOfKeyPoint

Namespace

Emgu.CV.Util

Assembly

Emgu.CV.dll

Wrapped class of the C++ standard vector of KeyPoint.

public class VectorOfKeyPoint : UnmanagedVector, IAsyncDisposable, ISerializable, IInputOutputArray, IInputArrayOfArrays, IOutputArrayOfArrays, IOutputArray, IInputArray, IDisposable

Inheritance

object

MarshalByRefObject

Stream

UnmanagedVector

VectorOfKeyPoint

Implements

IAsyncDisposable

ISerializable

IInputOutputArray

IInputArrayOfArrays

IOutputArrayOfArrays

IOutputArray

IInputArray

IDisposable

Inherited Members

UnmanagedVector._ptr

UnmanagedVector.Read(byte[], int, int)

UnmanagedVector.SetLength(long)

UnmanagedVector.Seek(long, SeekOrigin)

UnmanagedVector.Write(byte[], int, int)

UnmanagedVector.Flush()

UnmanagedVector.Dispose()

UnmanagedVector.Dispose(bool)

UnmanagedVector.ReleaseManagedResources()

UnmanagedVector.Position

UnmanagedVector.CanRead

UnmanagedVector.CanWrite

UnmanagedVector.CanSeek

UnmanagedVector.Ptr

Stream.Null

Stream.CopyTo(Stream)

Stream.CopyTo(Stream, int)

Stream.CopyToAsync(Stream)

Stream.CopyToAsync(Stream, int)

Stream.CopyToAsync(Stream, CancellationToken)

Stream.CopyToAsync(Stream, int, CancellationToken)

Stream.Close()

Stream.DisposeAsync()

Stream.FlushAsync()

Stream.FlushAsync(CancellationToken)

Stream.CreateWaitHandle()

Stream.BeginRead(byte[], int, int, AsyncCallback, object)

Stream.EndRead(IAsyncResult)

Stream.ReadAsync(byte[], int, int)

Stream.ReadAsync(byte[], int, int, CancellationToken)

Stream.ReadAsync(Memory<byte>, CancellationToken)

Stream.ReadExactlyAsync(Memory<byte>, CancellationToken)

Stream.ReadExactlyAsync(byte[], int, int, CancellationToken)

Stream.ReadAtLeastAsync(Memory<byte>, int, bool, CancellationToken)

Stream.BeginWrite(byte[], int, int, AsyncCallback, object)

Stream.EndWrite(IAsyncResult)

Stream.WriteAsync(byte[], int, int)

Stream.WriteAsync(byte[], int, int, CancellationToken)

Stream.WriteAsync(ReadOnlyMemory<byte>, CancellationToken)

Stream.Read(Span<byte>)

Stream.ReadByte()

Stream.ReadExactly(Span<byte>)

Stream.ReadExactly(byte[], int, int)

Stream.ReadAtLeast(Span<byte>, int, bool)

Stream.Write(ReadOnlySpan<byte>)

Stream.WriteByte(byte)

Stream.Synchronized(Stream)

Stream.ObjectInvariant()

Stream.ValidateBufferArguments(byte[], int, int)

Stream.ValidateCopyToArguments(Stream, int)

Stream.CanTimeout

Stream.ReadTimeout

Stream.WriteTimeout

MarshalByRefObject.GetLifetimeService()

MarshalByRefObject.InitializeLifetimeService()

MarshalByRefObject.MemberwiseClone(bool)

object.GetType()

object.MemberwiseClone()

object.ToString()

object.Equals(object)

object.Equals(object, object)

object.ReferenceEquals(object, object)

object.GetHashCode()

Extension Methods

IInputArrayExtensions.ForEachDuplicateChannel(IInputArray, Action<IInputArray, int>)

IInputArrayExtensions.ForEachDuplicateChannel<TReturn>(IInputArray, Func<IInputArray, int, TReturn>)

IInputArrayExtensions.IsUmat(IInputArray)

Constructors

VectorOfKeyPoint()

Create an empty standard vector of KeyPoint

public VectorOfKeyPoint()

VectorOfKeyPoint(MKeyPoint[])

Create a standard vector of KeyPoint with the initial values

public VectorOfKeyPoint(MKeyPoint[] values)

Parameters

values MKeyPoint[]

The initial values

VectorOfKeyPoint(int)

Create a standard vector of KeyPoint of the specific size

public VectorOfKeyPoint(int size)

Parameters

size int

The size of the vector

VectorOfKeyPoint(SerializationInfo, StreamingContext)

Constructor used to deserialize runtime serialized object

public VectorOfKeyPoint(SerializationInfo info, StreamingContext context)

Parameters

info SerializationInfo

The serialization info

context StreamingContext

The streaming context

VectorOfKeyPoint(Span<MKeyPoint>)

Create a standard vector of KeyPoint with the initial values

public VectorOfKeyPoint(Span<MKeyPoint> values)

Parameters

values Span<MKeyPoint>

The initial values

Properties

this[int]

Get the item in the specific index

public MKeyPoint this[int index] { get; }

Parameters

index int

The index

Property Value

MKeyPoint

The item in the specific index

Length

The size of memory in bytes, that is needed to hold all the items in this vector

public override long Length { get; }

Property Value

long

Size

Get the size of the vector

public override int Size { get; }

Property Value

int

SizeOfItemInBytes

The size of the item in this Vector, counted as size in bytes.

public static int SizeOfItemInBytes { get; }

Property Value

int

StartAddress

The pointer to the first element on the vector. In case of an empty vector, IntPtr.Zero will be returned.

public override nint StartAddress { get; }

Property Value

nint

Methods

Clear()

Clear the vector

public void Clear()

DisposeObject()

Release the standard vector

protected override void DisposeObject()

FilterByImageBorder(Size, int)

Remove keypoints within borderPixels of an image edge.

public void FilterByImageBorder(Size imageSize, int borderSize)

Parameters

imageSize Size

Image size

borderSize int

Border size in pixel

FilterByKeypointSize(float, float)

Remove keypoints of sizes out of range.

public void FilterByKeypointSize(float minSize, float maxSize)

Parameters

minSize float

Minimum size

maxSize float

Maximum size

FilterByPixelsMask(Image<Gray, byte>)

Remove keypoints from some image by mask for pixels of this image.

public void FilterByPixelsMask(Image<Gray, byte> mask)

Parameters

mask Image<Gray, byte>

The mask

GetInputArray()

Get the data as InputArray

public InputArray GetInputArray()

Returns

InputArray

The input array

GetInputOutputArray()

Get the data as InputOutputArray

public InputOutputArray GetInputOutputArray()

Returns

InputOutputArray

The input output array

GetObjectData(SerializationInfo, StreamingContext)

A function used for runtime serialization of the object

public void GetObjectData(SerializationInfo info, StreamingContext context)

Parameters

info SerializationInfo

Serialization info

context StreamingContext

Streaming context

GetOutputArray()

Get the data as OutputArray

public OutputArray GetOutputArray()

Returns

OutputArray

The output array

GetSpan()

Returns a memory span that wraps the underlying memory buffer.

public Span<MKeyPoint> GetSpan()

Returns

Span<MKeyPoint>

A memory span that wraps the underlying memory buffer.

Push(MKeyPoint[])

Push an array of values into the standard vector

public void Push(MKeyPoint[] values)

Parameters

values MKeyPoint[]

The values to be pushed to the vector

Push(VectorOfKeyPoint)

Push multiple values from the other vector into this vector

public void Push(VectorOfKeyPoint other)

Parameters

other VectorOfKeyPoint

The other vector, from which the values will be pushed to the current vector

Push(Span<MKeyPoint>)

Push an array of values into the standard vector

public void Push(Span<MKeyPoint> values)

Parameters

values Span<MKeyPoint>

The value to be pushed to the vector

ToArray()

Convert the standard vector to an array of KeyPoint

public MKeyPoint[] ToArray()

Returns

MKeyPoint[]

An array of KeyPoint