org.bytedeco.openpose

Class FloatArray

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.openpose.FloatArray

All Implemented Interfaces:

AutoCloseable

@Name(value="op::Array<float>")
 @NoOffset
 @Properties(inherit=openpose.class)
public class FloatArray
extends Pointer

Array: The OpenPose Basic Raw Data Container This template class implements a multidimensional data array. It is our basic data container, analogous to Mat in OpenCV, Tensor in Torch/TensorFlow or Blob in Caffe. It wraps a Matrix and a std::shared_ptr, both of them pointing to the same raw data. I.e. they both share the same memory, so we can read and modify this data in both formats with no performance impact. Hence, it keeps high performance while adding high-level functions.

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
FloatArray()
FloatArray(FloatArray array) Copy constructor.
FloatArray(FloatArray array, int index)
FloatArray(FloatArray array, int index, boolean noCopy) Array constructor.
FloatArray(int size) Array constructor.
FloatArray(int[] sizes)
FloatArray(int[] sizes, float value)
FloatArray(int[] sizes, float[] dataPtr)
FloatArray(IntBuffer sizes)
FloatArray(IntBuffer sizes, float value)
FloatArray(IntBuffer sizes, FloatBuffer dataPtr)
FloatArray(int size, float value) Array constructor.
FloatArray(int size, float[] dataPtr)
FloatArray(int size, FloatBuffer dataPtr)
FloatArray(int size, FloatPointer dataPtr) Array constructor.
FloatArray(IntPointer sizes) Array constructor.
FloatArray(IntPointer sizes, float value) Array constructor.
FloatArray(IntPointer sizes, FloatPointer dataPtr) Array constructor.
FloatArray(Pointer p) Pointer cast constructor.

Method Summary

Modifier and Type	Method and Description
FloatPointer	at(int index) at() function Same functionality as operator[](const int index), but it always check whether the indexes are within the data bounds.
float[]	at(int[] indexes)
FloatBuffer	at(IntBuffer indexes)
FloatPointer	at(IntPointer indexes) at() function Same functionality as operator[](const std::vector& indexes), but it always check whether the indexes are within the data bounds.
FloatArray	clone() Clone function.
boolean	empty() Check whether memory has been allocated.
FloatPointer	get(int index) [] operator Similar to the [] operator for raw pointer data.
float[]	get(int[] indexes)
FloatBuffer	get(IntBuffer indexes)
FloatPointer	get(IntPointer indexes) [] operator Same functionality as operator[](const int index), but it lets the user introduce the multi-dimensional index.
Matrix	getConstCvMat() Return a Matrix wrapper to the data.
FloatPointer	getConstPtr() Similar to getPtr(), but it forbids the data to be edited.
Matrix	getCvMat() Analogous to getConstCvMat, but in this case it returns a editable Matrix.
long	getNumberDimensions() Return the total number of dimensions, equivalent to getSize().size().
FloatPointer	getPseudoConstPtr() Similar to getConstPtr(), but it allows the data to be edited.
FloatPointer	getPtr() Return a raw pointer to the data.
IntPointer	getSize() Return a vector with the size of each dimension allocated.
int	getSize(int index) Return a vector with the size of the desired dimension.
IntPointer	getStride() Return the stride or step size of the array.
int	getStride(int index) Return the stride or step size of the array at the index-th dimension.
long	getVolume() Return the total number of elements allocated, equivalent to multiply all the components from getSize().
long	getVolume(int indexA)
long	getVolume(int indexA, int indexB) Similar to getVolume(), but in this case it just returns the volume between the desired dimensions.
BytePointer	printSize() Return a string with the size of each dimension allocated.
FloatArray	put(FloatArray array) Copy assignment.
void	reset()
void	reset(int size) Data allocation function.
void	reset(int[] sizes)
void	reset(int[] sizes, float value)
void	reset(int[] sizes, float[] dataPtr)
void	reset(IntBuffer sizes)
void	reset(IntBuffer sizes, float value)
void	reset(IntBuffer sizes, FloatBuffer dataPtr)
void	reset(int size, float value) Data allocation function.
void	reset(int size, float[] dataPtr)
void	reset(int size, FloatBuffer dataPtr)
void	reset(int size, FloatPointer dataPtr) Data allocation function.
void	reset(IntPointer sizes) Data allocation function.
void	reset(IntPointer sizes, float value) Data allocation function.
void	reset(IntPointer sizes, FloatPointer dataPtr) Data allocation function.
void	setFrom(Matrix cvMat) Data allocation function.
void	setTo(float value) Data allocation function.

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, getPointer, getPointer, getPointer, getPointer, hashCode, interruptDeallocatorThread, isNull, isNull, limit, limit, malloc, maxBytes, maxPhysicalBytes, memchr, memcmp, memcpy, memmove, memset, offsetAddress, offsetof, offsetof, parseBytes, physicalBytes, position, position, put, realloc, referenceCount, releaseReference, retainReference, setNull, sizeof, sizeof, toString, totalBytes, totalCount, totalPhysicalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

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

