org.bytedeco.javacpp

Class opencv_core.RNG

java.lang.Object

org.bytedeco.javacpp.Pointer

org.bytedeco.javacpp.opencv_core.RNG

All Implemented Interfaces:

AutoCloseable

Enclosing class:

opencv_core

@Namespace(value="cv")
@NoOffset
public static class opencv_core.RNG
extends Pointer

\brief Random Number Generator

Random number generator. It encapsulates the state (currently, a 64-bit integer) and has methods to return scalar random values and to fill arrays with random values. Currently it supports uniform and Gaussian (normal) distributions. The generator uses Multiply-With-Carry algorithm, introduced by G. Marsaglia ( ). Gaussian-distribution random numbers are generated using the Ziggurat algorithm ( ), introduced by G. Marsaglia and W. W. Tsang.

Nested Class Summary

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

Pointer.CustomDeallocator, Pointer.Deallocator, Pointer.NativeDeallocator

Field Summary

Fields

Modifier and Type	Field and Description
static int	NORMAL enum cv::RNG::
static int	UNIFORM enum cv::RNG::

Fields inherited from class org.bytedeco.javacpp.Pointer

address, capacity, limit, position

Constructor Summary

Constructors

Constructor and Description
opencv_core.RNG() \brief constructor
opencv_core.RNG(int state) \overload
opencv_core.RNG(long size) Native array allocator.
opencv_core.RNG(Pointer p) Pointer cast constructor.

Method Summary

Methods

Modifier and Type	Method and Description
void	_fill(opencv_core.Mat mat, int distType, opencv_core.Mat a, opencv_core.Mat b)
void	_fill(opencv_core.Mat mat, int distType, opencv_core.Mat a, opencv_core.Mat b, boolean saturateRange) \brief Fills arrays with random numbers.
int	apply() \brief returns a random integer sampled uniformly from [0, N).
int	apply(int N) \overload
byte	asByte() Each of the methods updates the state using the MWC algorithm and returns the next random number of the specified type.
double	asDouble() \overload
float	asFloat() \overload
int	asInt() \overload
short	asShort() \overload
double	gaussian(double sigma) \brief Returns the next random number sampled from the Gaussian distribution
int	next() The method updates the state using the MWC algorithm and returns the next 32-bit random number.
opencv_core.RNG	position(long position)
int	state()
opencv_core.RNG	state(int state)
double	uniform(double a, double b) \overload
float	uniform(float a, float b) \overload
int	uniform(int a, int b) \brief returns uniformly distributed integer random number from [a,b) range

Methods inherited from class org.bytedeco.javacpp.Pointer

address, asBuffer, asByteBuffer, capacity, capacity, close, deallocate, deallocate, deallocateReferences, deallocator, deallocator, equals, fill, hashCode, isNull, limit, limit, maxBytes, memchr, memcmp, memcpy, memmove, memset, offsetof, position, put, setNull, sizeof, toString, totalBytes, withDeallocator, zero

Methods inherited from class java.lang.Object

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

Field Detail

UNIFORM

public static final int UNIFORM

enum cv::RNG::

See Also:

Constant Field Values

NORMAL

public static final int NORMAL

enum cv::RNG::

See Also:

Constant Field Values

Constructor Detail

opencv_core.RNG

public opencv_core.RNG(Pointer p)

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

opencv_core.RNG

public opencv_core.RNG(long size)

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

opencv_core.RNG

public opencv_core.RNG()

\brief constructor

These are the RNG constructors. The first form sets the state to some pre-defined value, equal to 2\*\*32-1 in the current implementation. The second form sets the state to the specified value. If you passed state=0 , the constructor uses the above default value instead to avoid the singular random number sequence, consisting of all zeros.

opencv_core.RNG

public opencv_core.RNG(@Cast(value="uint64")
               int state)

\overload

Parameters:

state - 64-bit value used to initialize the RNG.

Method Detail

position

public opencv_core.RNG position(long position)

Overrides:

position in class Pointer

next

@Cast(value="unsigned")
public int next()

The method updates the state using the MWC algorithm and returns the next 32-bit random number.

asByte

@Name(value="operator uchar")
public byte asByte()

Each of the methods updates the state using the MWC algorithm and returns the next random number of the specified type. In case of integer types, the returned number is from the available value range for the specified type. In case of floating-point types, the returned value is from [0,1) range.

asShort

@Name(value="operator ushort")
public short asShort()

\overload

asInt

@Name(value="operator unsigned")
public int asInt()

\overload

asFloat

@Name(value="operator float")
public float asFloat()

\overload

asDouble

