Space::Space(unsigned int amount, unsigned int size, bool rare, FigureType figure) : figure_(figure) { if(rare) { for(unsigned int i = 0;i<amount;++i) { /* produce points for square size 2*size*amount x 2*size*amount */ int x = getRandomNumber(0,amount*size); int y = getRandomNumber(0,amount*size); Point randomPoint(x,y); points.push_back(randomPoint); } } else { int partChooser = getRandomNumber(0,3); Point offset; switch(partChooser) { case 0: offset.x = 0; offset.y = 0; break; case 1: offset.x = amount*size/2; offset.y = 0; break; case 2: offset.x = 0; offset.y = amount*size/2; break; case 3: offset.x = amount*size/2; offset.y = amount*size/2; break; } int notRareAmount = amount/4; int x = getRandomNumber(0,notRareAmount*size); for(unsigned int i = 0;i<notRareAmount;++i) { int y = getRandomNumber(0,notRareAmount*size); Point randomPoint(x,y); randomPoint = randomPoint + offset; points.push_back(randomPoint); } int restAmount = amount-notRareAmount; for(unsigned int i = 0;i<restAmount;++i) { x = getRandomNumber(notRareAmount*size,restAmount*size); int y = getRandomNumber(notRareAmount*size,restAmount*size); Point randomPoint(x,y); points.push_back(randomPoint); } } }
void Bullets::runEnemyAction(){ size = CCDirector::sharedDirector()->getWinSize(); CCJumpTo* jump = CCJumpTo::create(0.8f, randomPoint(), 50, 1); CCFadeTo* fade = CCFadeTo::create(1.0f, 0.0f); CCSequence* seq = CCSequence::create(jump,fade,NULL); this->runAction(seq); }
std::vector<double> RandomGlobalPoll::nextPoint() { if(hasConverged()) return min_element ( population.begin(),population.end() )->point(); if ( population.size() < dimPopul ) { ++timesInitialPopulation; return randomPoint(); } return computeFamilyStepPoint ( std::min ( bounds.size()+1,population.size()-1 ) ); }
void init(const Graph<P, W, H>& graph) { _embedding.clear(); for (const auto& n: graph._nodes) { _embedding.insert( std::pair<const Node<P, W, H>*, EuclidianVector<T, N>> (&*n, randomPoint())); } initDilatation(); }
void testAABB() { static const math::Vector3<real_t> ZERO( real_t( 0 ), real_t( 0 ), real_t( 0 ) ); static const math::Vector3<real_t> UNIT( real_t( 1 ), real_t( 1 ), real_t( 1 ) ); static const real_t EPSILON = real_t(1e-4); boost::random::mt19937 randomEngine; std::vector<math::AABB> testAABBs; testAABBs.push_back( math::AABB( -UNIT, UNIT ) ); testAABBs.push_back( math::AABB( ZERO, UNIT ) ); testAABBs.push_back( math::AABB( -UNIT, ZERO ) ); for( auto aabbIt = testAABBs.begin(); aabbIt != testAABBs.end(); ++aabbIt ) { const math::AABB outerAABB = aabbIt->getScaled( real_t( 2 ) ); std::vector< std::pair< Vector3<real_t>, Vector3<real_t> > > testPoints; for( int i = 0; i < 100; ++i ) { Vector3<real_t> outerPoint, innerPoint; do { outerPoint = outerAABB.randomPoint( randomEngine ); } while( aabbIt->contains( outerPoint ) ); innerPoint = aabbIt->randomPoint( randomEngine ); testPoints.push_back( std::make_pair( outerPoint, innerPoint - outerPoint ) ); } for( auto pointIt = testPoints.begin(); pointIt != testPoints.end(); ++pointIt ) { const Vector3<real_t> & fluidPoint = pointIt->first; const Vector3<real_t> & direction = pointIt->second; real_t q = lbm::intersectionRatio( *aabbIt, fluidPoint, direction, EPSILON ); Vector3<real_t> intersectionPoint = fluidPoint + direction * q; WALBERLA_CHECK_LESS( std::fabs( aabbIt->sqSignedDistance( intersectionPoint ) ), EPSILON * EPSILON ); q = lbm::intersectionRatioBisection( *aabbIt, fluidPoint, direction, EPSILON ); intersectionPoint = fluidPoint + direction * q; WALBERLA_CHECK_LESS( std::fabs( aabbIt->sqSignedDistance( intersectionPoint ) ), EPSILON * EPSILON ); } } }
void testAABBDistance( const Vector3<real_t> & translationVector = Vector3<real_t>() ) { auto mesh = make_shared<MeshType>(); mesh::readAndBroadcast( "cube.obj", *mesh); translate( *mesh, translationVector ); auto aabb = computeAABB( *mesh ); // works since the mesh is a cube auto testVolume = aabb.getScaled( real_t(2) ); // AABB containing the test points TriangleDistance<MeshType> triDist( mesh ); std::mt19937 rng; for( int i = 0; i < 10000; ++i ) { auto p = testVolume.randomPoint( rng ); WALBERLA_CHECK_FLOAT_EQUAL( triDist.sqSignedDistance( toOpenMesh(p) ), aabb.sqSignedDistance( p ) ); } }
void generateBuildingSeeds(Context &context, Stronghold &stronghold, Polygon2D const &inner, std::vector<BuildingSeed> &out) { // habitations const int numSeeds = 5000; //const float attractionThreshold = 10000; float threshold = 0.95f; std::vector<BuildingSeed> &seeds = stronghold.seeds; // test LJ for (int i = 0; i < numSeeds; ++i) { // new seed BuildingSeed s; s.location = randomPoint(inner); s.attraction = calculateAttractionPotential(s.location, seeds); s.flatness = flatnessScoreWall(s.location, 4.0f, context); // // Si le terrain n'est pas assez plat, on rejette la graine if (s.flatness > 0.3f) { continue; } // // La maison est trop proche d'autres habitations: rejet if (s.attraction < 0.f) { // reject continue; } // TODO: autres formes Rectangle2D house = generateBuilding(context, s, glm::vec2(7, 7)); bool accepted = true; for (int j = 0; j < seeds.size(); j++) { Rectangle2D house2 = generateBuilding(context, seeds[j], glm::vec2(7, 7)); if (intersect_houses(house, house2)) { accepted = false; break; } } if (!accepted) { continue; } // si la l'attraction n'est pas suffisante, il y a quand même une chance pour qu'un nouveau bâtiment apparaisse if (s.attraction < 0.5f) { if (GRandom.RandomNumber(0, 1) > threshold) { seeds.push_back(s); } } else { // // La graine a passé le test de 'platitude' et a une force d'attraction suffisante seeds.push_back(s); } } std::clog << "Created " << seeds.size() << " seeds\n"; /* debugSeeds(context, stronghold, seeds); */ // filtrage }
// TODO : random landMass from min to max // TODO : putting next landMass level for height static void civGeneration(GOC_HANDLER mapa, int numStartPoints, int minLM, int maxLM, int MINLEVEL, int NEWLEVEL) { // int MINLEVEL=0; // int NEWLEVEL=1; int type = 0; stChange point; point.x = 0; point.y = 0; point.v = 0; stChange** pSet = NULL; int nSet = 0; int landMass; int svStartPoints = numStartPoints; int createdLandMass; GOC_BINFO("Start civ generation system [numStartPoint: %d, minLandMass: %d, maxLandMass: %d, level: %d]", numStartPoints, minLM, maxLM, NEWLEVEL); if ( MINLEVEL >= 10 ) return; if ( numStartPoints <= 0 ) return; if ( maxLM <= 0 ) return; while (numStartPoints--) { GOC_BDEBUG("Number of start points %d", numStartPoints); // inicjowanie do kolejnej iteracji tworzenia masy ladowej type = 0; landMass = minLM + goc_random(maxLM-minLM); createdLandMass = 0; GOC_BINFO("Generated landmass: %d", landMass); if ( nSet ) { GOC_DEBUG("Clear set"); int i; for ( i=0; i<nSet; i++ ) free(pSet[i]); pSet = goc_tableClear(pSet, &nSet); } while ( landMass ) { GOC_BDEBUG("Landmass to generate %d", landMass); // random new point if ( randomPoint(&point, type, MINLEVEL, mapa) ) { GOC_BDEBUG("Setting a point (%d,%d,%d)", point.x, point.y, NEWLEVEL); pSet = goc_tableAdd(pSet, &nSet, sizeof(void*)); pSet[nSet-1] = mallocPoint(point.x, point.y, NEWLEVEL); goc_maparawSetPoint(mapa, point.x, point.y, NEWLEVEL); createdLandMass++; } landMass--; while ( nSet ) { // random point from set int randp = goc_random(nSet); int x, y; type = 1; // neighbour // check a point has any free neighbour x = pSet[randp]->x; y = pSet[randp]->y; if ( ( (x+1 < context.configuration.maxx) && (goc_maparawGetPoint(mapa, x+1, y) <= MINLEVEL) ) || ( (y+1 < context.configuration.maxy) && (goc_maparawGetPoint(mapa, x, y+1) <= MINLEVEL )) || ( (y > 0) && (goc_maparawGetPoint(mapa, x, y-1) <= MINLEVEL) ) || ( (x > 0) && (goc_maparawGetPoint(mapa, x-1, y) <= MINLEVEL) ) ) { point.x = x; point.y = y; point.v = pSet[randp]->v; GOC_BDEBUG("Find point in set (%d,%d,%d)", point.x, point.y, point.v); break; } else { GOC_DEBUG("Remove point from set"); free(pSet[randp]); pSet = goc_tableRemove(pSet, &nSet, sizeof(void*), randp); } } // check, if there are any points in set if ( !nSet ) break; } GOC_BINFO("Created landmass: %d", createdLandMass); } civGeneration( mapa, svStartPoints, //-svStartPoints/20, minLM-minLM*precentageCut[MINLEVEL]/10, maxLM-maxLM*precentageCut[MINLEVEL]/10, MINLEVEL+1, NEWLEVEL+1); /* pStartPoint = randomStartPoints(&nStartPoint, numStartPoints); for (i=0; i<nStartPoint; i++) { goc_maparawSetPoint(mapa, pStartPoint[i]->x, pStartPoint[i]->y, 1); } */ }
// A modified k-means clustering algorithm, where output points is the reduction // of each cluster. vector<Point> findCentroids(int k, int init, vector<Point> points, int maxIter) { vector<Group> groups; Point center = hullCenter(points); // Init groups to a random point for(int i = 0; i < k; i++) { Point c = center + randomPoint(-init, init); Group group(c, points); groups.push_back(group); } bool cont = true; int iter = 0; while(cont) { iter++; vector<Point> centroids; // Save centroids and clear points for (int i = 0; i < k; i++) { centroids.push_back(groups[i].centroid); (&(groups[i].points))->clear(); } // Assing points to the closest centroid for (int i = 0; i < points.size(); i++) { int closest = 0; double dist = 100000000.0; Point p = points[i]; for (int j = 0; j < k; j++) { Point c = groups[j].centroid; double d = norm(c-p); if (d < dist) { closest = j; dist = d; } } (&(groups[closest].points))->push_back(p); } cont = false; // Relocate centroids and check for change. for (int i = 0; i < k; i++) { Point c = groups[i].centroid; if (c == Point(0, 0)) (&groups[i])->centroid = center + randomPoint(-init, init); else (&groups[i])->centroid = hullCenter(groups[i].points); // Check if centroid has not changed. if (norm(groups[i].centroid - centroids[i]) > 0.001) { cont = true; } } if (iter > maxIter) { break; } } // Extract centroids. vector<Point> centroids; for (int i = 0; i < k; i++) { Point reduced = reduce(groups[i].points); centroids.push_back(reduced); } return centroids; }
Ray taf::randomRay( double a, double b ) { return Ray( randomPoint(a, b), randomDirection() ); }
BBox taf::randomBox( double a, double b ) { Point3D point1 = randomPoint( a, b ); Point3D point2 = randomPoint( a, b ); return BBox( point1, point2 ); }