Constructor Detail

FloatArray

public FloatArray(Pointer p)

Pointer cast constructor. Invokes Pointer(Pointer).

FloatArray

public FloatArray(int size)

Array constructor. Equivalent to default constructor + reset(const int size).

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

FloatArray

public FloatArray(@StdVector
                  IntPointer sizes)

Array constructor. Equivalent to default constructor + reset(const std::vector& size = {}).

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to new T[3*5*2].

FloatArray

public FloatArray()

FloatArray

public FloatArray(@StdVector
                  IntBuffer sizes)

FloatArray

public FloatArray(@StdVector
                  int[] sizes)

FloatArray

public FloatArray(int size,
                  float value)

Array constructor. Equivalent to default constructor + reset(const int size, const T value).

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

value - Initial value for each component of the Array.

FloatArray

public FloatArray(@StdVector
                  IntPointer sizes,
                  float value)

Array constructor. Equivalent to default constructor + reset(const std::vector& size, const T value).

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to: new T[3*5*2].

value - Initial value for each component of the Array.

FloatArray

public FloatArray(@StdVector
                  IntBuffer sizes,
                  float value)

FloatArray

public FloatArray(@StdVector
                  int[] sizes,
                  float value)

FloatArray

public FloatArray(int size,
                  FloatPointer dataPtr)

Array constructor. Equivalent to default constructor, but it does not allocate memory, but rather use dataPtr.

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

dataPtr - Pointer to the memory to be used by the Array.

FloatArray

public FloatArray(int size,
                  FloatBuffer dataPtr)

FloatArray

public FloatArray(int size,
                  float[] dataPtr)

FloatArray

public FloatArray(@StdVector
                  IntPointer sizes,
                  FloatPointer dataPtr)

Array constructor. Equivalent to default constructor, but it does not allocate memory, but rather use dataPtr.

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to: new T[3*5*2].

dataPtr - Pointer to the memory to be used by the Array.

FloatArray

public FloatArray(@StdVector
                  IntBuffer sizes,
                  FloatBuffer dataPtr)

FloatArray

public FloatArray(@StdVector
                  int[] sizes,
                  float[] dataPtr)

FloatArray

public FloatArray(@Const @ByRef
                  FloatArray array,
                  int index,
                  @Cast(value="const bool")
                  boolean noCopy)

Array constructor.

Parameters:

array - Array with the original data array to slice.

index - indicates the index of the array to extract.

noCopy - indicates whether to perform a copy. Copy will never go to undefined behavior, however, if noCopy == true, then: 1. It is faster, as no data copy is involved, but... 2. If the Array array goes out of scope, then the resulting Array will provoke an undefined behavior. 3. If the returned Array is modified, the information in the Array array will also be.

FloatArray

public FloatArray(@Const @ByRef
                  FloatArray array,
                  int index)

FloatArray

public FloatArray(@Const @ByRef
                  FloatArray array)

Copy constructor. It performs fast copy: For performance purpose, copying a Array or Datum or cv::Mat just copies the reference, it still shares the same internal data. Modifying the copied element will modify the original one. Use clone() for a slower but real copy, similarly to cv::Mat and Array.

Parameters:

array - Array to be copied.

Method Detail

put

@ByRef
 @Name(value="operator =")
public FloatArray put(@Const @ByRef
                                                        FloatArray array)

Copy assignment. Similar to Array(const Array& array).