@Name(value="operator double")
public double asDouble()

\overload

apply

@Cast(value="unsigned")
@Name(value="operator ()")
public int apply()

\brief returns a random integer sampled uniformly from [0, N).

The methods transform the state using the MWC algorithm and return the next random number. The first form is equivalent to RNG::next . The second form returns the random number modulo N , which means that the result is in the range [0, N) .

apply

@Cast(value="unsigned")
@Name(value="operator ()")
public int apply(@Cast(value="unsigned")
                            int N)

\overload

Parameters:

N - upper non-inclusive boundary of the returned random number.

uniform

public int uniform(int a,
          int b)

\brief returns uniformly distributed integer random number from [a,b) range

The methods transform the state using the MWC algorithm and return the next uniformly-distributed random number of the specified type, deduced from the input parameter type, from the range [a, b) . There is a nuance illustrated by the following sample:

{.cpp}
    RNG rng;

    // always produces 0
    double a = rng.uniform(0, 1);

    // produces double from [0, 1)
    double a1 = rng.uniform((double)0, (double)1);

    // produces float from [0, 1)
    double b = rng.uniform(0.f, 1.f);

    // produces double from [0, 1)
    double c = rng.uniform(0., 1.);

    // may cause compiler error because of ambiguity:
    //  RNG::uniform(0, (int)0.999999)? or RNG::uniform((double)0, 0.99999)?
    double d = rng.uniform(0, 0.999999);
    

The compiler does not take into account the type of the variable to which you assign the result of RNG::uniform . The only thing that matters to the compiler is the type of a and b parameters. So, if you want a floating-point random number, but the range boundaries are integer numbers, either put dots in the end, if they are constants, or use explicit type cast operators, as in the a1 initialization above.

Parameters:

a - lower inclusive boundary of the returned random numbers.

b - upper non-inclusive boundary of the returned random numbers.

uniform

public float uniform(float a,
            float b)

\overload

uniform

public double uniform(double a,
             double b)

\overload

_fill

@Name(value="fill")
public void _fill(@ByVal
                   opencv_core.Mat mat,
                   int distType,
                   @ByVal
                   opencv_core.Mat a,
                   @ByVal
                   opencv_core.Mat b,
                   @Cast(value="bool")
                   boolean saturateRange)

\brief Fills arrays with random numbers.

Parameters:

mat - 2D or N-dimensional matrix; currently matrices with more than 4 channels are not supported by the methods, use Mat::reshape as a possible workaround.

distType - distribution type, RNG::UNIFORM or RNG::NORMAL.

a - first distribution parameter; in case of the uniform distribution, this is an inclusive lower boundary, in case of the normal distribution, this is a mean value.

b - second distribution parameter; in case of the uniform distribution, this is a non-inclusive upper boundary, in case of the normal distribution, this is a standard deviation (diagonal of the standard deviation matrix or the full standard deviation matrix).

saturateRange - pre-saturation flag; for uniform distribution only; if true, the method will first convert a and b to the acceptable value range (according to the mat datatype) and then will generate uniformly distributed random numbers within the range [saturate(a), saturate(b)), if saturateRange=false, the method will generate uniformly distributed random numbers in the original range [a, b) and then will saturate them, it means, for example, that theRNG().fill(mat_8u, RNG::UNIFORM, -DBL_MAX, DBL_MAX) will likely produce array mostly filled with 0's and 255's, since the range (0, 255) is significantly smaller than [-DBL_MAX, DBL_MAX).

Each of the methods fills the matrix with the random values from the specified distribution. As the new numbers are generated, the RNG state is updated accordingly. In case of multiple-channel images, every channel is filled independently, which means that RNG cannot generate samples from the multi-dimensional Gaussian distribution with non-diagonal covariance matrix directly. To do that, the method generates samples from multi-dimensional standard Gaussian distribution with zero mean and identity covariation matrix, and then transforms them using transform to get samples from the specified Gaussian distribution.

_fill

@Name(value="fill")
public void _fill(@ByVal
                   opencv_core.Mat mat,
                   int distType,
                   @ByVal
                   opencv_core.Mat a,
                   @ByVal
                   opencv_core.Mat b)

gaussian

public double gaussian(double sigma)

\brief Returns the next random number sampled from the Gaussian distribution

Parameters:

sigma - standard deviation of the distribution.

The method transforms the state using the MWC algorithm and returns the next random number from the Gaussian distribution N(0,sigma) . That is, the mean value of the returned random numbers is zero and the standard deviation is the specified sigma .

state

@Cast(value="uint64")
public int state()

state

public opencv_core.RNG state(int state)