mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
461 lines
11 KiB
461 lines
11 KiB
/////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas |
|
// Digital Ltd. LLC |
|
// |
|
// All rights reserved. |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are |
|
// met: |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * Redistributions in binary form must reproduce the above |
|
// copyright notice, this list of conditions and the following disclaimer |
|
// in the documentation and/or other materials provided with the |
|
// distribution. |
|
// * Neither the name of Industrial Light & Magic nor the names of |
|
// its contributors may be used to endorse or promote products derived |
|
// from this software without specific prior written permission. |
|
// |
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
// |
|
/////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
#ifndef INCLUDED_IMATHRANDOM_H |
|
#define INCLUDED_IMATHRANDOM_H |
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Generators for uniformly distributed pseudo-random numbers and |
|
// functions that use those generators to generate numbers with |
|
// different distributions: |
|
// |
|
// class Rand32 |
|
// class Rand48 |
|
// solidSphereRand() |
|
// hollowSphereRand() |
|
// gaussRand() |
|
// gaussSphereRand() |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
// |
|
// Here is the copyright for the *rand48() functions implemented for |
|
// Windows. |
|
// |
|
|
|
// |
|
// Copyright (c) 1993 Martin Birgmeier |
|
// All rights reserved. |
|
// |
|
// You may redistribute unmodified or modified versions of this source |
|
// code provided that the above copyright notice and this and the |
|
// following conditions are retained. |
|
// |
|
// This software is provided ``as is'', and comes with no warranties |
|
// of any kind. I shall in no event be liable for anything that happens |
|
// to anyone/anything when using this software. |
|
// |
|
|
|
#include <stdlib.h> |
|
#include <math.h> |
|
|
|
namespace Imath { |
|
|
|
|
|
//----------------------------------------------- |
|
// Fast random-number generator that generates |
|
// a uniformly distributed sequence with a period |
|
// length of 2^32. |
|
//----------------------------------------------- |
|
|
|
class Rand32 |
|
{ |
|
public: |
|
|
|
//------------ |
|
// Constructor |
|
//------------ |
|
|
|
Rand32 (unsigned long int seed = 0); |
|
|
|
|
|
//-------------------------------- |
|
// Re-initialize with a given seed |
|
//-------------------------------- |
|
|
|
void init (unsigned long int seed); |
|
|
|
|
|
//---------------------------------------------------------- |
|
// Get the next value in the sequence (range: [false, true]) |
|
//---------------------------------------------------------- |
|
|
|
bool nextb (); |
|
|
|
|
|
//--------------------------------------------------------------- |
|
// Get the next value in the sequence (range: [0 ... 0xffffffff]) |
|
//--------------------------------------------------------------- |
|
|
|
unsigned long int nexti (); |
|
|
|
|
|
//------------------------------------------------------ |
|
// Get the next value in the sequence (range: [0 ... 1[) |
|
//------------------------------------------------------ |
|
|
|
float nextf (); |
|
|
|
|
|
//------------------------------------------------------------------- |
|
// Get the next value in the sequence (range [rangeMin ... rangeMax[) |
|
//------------------------------------------------------------------- |
|
|
|
float nextf (float rangeMin, float rangeMax); |
|
|
|
|
|
private: |
|
|
|
void next (); |
|
|
|
unsigned long int _state; |
|
}; |
|
|
|
|
|
//-------------------------------------------------------- |
|
// Random-number generator based on the C Standard Library |
|
// functions drand48(), lrand48() & company; generates a |
|
// uniformly distributed sequence. |
|
//-------------------------------------------------------- |
|
|
|
class Rand48 |
|
{ |
|
public: |
|
|
|
//------------ |
|
// Constructor |
|
//------------ |
|
|
|
Rand48 (unsigned long int seed = 0); |
|
|
|
|
|
//-------------------------------- |
|
// Re-initialize with a given seed |
|
//-------------------------------- |
|
|
|
void init (unsigned long int seed); |
|
|
|
|
|
//---------------------------------------------------------- |
|
// Get the next value in the sequence (range: [false, true]) |
|
//---------------------------------------------------------- |
|
|
|
bool nextb (); |
|
|
|
|
|
//--------------------------------------------------------------- |
|
// Get the next value in the sequence (range: [0 ... 0x7fffffff]) |
|
//--------------------------------------------------------------- |
|
|
|
long int nexti (); |
|
|
|
|
|
//------------------------------------------------------ |
|
// Get the next value in the sequence (range: [0 ... 1[) |
|
//------------------------------------------------------ |
|
|
|
double nextf (); |
|
|
|
|
|
//------------------------------------------------------------------- |
|
// Get the next value in the sequence (range [rangeMin ... rangeMax[) |
|
//------------------------------------------------------------------- |
|
|
|
double nextf (double rangeMin, double rangeMax); |
|
|
|
|
|
private: |
|
|
|
unsigned short int _state[3]; |
|
|
|
#if defined ( _WIN32 ) || defined ( _WIN64 ) || defined ( __MWERKS__ ) |
|
void shiftState(); |
|
#endif |
|
}; |
|
|
|
|
|
//------------------------------------------------------------ |
|
// Return random points uniformly distributed in a sphere with |
|
// radius 1 around the origin (distance from origin <= 1). |
|
//------------------------------------------------------------ |
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
solidSphereRand (Rand &rand); |
|
|
|
|
|
//------------------------------------------------------------- |
|
// Return random points uniformly distributed on the surface of |
|
// a sphere with radius 1 around the origin. |
|
//------------------------------------------------------------- |
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
hollowSphereRand (Rand &rand); |
|
|
|
|
|
//----------------------------------------------- |
|
// Return random numbers with a normal (Gaussian) |
|
// distribution with zero mean and unit variance. |
|
//----------------------------------------------- |
|
|
|
template <class Rand> |
|
float |
|
gaussRand (Rand &rand); |
|
|
|
|
|
//---------------------------------------------------- |
|
// Return random points whose distance from the origin |
|
// has a normal (Gaussian) distribution with zero mean |
|
// and unit variance. |
|
//---------------------------------------------------- |
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
gaussSphereRand (Rand &rand); |
|
|
|
|
|
//--------------- |
|
// Implementation |
|
//--------------- |
|
|
|
|
|
inline void |
|
Rand32::init (unsigned long int seed) |
|
{ |
|
_state = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL; |
|
} |
|
|
|
|
|
inline |
|
Rand32::Rand32 (unsigned long int seed) |
|
{ |
|
init (seed); |
|
} |
|
|
|
|
|
inline void |
|
Rand32::next () |
|
{ |
|
_state = 1664525L * _state + 1013904223L; |
|
} |
|
|
|
|
|
inline bool |
|
Rand32::nextb () |
|
{ |
|
next (); |
|
// Return the 31st (most significant) bit, by and-ing with 2 ^ 31. |
|
return !!(_state & 2147483648UL); |
|
} |
|
|
|
|
|
inline unsigned long int |
|
Rand32::nexti () |
|
{ |
|
next (); |
|
return _state & 0xffffffff; |
|
} |
|
|
|
|
|
inline float |
|
Rand32::nextf () |
|
{ |
|
next (); |
|
return ((int) (_state & 0xffffff)) * ((float) (1.0F / 0x1000000)); |
|
} |
|
|
|
|
|
inline float |
|
Rand32::nextf (float rangeMin, float rangeMax) |
|
{ |
|
return rangeMin + nextf() * (rangeMax - rangeMin); |
|
} |
|
|
|
|
|
inline void |
|
Rand48::init (unsigned long int seed) |
|
{ |
|
seed = (seed * 0xa5a573a5L) ^ 0x5a5a5a5aL; |
|
|
|
_state[0] = (unsigned short int) (seed); |
|
_state[1] = (unsigned short int) (seed >> 16); |
|
_state[2] = (unsigned short int) (seed); |
|
} |
|
|
|
|
|
inline |
|
Rand48::Rand48 (unsigned long int seed) |
|
{ |
|
init (seed); |
|
} |
|
|
|
|
|
#if defined ( _WIN32 ) || defined ( _WIN64 ) || defined ( __MWERKS__ ) |
|
|
|
inline void |
|
Rand48::shiftState() |
|
{ |
|
unsigned long accu; |
|
unsigned short temp[2]; |
|
|
|
accu = 0xe66dUL * ( unsigned long )_state[0] + 0x000bUL; |
|
|
|
temp[0] = ( unsigned short )accu; /* lower 16 bits */ |
|
accu >>= sizeof( unsigned short ) * 8; |
|
|
|
accu += 0xe66dUL * ( unsigned long )_state[1] + |
|
0xdeecUL * ( unsigned long )_state[0]; |
|
|
|
temp[1] = ( unsigned short )accu; /* middle 16 bits */ |
|
accu >>= sizeof( unsigned short ) * 8; |
|
|
|
accu += 0xe66dUL * _state[2] + |
|
0xdeecUL * _state[1] + |
|
0x0005UL * _state[0]; |
|
|
|
_state[0] = temp[0]; |
|
_state[1] = temp[1]; |
|
_state[2] = ( unsigned short )accu; |
|
} |
|
|
|
#endif |
|
|
|
inline bool |
|
Rand48::nextb () |
|
{ |
|
#if defined ( _WIN32 ) || defined ( _WIN64 ) || defined ( __MWERKS__ ) |
|
shiftState(); |
|
return ( ( long( _state[2] ) << 15 ) + ( long( _state[1] ) >> 1 ) ) & 0x1; |
|
#else |
|
return nrand48 (_state) & 1; |
|
#endif |
|
} |
|
|
|
|
|
inline long int |
|
Rand48::nexti () |
|
{ |
|
#if defined ( _WIN32 ) || defined ( _WIN64 ) || defined ( __MWERKS__ ) |
|
shiftState(); |
|
return ( long( _state[2] ) << 15 ) + ( long( _state[1] ) >> 1 ); |
|
#else |
|
return nrand48 (_state); |
|
#endif |
|
} |
|
|
|
|
|
inline double |
|
Rand48::nextf () |
|
{ |
|
#if defined ( _WIN32 ) || defined ( _WIN64 ) || defined ( __MWERKS__ ) |
|
shiftState(); |
|
return ldexp( double( _state[0] ), -48 ) + |
|
ldexp( double( _state[1] ), -32 ) + |
|
ldexp( double( _state[2] ), -16 ); |
|
#else |
|
return erand48 (_state); |
|
#endif |
|
} |
|
|
|
|
|
inline double |
|
Rand48::nextf (double rangeMin, double rangeMax) |
|
{ |
|
return rangeMin + nextf() * (rangeMax - rangeMin); |
|
} |
|
|
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
solidSphereRand (Rand &rand) |
|
{ |
|
Vec v; |
|
|
|
do |
|
{ |
|
for (unsigned int i = 0; i < Vec::dimensions(); i++) |
|
v[i] = (typename Vec::BaseType) rand.nextf (-1, 1); |
|
} |
|
while (v.length2() > 1); |
|
|
|
return v; |
|
} |
|
|
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
hollowSphereRand (Rand &rand) |
|
{ |
|
Vec v; |
|
typename Vec::BaseType length; |
|
|
|
do |
|
{ |
|
for (unsigned int i = 0; i < Vec::dimensions(); i++) |
|
v[i] = (typename Vec::BaseType) rand.nextf (-1, 1); |
|
|
|
length = v.length(); |
|
} |
|
while (length > 1 || length == 0); |
|
|
|
return v / length; |
|
} |
|
|
|
|
|
template <class Rand> |
|
float |
|
gaussRand (Rand &rand) |
|
{ |
|
float x; // Note: to avoid numerical problems with very small |
|
float y; // numbers, we make these variables singe-precision |
|
float length2; // floats, but later we call the double-precision log() |
|
// and sqrt() functions instead of logf() and sqrtf(). |
|
do |
|
{ |
|
x = float (rand.nextf (-1, 1)); |
|
y = float (rand.nextf (-1, 1)); |
|
length2 = x * x + y * y; |
|
} |
|
while (length2 >= 1 || length2 == 0); |
|
|
|
return x * sqrt (-2 * log (length2) / length2); |
|
} |
|
|
|
|
|
template <class Vec, class Rand> |
|
Vec |
|
gaussSphereRand (Rand &rand) |
|
{ |
|
return hollowSphereRand <Vec> (rand) * gaussRand (rand); |
|
} |
|
|
|
double drand48(); |
|
long int lrand48(); |
|
|
|
} // namespace Imath |
|
|
|
#endif
|
|
|