Parameters:

array - Array to be copied.

Returns:

The resulting Array.

clone

@ByVal
public FloatArray clone()

Clone function. Similar to cv::Mat::clone and Datum::clone. It performs a real but slow copy of the data, i.e., even if the copied element is modified, the original one is not.

Overrides:

clone in class Object

Returns:

The resulting Array.

reset

public void reset(int size)

Data allocation function. It allocates the required space for the memory (it does not initialize that memory).

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

reset

public void reset(@StdVector
                  IntPointer sizes)

Data allocation function. Similar to reset(const int size), but it allocates a multi-dimensional array of dimensions each of the values of the argument.

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to new T[3*5*2].

reset

public void reset()

reset

public void reset(@StdVector
                  IntBuffer sizes)

reset

public void reset(@StdVector
                  int[] sizes)

reset

public void reset(int size,
                  float value)

Data allocation function. Similar to reset(const int size), but initializing the data to the value specified by the second argument.

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

value - Initial value for each component of the Array.

reset

public void reset(@StdVector
                  IntPointer sizes,
                  float value)

Data allocation function. Similar to reset(const std::vector& size), but initializing the data to the value specified by the second argument.

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to new T[3*5*2].

value - Initial value for each component of the Array.

reset

public void reset(@StdVector
                  IntBuffer sizes,
                  float value)

reset

public void reset(@StdVector
                  int[] sizes,
                  float value)

reset

public void reset(int size,
                  FloatPointer dataPtr)

Data allocation function. Equivalent to default constructor, but it does not allocate memory, but rather use dataPtr.

Parameters:

size - Integer with the number of T element to be allocated. E.g., size = 5 is internally similar to new T[5].

dataPtr - Pointer to the memory to be used by the Array.

reset

public void reset(int size,
                  FloatBuffer dataPtr)

reset

public void reset(int size,
                  float[] dataPtr)

reset

public void reset(@StdVector
                  IntPointer sizes,
                  FloatPointer dataPtr)

Data allocation function. Equivalent to default constructor, but it does not allocate memory, but rather use dataPtr.

Parameters:

sizes - Vector with the size of each dimension. E.g., size = {3, 5, 2} is internally similar to: new T[3*5*2].

dataPtr - Pointer to the memory to be used by the Array.

reset

public void reset(@StdVector
                  IntBuffer sizes,
                  FloatBuffer dataPtr)

reset

public void reset(@StdVector
                  int[] sizes,
                  float[] dataPtr)

setFrom

public void setFrom(@Const @ByRef
                    Matrix cvMat)

Data allocation function. It internally allocates memory and copies the data of the argument to the Array allocated memory.

Parameters:

cvMat - Matrix to be copied.

setTo

public void setTo(float value)

Data allocation function. It internally assigns all the allocated memory to the value indicated by the argument.

Parameters:

value - Value for each component of the Array.

empty

@Cast(value="bool")
public boolean empty()

Check whether memory has been allocated.

Returns:

True if no memory has been allocated, false otherwise.

getSize

@StdVector
public IntPointer getSize()

Return a vector with the size of each dimension allocated.

Returns:

A std::vector with the size of each dimension. If no memory has been allocated, it will return an empty std::vector.

getSize

public int getSize(int index)

Return a vector with the size of the desired dimension.

Parameters:

index - Dimension to check its size.

Returns:

Size of the desired dimension. It will return 0 if the requested dimension is higher than the number of dimensions.

printSize

@StdString
public BytePointer printSize()

Return a string with the size of each dimension allocated.

Returns:

A std::stringwith the size of each dimension. If no memory has been allocated, it will return an empty string.

getNumberDimensions

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

Return the total number of dimensions, equivalent to getSize().size().

Returns:

The number of dimensions. If no memory is allocated, it returns 0.

getVolume

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

Return the total number of elements allocated, equivalent to multiply all the components from getSize(). E.g., for a Array of size = {2,5,3}, the volume or total number of elements is: 2x5x3 = 30.

Returns:

The total volume of the allocated data. If no memory is allocated, it returns 0.

getVolume

@Cast(value="size_t")
public long getVolume(int indexA,
                                            int indexB)

