virtual void test_by_pict() { Mat frame1 = readImage("optflow/RubberWhale1.png", IMREAD_GRAYSCALE); UMat usrc; frame1.copyTo(usrc); int histSize = randomInt(3, 29); float hue_range[] = { 0, 180 }; const float* ranges1 = { hue_range }; Mat hist1; //compute histogram calcHist(&frame1, 1, 0, Mat(), hist1, 1, &histSize, &ranges1, true, false); normalize(hist1, hist1, 0, 255, NORM_MINMAX, -1, Mat()); Mat dst1; UMat udst1, src, uhist1; hist1.copyTo(uhist1); std::vector<UMat> uims; uims.push_back(usrc); std::vector<float> urngs; urngs.push_back(0); urngs.push_back(180); std::vector<int> chs; chs.push_back(0); OCL_OFF(calcBackProject(&frame1, 1, 0, hist1, dst1, &ranges1, 1, true)); OCL_ON(calcBackProject(uims, chs, uhist1, udst1, urngs, 1.0)); EXPECT_MAT_NEAR(dst1, udst1, 0.0); }
void Aircraft::checkPickupDrop(CommandQueue& commands) { if (!isAllied() && randomInt(3) == 0 && !mSpawnedPickup) commands.push(mDropPickupCommand); mSpawnedPickup = true; }
uint32 MersenneTwister::randomIntRange (uint32 start, uint32 end) { lela_check (end > start); uint32 dist = end - start; uint32 random; /* All tricks doing modulo calculations do not have a perfect * distribution -> We must use the slower way through gdouble for * maximal quality. */ if (dist <= 0x10000L) { /* 2^16 */ /* This method, which only calls g_rand_int once is only good * for (end - begin) <= 2^16, because we only have 32 bits set * from the one call to g_rand_int (). */ /* we are using (trans + trans * trans), because g_rand_int only * covers [0..2^32-1] and thus g_rand_int * trans only covers * [0..1-2^-32], but the biggest double < 1 is 1-2^-52. */ double double_rand = randomInt () * (doubleTransform + doubleTransform * doubleTransform); random = (uint32) (double_rand * dist); } else { /* Now we use g_rand_double_range (), which will set 52 bits for us, so that it is safe to round and still get a decent distribution */ random = (uint32) randomDoubleRange (0, dist); } return start + random; }
void LineViewer::adaptFlora(int pts){ int flora_pts = this->getTotalPoints(); int nOrganisms = this->getNOrganisms(); int diff = pts - (flora_pts - nOrganisms); if(pts-1 > flora_pts){ int index = 0; while(diff > 0){ index = randomInt(0,this->getNOrganisms()-1); if(diff % 2){ //mitosis 2 this->flora->at(index)->mitosis(2); diff -= 2; flora_pts += 2; } else{ //mitosis 1 this->flora->at(index)->mitosis(1); diff--; flora_pts++; } if(this->getPointsOfOrganism(index) > 5){ //split LineOrganism *org1 = NULL,*org2 = NULL; if(instance->flora->at(index)->split(&org1,&org2)){ instance->getFlora()->insert(instance->getFlora()->begin() + index + 1,org1); instance->getFlora()->insert(instance->getFlora()->begin() + index + 2,org2); instance->flora->erase(instance->flora->begin() + index); diff--; nOrganisms++; } } } printf(""); } else{ while(diff < 0){ int index = this->getNOrganisms()-1; if(abs(diff) > this->getPointsOfOrganism(index)){ diff += this->getPointsOfOrganism(index); this->getFlora()->pop_back(); } else{ if(this->getPointsOfOrganism(index) > 4){ this->getFlora()->at(index)->dropPoint(2); diff+=2; } else{ this->getFlora()->at(index)->dropPoint(1); diff++; } } } } }
void Pirate::genType() { int t = randomInt(1,100); if( t<34 ) type = "dorc"; else if(t>=34&&t<66) type = "porc"; else type = "borc"; }
QByteArray SecureRNG::randomPrintable(int length) { QByteArray re(length, 0); for (int i = 0; i < re.size(); i++) re[i] = randomInt(95) + 32; return re; }
void GeneticPopulation::crossover( const Weights& parent1, const Weights& parent2, Weights& child1, Weights& child2) const { assert(parent1.size() == parent2.size()); if (randomReal(0, 1) > crossoverRate || parent1 == parent2) { child1 = parent1; child2 = parent2; return; } unsigned crossoverPoint = static_cast<unsigned>(randomInt(0, parent1.size())); child1.clear(); child2.clear(); //create the offspring for (unsigned i = 0; i < crossoverPoint; ++i) { child1.push_back(parent1[i]); child2.push_back(parent2[i]); } for (unsigned i = crossoverPoint; i < parent1.size(); ++i) { child1.push_back(parent2[i]); child2.push_back(parent1[i]); } }
KategProblem &makRandom(int ANZ_WORD,int ANZ_CLS,int initValue, int auswertung,int nachbarschaft,float relInit) { KategProblem &k= *new KategProblem(ANZ_WORD,ANZ_CLS,initValue,auswertung,nachbarschaft); KategProblemWBC &w=k.wordFreq; Array<int> after(ANZ_WORD,0); Array<int> before(ANZ_WORD,0); Array<FreqArray> twoD(ANZ_WORD); int i; for(i=0;i<ANZ_WORD;i++) twoD[i].init(ANZ_WORD,0); for(i=0;i<ANZ_WORD;i++) { massert(after[i]==0); massert(before[i]==0); for(int j=0;j<ANZ_WORD;j++) { massert(twoD[i][j]==0); } } for(i=0;i<ANZ_WORD*ANZ_WORD*relInit;i++) { int x=randomInt(ANZ_WORD); int y=randomInt(ANZ_WORD); if(twoD[x][y]==0) { after[x]++; before[y]++; } twoD[x][y]+=randomInt(10)+1; } for(i=0;i<ANZ_WORD;i++) { w.setAfterWords(i,after[i]); w.setBeforeWords(i,before[i]); } for(i=0;i<ANZ_WORD;i++) { for(int j=0;j<ANZ_WORD;j++) if( twoD[i][j] ) w.setFreq(i,j,twoD[i][j]); } w.testFull(); return k; }
void KruskalMaze::generate() { // Generate sets m_set_ids = QVector< QVector<Set*> >(columns(), QVector<Set*>(rows())); for (int c = 0; c < columns(); ++c) { for (int r = 0; r < rows(); ++r) { m_sets.append(QList<QPoint>() << QPoint(c, r)); m_set_ids[c][r] = &m_sets.last(); } } while (m_sets.size() > 1) { Set* set1 = &m_sets.first(); // Find random cell const QPoint& cell = set1->at(randomInt(set1->size())); // Find random neighbor of cell QPoint cell2(cell); if (randomInt(2)) { cell2.rx()++; } else { cell2.ry()++; } if (cell2.x() >= columns() || cell2.y() >= rows()) { continue; } // Find set containing second cell Set* set2 = m_set_ids.at(cell2.x()).at(cell2.y()); // Merge sets if they are different if (set1 != set2) { mergeCells(cell, cell2); int size = set1->size(); for (int i = 0; i < size; ++i) { const QPoint& cell3 = set1->at(i); m_set_ids[cell3.x()][cell3.y()] = set2; } *set2 += *set1; m_sets.removeFirst(); } } m_sets.clear(); m_set_ids.clear(); }
void MainWindow::startGrid() { int i,j,k,l; score = 0; max = 0; for( i=0;i<4;i++ ) for( j=0;j<4;j++ ) grid[i][j] = 0; i = randomInt(4); j = randomInt(4); grid[i][j] = 2; do{ k = randomInt(4); l = randomInt(4); }while( k==i && l==j); grid[k][l] = 2; }
GpuMat createMat(Size size, int type, bool useRoi) { Size size0 = size; if (useRoi) { size0.width += randomInt(5, 15); size0.height += randomInt(5, 15); } GpuMat d_m(size0, type); if (size0 != size) d_m = d_m(Rect((size0.width - size.width) / 2, (size0.height - size.height) / 2, size.width, size.height)); return d_m; }
void render(SDL_Renderer *renderer) { Uint8 r, g, b; int renderW; int renderH; SDL_RenderGetLogicalSize(renderer, &renderW, &renderH); /* Come up with a random rectangle */ SDL_Rect rect; rect.w = randomInt(64, 128); rect.h = randomInt(64, 128); rect.x = randomInt(0, renderW); rect.y = randomInt(0, renderH); /* Come up with a random color */ r = randomInt(50, 255); g = randomInt(50, 255); b = randomInt(50, 255); /* Fill the rectangle in the color */ SDL_SetRenderDrawColor(renderer, r, g, b, 255); SDL_RenderFillRect(renderer, &rect); /* update screen */ SDL_RenderPresent(renderer); }
void render(SDL_Renderer *renderer) { Uint8 r, g, b; /* Clear the screen */ SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); SDL_RenderClear(renderer); /* Come up with a random rectangle */ SDL_Rect rect; rect.w = randomInt(64, 128); rect.h = randomInt(64, 128); rect.x = randomInt(0, SCREEN_WIDTH); rect.y = randomInt(0, SCREEN_HEIGHT); /* Come up with a random color */ r = randomInt(50, 255); g = randomInt(50, 255); b = randomInt(50, 255); SDL_SetRenderDrawColor(renderer, r, g, b, 255); /* Fill the rectangle in the color */ SDL_RenderFillRect(renderer, &rect); /* update screen */ SDL_RenderPresent(renderer); }
static std::vector<int> randomInts(int howMany, int min, int max) { std::vector<int> ints; for (int index = 0; index < howMany; index++) { ints.push_back(randomInt(min, max)); } return ints; }
static void initPopulation() { int cromosomeIdx; int blocks; int threads; for (cromosomeIdx = 0; cromosomeIdx < POPULATION_NMR; ++cromosomeIdx) { do { blocks = randomInt(columns - 1) + 1; threads = randomInt(columns - 1) + 1; } while (2l * blocks * threads >= (long) columns || threads > MAX_THREADS || blocks > MAX_BLOCKS); population[cromosomeIdx].blocks = blocks; population[cromosomeIdx].threads = threads; } }
void Tile::checkPickupDrop(CommandQueue& commands) { // Drop pickup, if enemy airplane, with probability 1/4, if pickup not yet dropped // and if not in network mode (where pickups are dropped via packets) if (isBlock() && randomInt(5) == 0 && !mSpawnedPickup && mPickupsEnabled){ commands.push(mDropPickupCommand); } mSpawnedPickup = true; }
char * corrupt_bits(char * data, size_t * dataSz) { size_t bitsToCorrupt = randomInt(0, 20); size_t i; // Flip the MSB of a random amount of bytes for(i = 0; i < bitsToCorrupt; i++) { size_t off = random_offset(*dataSz); size_t bit = randomInt(0, 7); // flip the bit data[off] = data[off] ^ (1 << bit); } return data; }
/// <summary> /// Adds a particle. /// </summary> /// <param name="position">The position.</param> void ParticleSystem::addParticle(sf::Vector2f position) { mVertexNeedsUpdate = true; Particle particle; particle.position = position; particle.type = mType; particle.lifeTime = Table[mType].lifetime; // Trail Particles don't need velocity or angle since they dont move if (mType != Particle::Trail) { particle.velocity = (randomInt(2) + 1) * Table[mType].maxVelocity; particle.angle = randomInt(361); } mParticles.push_back(particle); }
void Aircraft::createPickup(SceneNode& node, const TextureHolder& textures) const { auto type = static_cast<Pickup::Type>(randomInt(Pickup::TypeCount)); std::unique_ptr<Pickup> pickup(new Pickup(type, textures)); pickup->setPosition(getWorldPosition()); pickup->setVelocity(0.f, 1.f); node.attachChild(std::move(pickup)); }
void RecursiveBacktrackerMaze::generate() { m_visited = QVector< QVector<bool> >(columns(), QVector<bool>(rows())); QPoint start(0, randomInt(rows())); m_visited[start.x()][start.y()] = true; makePath(start); m_visited.clear(); }
TEST( SequencerController, Rewind ) { SequencerController* controller = new SequencerController(); int minPosition = randomInt( 0, 44100 ); int maxPosition = randomInt( 88200, 192000 ); AudioEngine::min_buffer_position = minPosition; AudioEngine::max_buffer_position = maxPosition; controller->setBufferPosition( randomInt( AudioEngine::min_buffer_position + 1, AudioEngine::max_buffer_position - 1 )); controller->rewind(); EXPECT_EQ( minPosition, AudioEngine::min_buffer_position ) << "expected engine to have 'rewound'"; delete controller; }
void Controller::generate() { int random_number = randomInt(1,100); if(random_number<51&&WarriorList->getSize()<25) { Pirate *p = new Pirate(); p->setX(0); p->setY(randomInt(1,6)); WarriorList->push(p); } if(random_number>34&&WarriorList->getSize()<25) { Soldier *s = new Soldier(); s->setY(randomInt(2,4)); s->setX(24); WarriorList->push(s); } }
TEST( WaveTable, Accumulator ) { int length = randomInt( 2, 256 ); float frequency = randomFloat( 20, 880 ); WaveTable* table = new WaveTable( length, frequency ); EXPECT_EQ( 0.0, table->getAccumulator() ) << "expected WaveTable accumulator to be 0.0 upon construction"; for ( int i = 0; i < randomInt( 1, 100 ); ++i ) { SAMPLE_TYPE value = randomSample( 0.0, ( SAMPLE_TYPE ) length ); table->setAccumulator( value ); EXPECT_EQ( value, table->getAccumulator() ) << "expected WaveTable accumulator to be " << value << " after setter, got " << table->getAccumulator() << " instead"; } delete table; }
TEST( SequencerController, GetSetBufferPosition ) { SequencerController* controller = new SequencerController(); int minBufferPos = randomInt( 0, 5512 ); int maxBufferPos = randomInt( minBufferPos + 1, minBufferPos + 44100 ); AudioEngine::min_buffer_position = minBufferPos; AudioEngine::max_buffer_position = maxBufferPos; AudioEngine::bufferPosition = randomInt( minBufferPos, maxBufferPos ); // test 1. test getter EXPECT_EQ( AudioEngine::bufferPosition, controller->getBufferPosition() ) << "expected SequencerController to return the buffer position"; // test 2. test setter int newPosition = randomInt( minBufferPos, maxBufferPos ); controller->setBufferPosition( newPosition ); EXPECT_EQ( newPosition, controller->getBufferPosition() ) << "expected SequencerController to have updated the buffer position"; // test 3. sanitation of existing out-of-range position newPosition = minBufferPos - 1; // force current position to be below range controller->setBufferPosition( newPosition ); EXPECT_EQ( minBufferPos, controller->getBufferPosition() ) << "expected SequencerController to have sanitized the current buffer position"; newPosition = maxBufferPos + 1; // force current position to be above range controller->setBufferPosition( newPosition ); EXPECT_EQ( minBufferPos, controller->getBufferPosition() ) << "expected SequencerController to have sanitized the current buffer position"; delete controller; }
TEST( SequencerController, GetStepPosition ) { SequencerController* controller = new SequencerController(); AudioEngine::stepPosition = randomInt( 1, 16 ); EXPECT_EQ( AudioEngine::stepPosition, controller->getStepPosition() ) << "expected SequencerController to have returned the current step position"; delete controller; }
TEST( SequencerController, GetSamplesPerBar ) { SequencerController* controller = new SequencerController(); AudioEngine::samples_per_bar = randomInt( 512, 8192 ); EXPECT_EQ( AudioEngine::samples_per_bar, controller->getSamplesPerBar() ) << "expected SequencerController to have returned samples per bar"; delete controller; }
void PrimMaze::generate() { // Generate cell lists m_regions = QVector< QVector<int> >(columns(), QVector<int>(rows(), 0)); // Move first cell QPoint cell(0, randomInt(columns())); m_regions[0][cell.y()] = 2; moveNeighbors(cell); // Move remaining cells while (!m_frontier.isEmpty()) { cell = m_frontier.takeAt(randomInt(m_frontier.size())); mergeRandomNeighbor(cell); m_regions[cell.x()][cell.y()] = 2; moveNeighbors(cell); } m_regions.clear(); }
// update all enemies // spawn new enemies if available void Spawner::update(float dT) { // only spawn new enemies if alive if(alive) { // if health is below 0 it is dead if(curHealth <= 0.0f) alive = false; // update cool downs CoolDownCtrl(dT, canSpawn); /// check on enemy count if(m_enemies.size() < max_enemies && !canSpawn.active) { // spawn a new enemy m_enemies.add( new Enemy ); // generate a new position next to me that is free int x = 0, y = 0; do { x = randomInt(-1,1) + m_roomPOS.x; y = randomInt(-1,1) + m_roomPOS.y; }while( m_room->checkLocation(x,y).m_type != FLOOR || (x-m_roomPOS.x == 0 && y-m_roomPOS.y == 0) ); // initialize that enemy with the given position m_enemies.get( m_enemies.size()-1 )->initialize(spawnType,thePlayer, V2DF( (x * TEX_SIZE) + HALF_TEX + BORDER, (y * TEX_SIZE) + HALF_TEX + BORDER ), m_room); // start spawn cool down canSpawn.active = true; } } for(int i = 0; i < m_enemies.size(); ++i) { // check if any enemies are dead if(m_enemies.get(i)->checkHealth() <= 0.0f) m_enemies.removeFast(i); // incase the original enemy was killed make sure the next enemy exists and update them if(i < m_enemies.size()) m_enemies.get(i)->update(dT); } }
bool placeObject(char tile) { if (_rooms.empty()) return false; int r = randomInt(_rooms.size()); // choose a random room int x = randomInt(_rooms[r].x + 1, _rooms[r].x + _rooms[r].width - 2); int y = randomInt(_rooms[r].y + 1, _rooms[r].y + _rooms[r].height - 2); if (getTile(x, y) == Floor) { setTile(x, y, tile); // place one object in one room (optional) _rooms.erase(_rooms.begin() + r); return true; } return false; }
bool CCSSBot :: startGame () { // do whatever is necessary here to join the game... IPlayerInfo* pInfo = playerinfomanager->GetPlayerInfo(m_pEdict); if ( pInfo->GetTeamIndex() == 0 ) { pInfo->ChangeTeam(randomInt(2,3)); } return (pInfo->GetTeamIndex() != 0); }