Eigen::Vector3d HoleFinder::getRandomPoint()
{
Q_D(HoleFinder);
// Randomly select a hole
const Hole &hole = d->getRandomHole();
// Trim the radius of the sphere by 1.5 units. If the sphere is smaller than
// 1.5 units, trim it to 0.5 units.
const double rmax = (hole.radius >= d->minDist)
? hole.radius - d->minDist : 0.5;
// Randomly select point from uniform distribution around sphere. The radius
// is chosen such that
//
// P(r) [is prop. to] Area(r) = 4*pi*r^2, or
// P(r) = N * 4*pi*r^2
//
// We want P(r) to lie between [0,1] and r to be between [0, rmax].
//
// Lower boundary conditions are trivially satisfied:
//
// P(0) = N * 4*pi*0^2 = 0
//
// Upper boundary conditions:
//
// P(rmax) = 1 = N * 4*pi*rmax^2, or
// N = 1 / (4*pi*rmax^2)
//
// So P(r) simplifies to
//
// P(r) = (1/(4*pi*r^2)) * 4*pi*r^2 = r^2 / (rmax^2)
//
// So we can pick a "p" value from a uniform distribution from [0,1] and
// transform it to a random radius that is uniformly distributed throughout
// the sphere by
const double p = RANDDOUBLE();
const double r = sqrt(p) * rmax;
// A random unit vector representing the displacement:
Eigen::Vector3d displacement (2.0 * RANDDOUBLE() - 1.0,
2.0 * RANDDOUBLE() - 1.0,
2.0 * RANDDOUBLE() - 1.0);
displacement.normalize();
// Put the two together
displacement *= r;
// Shift by the hole's origin
const Eigen::Vector3d ret (hole.center + displacement);
// Ta-da!
return ret;
}
void RANDDOUBLETest::generateImageDefault()
{
INIT_RANDOM_GENERATOR();
// Create matrix to store hits
std::vector<std::vector<unsigned int> > hits;
hits.resize(size);
for (int i = 0; i < size; i++) {
hits[i].resize(size);
for (int j = 0; j < size; j++) {
hits[i][j] = 0;
}
}
// Generate numbers
int x,y;
QBENCHMARK {
for (int i = 0; i < numPoints; i++) {
x = (int)(RANDDOUBLE() * size);
y = (int)(RANDDOUBLE() * size);
hits[x][y]++;
}
}
// Find greatest number of hits
unsigned int max = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
if (hits[i][j] > max) {
max = hits[i][j];
}
}
}
// Generate image
unsigned int normHit;
unsigned int rgb;
QImage im (size, size, QImage::Format_RGB32);
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
normHit = (hits[i][j] * 100) / max;
rgb = (normHit * 0xff) / 100;
im.setPixel(i, j,
0xff000000 +
0x00010000 * rgb +
0x00000100 * rgb +
0x00000001 * rgb );
}
}
im.save("RANDDOUBLETest-default.png", 0, 100);
}
const Hole & HoleFinderPrivate::getRandomHole()
{
Q_ASSERT(this->holeProbs.size() != 0);
double r = RANDDOUBLE();
int ind;
for (ind = 0; ind < this->holeProbs.size(); ind++)
if (r < this->holeProbs[ind]) break;
QMap<double, Hole>::const_iterator retIt = this->holeMap.constBegin();
for (int i = 0; i < ind; ++i) ++retIt;
return retIt.value();
}
void init_dna(shape_t * dna)
{
for(int i = 0; i < NUM_SHAPES; i++)
{
for(int j = 0; j < NUM_POINTS; j++)
{
dna[i].points[j].x = RANDDOUBLE(WIDTH);
dna[i].points[j].y = RANDDOUBLE(HEIGHT);
}
dna[i].r = RANDDOUBLE(1);
dna[i].g = RANDDOUBLE(1);
dna[i].b = RANDDOUBLE(1);
dna[i].a = RANDDOUBLE(1);
//dna[i].r = 0.5;
//dna[i].g = 0.5;
//dna[i].b = 0.5;
//dna[i].a = 1;
}
}
int mutate(int * mutated_shape, shape_t * dna_test)
{
*mutated_shape = RANDINT(NUM_SHAPES);
double roulette = RANDDOUBLE(2.8);
double drastic = RANDDOUBLE(2);
// mutate color
if(roulette<1)
{
if(dna_test[*mutated_shape].a < 0.01 // completely transparent shapes are stupid
|| roulette<0.25)
{
if(drastic < 1)
{
dna_test[*mutated_shape].a += RANDDOUBLE(0.1);
dna_test[*mutated_shape].a = CLAMP(dna_test[*mutated_shape].a, 0.0, 1.0);
}
else
dna_test[*mutated_shape].a = RANDDOUBLE(1.0);
}
else if(roulette<0.50)
{
if(drastic < 1)
{
dna_test[*mutated_shape].r += RANDDOUBLE(0.1);
dna_test[*mutated_shape].r = CLAMP(dna_test[*mutated_shape].r, 0.0, 1.0);
}
else
dna_test[*mutated_shape].r = RANDDOUBLE(1.0);
}
else if(roulette<0.75)
{
if(drastic < 1)
{
dna_test[*mutated_shape].g += RANDDOUBLE(0.1);
dna_test[*mutated_shape].g = CLAMP(dna_test[*mutated_shape].g, 0.0, 1.0);
}
else
dna_test[*mutated_shape].g = RANDDOUBLE(1.0);
}
else
{
if(drastic < 1)
{
dna_test[*mutated_shape].b += RANDDOUBLE(0.1);
dna_test[*mutated_shape].b = CLAMP(dna_test[*mutated_shape].b, 0.0, 1.0);
}
else
dna_test[*mutated_shape].b = RANDDOUBLE(1.0);
}
}
// mutate shape
else if(roulette < 2.0)
{
int point_i = RANDINT(NUM_POINTS);
if(roulette<1.5)
{
if(drastic < 1)
{
dna_test[*mutated_shape].points[point_i].x += (int)RANDDOUBLE(WIDTH/10.0);
dna_test[*mutated_shape].points[point_i].x = CLAMP(dna_test[*mutated_shape].points[point_i].x, 0, WIDTH-1);
}
else
dna_test[*mutated_shape].points[point_i].x = RANDDOUBLE(WIDTH);
}
else
{
if(drastic < 1)
{
dna_test[*mutated_shape].points[point_i].y += (int)RANDDOUBLE(HEIGHT/10.0);
dna_test[*mutated_shape].points[point_i].y = CLAMP(dna_test[*mutated_shape].points[point_i].y, 0, HEIGHT-1);
}
else
dna_test[*mutated_shape].points[point_i].y = RANDDOUBLE(HEIGHT);
}
}
// mutate stacking
else
{
int destination = RANDINT(NUM_SHAPES);
shape_t s = dna_test[*mutated_shape];
dna_test[*mutated_shape] = dna_test[destination];
dna_test[destination] = s;
return destination;
}
return -1;
}
Mutation getMutation(const ShapeCollection &collection)
{
Mutation mutation{};
double roulette = (collection.polygonCount > 1 ? RANDDOUBLE(2.2) : RANDDOUBLE(2.0));
mutation.type = (roulette >= 2.0f ? Mutation::kOrderSwapped :
(roulette < 1.0f ? Mutation::kColorChanged :
Mutation::kPointChanged));
mutation.shapeIdx = RANDINT(collection.polygonCount);
switch(mutation.type) {
case Mutation::kOrderSwapped:
{
mutation.data.shapeIdxB = RANDINT(collection.polygonCount);
while (mutation.shapeIdx == mutation.data.shapeIdxB) {
mutation.data.shapeIdxB = RANDINT(collection.polygonCount);
}
if (mutation.shapeIdx > mutation.data.shapeIdxB) {
std::swap(mutation.shapeIdx, mutation.data.shapeIdxB);
}
}
break;
case Mutation::kColorChanged:
{
mutation.data.color = collection.shapes[mutation.shapeIdx].rgba;
bool drastic = RANDBOOL();
int part = roulette * 4;
mutation.data.color[part] = (drastic ?
CLAMPINT(RANDUINT8(), part == 3 ? 0 : 1, 255) :
CLAMPINT(mutation.data.color[part] +
(RANDBOOL() ? + 1 : -1)
* RANDINT(25), part == 3 ? 0 : 1, 255));
}
break;
case Mutation::kPointChanged:
{
mutation.data.pt.idx = RANDINT(collection.vertexCount);
mutation.data.pt.val = collection.shapes[mutation.shapeIdx].polygon[mutation.data.pt.idx];
bool drastic = RANDBOOL(); ;
bool changeX = roulette < 1.5;
std::array<float, 2> &ptRef = mutation.data.pt.val;
if (changeX) {
double x = ptRef[0];
if (drastic) {
ptRef[0] = RANDINT(collection.width + 1);
while (x == ptRef[0]) {
ptRef[0] = RANDINT(collection.width + 1);
}
} else {
ptRef[0] = CLAMPINT(ptRef[0] + (RANDBOOL() ? +1 : -1) *
static_cast<int>(RANDDOUBLE(collection.width / 10.0)), 0, collection.width);
}
} else {
double y = ptRef[1];
if (drastic) {
ptRef[1] = RANDINT(collection.height + 1);
while (y == ptRef[1]) {
ptRef[1] = RANDINT(collection.height + 1);
}
} else {
ptRef[1] = CLAMPINT(ptRef[1] + (RANDBOOL() ? +1 : -1) *
static_cast<int>(RANDDOUBLE(collection.height / 10.0)), 0,
collection.height);
}
}
}
break;
default:
;
}
return mutation;
}