Similar to getVolume(), but in this case it just returns the volume between the desired dimensions. E.g., for a Array of size = {2,5,3}, the volume or total number of elements for getVolume(1,2) is 5x3 = 15.

Parameters:

indexA - Dimension where to start.

indexB - Dimension where to stop. If indexB == -1, then it will take up to the last dimension.

Returns:

The total volume of the allocated data between the desired dimensions. If the index are out of bounds, it throws an error.

getVolume

@Cast(value="size_t")
public long getVolume(int indexA)

getStride

@StdVector
public IntPointer getStride()

Return the stride or step size of the array. E.g., given and Array of size 5x3, getStride() would return the following vector: {5x3sizeof(T), 3sizeof(T), sizeof(T)}.

getStride

public int getStride(int index)

Return the stride or step size of the array at the index-th dimension. E.g., given and Array of size 5x3, getStride(2) would return sizeof(T).

getPtr

public FloatPointer getPtr()

Return a raw pointer to the data. Similar to: std::shared_ptr::get(). Note: if you modify the pointer data, you will directly modify it in the Array instance too. If you know you do not want to modify the data, then use getConstPtr() instead.

Returns:

A raw pointer to the data.

getConstPtr

@Const
public FloatPointer getConstPtr()

Similar to getPtr(), but it forbids the data to be edited.

Returns:

A raw const pointer to the data.

getPseudoConstPtr

public FloatPointer getPseudoConstPtr()

Similar to getConstPtr(), but it allows the data to be edited. This function is only implemented for Pybind11 usage.

Returns:

A raw pointer to the data.

getConstCvMat

@Const
 @ByRef
public Matrix getConstCvMat()

Return a Matrix wrapper to the data. It forbids the data to be modified. OpenCV only admits unsigned char, signed char, int, float & double. If the T class is not supported by OpenCV, it will throw an error. Note: Array does not return an editable Matrix because some OpenCV functions reallocate memory and it would not longer point to the Array instance. If you want to perform some OpenCV operation on the Array data, you can use: editedCvMat = array.getConstCvMat().clone(); // modify data array.setFrom(editedCvMat)

Returns:

A const Matrix pointing to the data.

getCvMat

@ByRef
public Matrix getCvMat()

Analogous to getConstCvMat, but in this case it returns a editable Matrix. Very important: Only allowed functions which do not provoke data reallocation. E.g., resizing functions will not work and they would provoke an undefined behavior and/or execution crashes.

Returns:

A Matrix pointing to the data.

get

@ByRef
 @Name(value="operator []")
public FloatPointer get(int index)

[] operator Similar to the [] operator for raw pointer data. If debug mode is enabled, then it will check that the desired index is in the data range, and it will throw an exception otherwise (similar to the at operator).

Parameters:

index - The desired memory location.

Returns:

A editable reference to the data on the desired index location.

get

@ByRef
 @Name(value="operator []")
public FloatPointer get(@StdVector
                                                           IntPointer indexes)

[] operator Same functionality as operator[](const int index), but it lets the user introduce the multi-dimensional index. E.g., given a (10 x 10 x 10) array, array[11] is equivalent to array[{1,1,0}]

Parameters:

indexes - Vector with the desired memory location.

Returns:

A editable reference to the data on the desired index location.

get

@ByRef
 @Name(value="operator []")
public FloatBuffer get(@StdVector
                                                          IntBuffer indexes)

get

@ByRef
 @Name(value="operator []")
public float[] get(@StdVector
                                                      int[] indexes)

at

@ByRef
public FloatPointer at(int index)

at() function Same functionality as operator[](const int index), but it always check whether the indexes are within the data bounds. Otherwise, it will throw an error.

Parameters:

index - The desired memory location.

Returns:

A editable reference to the data on the desired index location.

at

@ByRef
public FloatPointer at(@StdVector
                              IntPointer indexes)

at() function Same functionality as operator[](const std::vector& indexes), but it always check whether the indexes are within the data bounds. Otherwise, it will throw an error.

Parameters:

indexes - Vector with the desired memory location.

Returns:

A editable reference to the data on the desired index location.

at

@ByRef
public FloatBuffer at(@StdVector
                             IntBuffer indexes)

at

@ByRef
public float[] at(@StdVector
                         int[] indexes)