void Quad::updateGrid(float dt) { //if (xDivs == 0 && yDivs == 0) return; if (!doUpdateGrid) return; if (gridType == GRID_WAVY) { gridTimer += dt * drawGridTimeMultiplier; resetGrid(); int hx = xDivs/2; for (int x = 0; x < xDivs; x++) { float yoffset = x * drawGridOffsetY; float addY = 0; if (drawGridModY != 0) addY = cosf(gridTimer+yoffset)*drawGridModY; for (int y = 0; y < yDivs; y++) { float xoffset = y * drawGridOffsetX; if (drawGridModX != 0) { float addX = (sinf(gridTimer+xoffset)*drawGridModX); if (drawGridOut && x < hx) drawGrid[x][y].x += addX; else drawGrid[x][y].x -= addX; } drawGrid[x][y].y += addY; } } } }
void Quad::setGridPoints(bool vert, const std::vector<Vector> &points) { if (!drawGrid) return; resetGrid(); for (int i = 0; i < points.size(); i++) { if (!vert) // horz { for (int y = 0; y < yDivs; y++) { for (int x = 0; x < xDivs; x++) { if (x < points.size()) { drawGrid[x][y] += points[x]; } } } } else { for (int x = 0; x < xDivs; x++) { for (int y = 0; y < yDivs; y++) { if (y < points.size()) { drawGrid[x][y] += points[y]; } } } } } }
/* * --------------------------------------------------------- * Setups * --------------------------------------------------------- */ void MainWindow::createWindow() { QWidget *w = new QWidget; setCentralWidget(w); _playBox = new PlayBox(this); _tracklist = new Tracklist(this); _playlist = new Playlist(_tracklist, this); _colourMapDisplay = new ColourMapDisplay(this); _display = new GridDisplay(600, _tracklist, _dataGrid, this); QGridLayout *gridLayout = new QGridLayout; //fromRow, fromCol, rowSpan, colSpan gridLayout->addWidget( _display, 0, 0, 4, 1); QVBoxLayout *vbox = new QVBoxLayout; vbox->addWidget(new QLabel(tr("Playlists"))); vbox->addWidget(_playlist); vbox->addWidget(new QLabel(tr("Track list"))); vbox->addWidget(_tracklist); vbox->addWidget(_colourMapDisplay); gridLayout->addLayout(vbox,1,1,1,1); connect(_display, SIGNAL(playingTrack(MusicTrack*)), this, SLOT(updateCurrentlyPlaying(MusicTrack*))); connect(this, SIGNAL(libraryUpdated()), _playlist, SLOT(updatePlaylist())); connect(this, SIGNAL(libraryUpdated()), _display, SLOT(reload())); connect(this, SIGNAL(openPredictGridFile(QString)), _display, SLOT(openPredictionGrid(QString))); connect(this, SIGNAL(savePredictGridFile(QString)), _display, SLOT(savePredictionGrid(QString))); connect(this, SIGNAL(playModeChanged()), _display, SLOT(playModeChanged())); connect(this, SIGNAL(cancelButtonSignal()), _display, SLOT(cancelButton())); connect(_display, SIGNAL(fullScreenMode(bool)), this, SLOT(fullScreenMode(bool))); connect(this, SIGNAL(fullScreenModeOff()), _display, SLOT(fullScreenMouse())); connect(_playlist, SIGNAL(SelectedPlaylist(QString)), _display, SLOT(playlistSelected(QString))); connect(_display, SIGNAL(updateColourMap(int *, int)), _colourMapDisplay, SLOT(updateSquare(int *, int))); connect(this, SIGNAL(resetGrid()), _display, SLOT(resetGrid())); w->setLayout(gridLayout); statusBar()->showMessage(tr("Ready")); }
void Document::setSize(const QSize &size) { if (size_ == size) return; size_ = size; resetGrid(); }
void Grid::openPredictionGrid(QString fname) { fstream file_ip((fname.toStdString()).c_str(), ios::in); if (!file_ip) { cerr << "Can't open input file " << endl; return; } int x_size = 0; int y_size = 0; int index = 0; int splitIndex = 0; QString qFname = ""; string intBufferStr = ""; string line = ""; string listFname = ""; string vecIndex = ""; cout << "doing file stuff" << endl; // get the stored size of the vector getline(file_ip,intBufferStr); istringstream intBuffer(intBufferStr); intBuffer >> x_size; getline(file_ip, intBufferStr); istringstream intBufferTwo(intBufferStr); intBufferTwo >> y_size; cout << "x_size = " << x_size << endl; cout << "y_size = " << y_size << endl; cout << "Before reset grid" << endl; resetGrid(); cout << "After reset grid" << endl; int i = 1; while(!file_ip.eof()) { getline(file_ip,line); cout << "Line is " << line << endl; splitIndex = line.find_first_of(','); vecIndex = line.substr(0,splitIndex); listFname = line.substr(splitIndex + 1); qFname = listFname.c_str(); istringstream buffer(vecIndex); buffer >> index; cout << "index = " << index << endl; cout << "filename = " << qFname << endl; addTrack(index % som_height, index / som_height, qFname); } }
void AnimatorScene::setGridLinesCount (int nGridLines) { m_nGridLines = nGridLines; bool showGrid = m_showGrid; resetGrid (); m_showGrid = showGrid; if (m_showGrid) { addGrid (); } update (); }
void MainWindow::resetButtonPressed() { QMessageBox msgBox; msgBox.setText("Are you sure you want to reset the grid?"); msgBox.setInformativeText("You will need to extract and train your collection again."); msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No); msgBox.setDefaultButton(QMessageBox::No); int ret = msgBox.exec(); if(ret == QMessageBox::Yes) { emit resetGrid(); } }
void FastDetector::detect( Frame* frame, const ImgPyr& img_pyr, const double detection_threshold, Features& fts) { Corners corners(grid_n_cols_*grid_n_rows_, Corner(0,0,detection_threshold,0,0.0f)); for(int L=0; L<n_pyr_levels_; ++L) { const int scale = (1<<L); vector<fast::fast_xy> fast_corners; #if __SSE2__ fast::fast_corner_detect_10_sse2( (fast::fast_byte*) img_pyr[L].data, img_pyr[L].cols, img_pyr[L].rows, img_pyr[L].cols, 20, fast_corners); #elif HAVE_FAST_NEON fast::fast_corner_detect_9_neon( (fast::fast_byte*) img_pyr[L].data, img_pyr[L].cols, img_pyr[L].rows, img_pyr[L].cols, 20, fast_corners); #else fast::fast_corner_detect_10( (fast::fast_byte*) img_pyr[L].data, img_pyr[L].cols, img_pyr[L].rows, img_pyr[L].cols, 20, fast_corners); #endif vector<int> scores, nm_corners; fast::fast_corner_score_10((fast::fast_byte*) img_pyr[L].data, img_pyr[L].cols, fast_corners, 20, scores); fast::fast_nonmax_3x3(fast_corners, scores, nm_corners); for(auto it=nm_corners.begin(), ite=nm_corners.end(); it!=ite; ++it) { fast::fast_xy& xy = fast_corners.at(*it); const int k = static_cast<int>((xy.y*scale)/cell_size_)*grid_n_cols_ + static_cast<int>((xy.x*scale)/cell_size_); if(grid_occupancy_[k]) continue; const float score = vk::shiTomasiScore(img_pyr[L], xy.x, xy.y); if(score > corners.at(k).score) corners.at(k) = Corner(xy.x*scale, xy.y*scale, score, L, 0.0f); } } // Create feature for every corner that has high enough corner score std::for_each(corners.begin(), corners.end(), [&](Corner& c) { if(c.score > detection_threshold) fts.push_back(new Feature(frame, Vector2d(c.x, c.y), c.level)); }); resetGrid(); }
Document::Document(const QSize &size, QObject *parent) : QGraphicsScene(parent), size_(size) { selection_ = NULL; floatingSelection_ = NULL; changed_ = false; editor_ = new Editor(this); map_ = new SparseMap(this); connect(editor_, SIGNAL(changed()), this, SLOT(documentChanged_())); grid_ = NULL; resetGrid(); GlobalState::self()->undoGroup()->addStack(editor_); }
void Quad::createGrid(int xd, int yd) { deleteGrid(); xDivs = xd; yDivs = yd; drawGrid = new Vector * [xDivs]; for (int i = 0; i < xDivs; i++) { drawGrid[i] = new Vector [yDivs]; for (int j = 0; j < yDivs; j++) { drawGrid[i][j].z = 1; } } resetGrid(); }
void main() { char myGrid[NRows][NCols]; /****** 16.216 PROGRAM 8 ****** ADD ADDITIONAL VARIABLES HERE ********************************/ resetGrid(myGrid); // Initialize grid to clear state /******* 16.216 PROGRAM 8 ******* LOOP TO REPEATEDLY PROMPT FOR AND EXECUTE INPUT COMMANDS *********************************/ /***** 16.216 PROGRAM 8 ******* PROMPT FOR AND READ INPUT COMMAND *******************************/ /***** 16.216 PROGRAM 8 ******* "print" COMMAND ENTERED--PRINT CURRENT STATE OF GRID *******************************/ /***** 16.216 PROGRAM 8 ********* "reset" COMMAND ENTERED--RESET GRID TO HAVE NO BOXES *********************************/ /***** 16.216 PROGRAM 8 ********* "add" COMMAND ENTERED--PROMPT FOR ORIGIN COORDINATES (X,Y), WIDTH, AND HEIGHT, THEN ADD BOX TO GRID **********************************/ /***** 16.216 PROGRAM 8 ********* "exit" COMMAND ENTERED--END PROGRAM **********************************/ /***** 16.216 PROGRAM 8 ********* NO MATCHING COMMAND--PRINT ERROR *********************************/ /***** 16.216 PROGRAM 8 ******** END LOOP ********************************/ }
void BoggleSolver::setGrid(const std::string& g) { std::vector<char> tmp; for(std::string::const_iterator it = g.begin(); it != g.end();++it) { if(*it != ' ') { if( *it != ',') tmp.push_back((char)toupper(*it)); else { grid.push_back(tmp); tmp.clear(); } } } grid.push_back(tmp); if(!checkGridIntegrity()) { std::cerr << "Invalid Grid" << std::endl; resetGrid(); } }
void AfterEffectManager::clear() { deleteEffects(); resetGrid(); }
MStatus ProxyViz::compute( const MPlug& plug, MDataBlock& block ) { if(!m_enableCompute) return MS::kSuccess; if( plug == outValue ) { updateWorldSpace(thisMObject() ); MStatus status; ExampVox * defBox = plantExample(0); defBox->setGeomSizeMult(block.inputValue(aradiusMult).asFloat() ); defBox->setGeomBox(block.inputValue(abboxminx).asFloat(), block.inputValue(abboxminy).asFloat(), block.inputValue(abboxminz).asFloat(), block.inputValue(abboxmaxx).asFloat(), block.inputValue(abboxmaxy).asFloat(), block.inputValue(abboxmaxz).asFloat()); float grdsz = defBox->geomExtent() * 32.f ; if(grdsz < 32.f) { AHelper::Info<float>(" ProxyViz input box is too small", grdsz); grdsz = 32.f; AHelper::Info<float>(" trancated to", grdsz); } if(m_toSetGrid) { m_toSetGrid = false; resetGrid(grdsz); } if(_firstLoad) { /// internal cache only, initializing from external cache is obsolete if(!loadInternal(block) ) std::cout<<"\n ERROR proxviz cannot load internal cache"; _firstLoad = 0; } if(!m_toCheckVisibility) { MArrayDataHandle groundMeshArray = block.inputArrayValue(agroundMesh ); MArrayDataHandle groundSpaceArray = block.inputArrayValue(agroundSpace ); /// in case no ground is connected if(updateGround(groundMeshArray, groundSpaceArray )) { moveWithGround(); AHelper::Info<std::string>(" ProxyViz ground ", groundBuildLog() ); } } if(!m_hasParticle) { block.setClean(plug); return MS::kSuccess; } const int ngroups = block.inputValue(agroupcount).asInt(); MDataHandle hdata = block.inputValue(outPositionPP, &status); MFnVectorArrayData farray(hdata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle scaledata = block.inputValue(outScalePP, &status); MFnVectorArrayData scalearray(scaledata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle rotatedata = block.inputValue(outRotationPP, &status); MFnVectorArrayData rotatearray(rotatedata.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system"); block.setClean(plug); return MS::kSuccess; } MDataHandle replaceData = block.inputValue(outReplacePP, &status); MFnDoubleArrayData replaceArrayFn(replaceData.data(), &status); if(!status) { MGlobal::displayInfo("proxy viz is not properly connected to a particle system, needs userScalarPP"); block.setClean(plug); return MS::kSuccess; } MVectorArray outPosArray = farray.array(); MVectorArray outScaleArray = scalearray.array(); MVectorArray outRotateArray = rotatearray.array(); MDoubleArray outReplaceArray = replaceArrayFn.array(); if( outPosArray.length() < 1) { block.setClean(plug); return MS::kSuccess; } computePPAttribs(outPosArray, outRotateArray, outScaleArray, outReplaceArray, ngroups); float result = outPosArray.length(); MDataHandle outputHandle = block.outputValue( outValue ); outputHandle.set( result ); block.setClean(plug); } if(plug == outValue1) { MArrayDataHandle hArray = block.inputArrayValue(ainexamp); updateExamples(hArray); float result = 91.f; MDataHandle outputHandle = block.outputValue( outValue1 ); outputHandle.set( result ); block.setClean(plug); } return MS::kSuccess; }
gameGrid::gameGrid(void) { resetGrid(); }
void Reprojector::reprojectMap( FramePtr frame, std::vector< std::pair<FramePtr,std::size_t> >& overlap_kfs) { resetGrid(); // Identify those Keyframes which share a common field of view. SVO_START_TIMER("reproject_kfs"); list< pair<FramePtr,double> > close_kfs; map_.getCloseKeyframes(frame, close_kfs); // Sort KFs with overlap according to their closeness close_kfs.sort(boost::bind(&std::pair<FramePtr, double>::second, _1) < boost::bind(&std::pair<FramePtr, double>::second, _2)); // Reproject all mappoints of the closest N kfs with overlap. We only store // in which grid cell the points fall. size_t n = 0; overlap_kfs.reserve(options_.max_n_kfs); for(auto it_frame=close_kfs.begin(), ite_frame=close_kfs.end(); it_frame!=ite_frame && n<options_.max_n_kfs; ++it_frame, ++n) { FramePtr ref_frame = it_frame->first; overlap_kfs.push_back(pair<FramePtr,size_t>(ref_frame,0)); // Try to reproject each mappoint that the other KF observes for(auto it_ftr=ref_frame->fts_.begin(), ite_ftr=ref_frame->fts_.end(); it_ftr!=ite_ftr; ++it_ftr) { // check if the feature has a mappoint assigned if((*it_ftr)->point == NULL) continue; // make sure we project a point only once if((*it_ftr)->point->last_projected_kf_id_ == frame->id_) continue; (*it_ftr)->point->last_projected_kf_id_ = frame->id_; if(reprojectPoint(frame, (*it_ftr)->point)) overlap_kfs.back().second++; } } SVO_STOP_TIMER("reproject_kfs"); // Now project all point candidates SVO_START_TIMER("reproject_candidates"); { boost::unique_lock<boost::mutex> lock(map_.point_candidates_.mut_); auto it=map_.point_candidates_.candidates_.begin(); while(it!=map_.point_candidates_.candidates_.end()) { if(!reprojectPoint(frame, it->first)) { it->first->n_failed_reproj_ += 3; if(it->first->n_failed_reproj_ > 30) { map_.point_candidates_.deleteCandidate(*it); it = map_.point_candidates_.candidates_.erase(it); continue; } } ++it; } } // unlock the mutex when out of scope SVO_STOP_TIMER("reproject_candidates"); // Now we go through each grid cell and select one point to match. // At the end, we should have at maximum one reprojected point per cell. SVO_START_TIMER("feature_align"); for(size_t i=0; i<grid_.cells.size(); ++i) { // we prefer good quality points over unkown quality (more likely to match) // and unknown quality over candidates (position not optimized) if(reprojectCell(*grid_.cells.at(grid_.cell_order[i]), frame)) ++n_matches_; if(n_matches_ > (size_t) Config::maxFts()) break; } SVO_STOP_TIMER("feature_align"); }