P_GMPAGE cGmpagesMap::addPage(P_GMPAGE page){ P_GMPAGE page1 = NULL; if (findPage(page->getSerial())==NULL) //first page for a player { gmpages_map.insert(make_pair(page->getSerial(),page)); return page; } else //appends further pages { page1=findPage(page->getSerial()); while(page1->getNextPage() != NULL) page1=page1->getNextPage(); if (page1->getPageNumber() < 4) // allows a maximum of 3 pages for a single player (first page_number is 1) { page->setPrevPage(page1); page->setPageNumber((UI08)(page1->getPageNumber() + 1)); page1->setNextPage(page); return page; } else return NULL; //no page can be added, first a gm should solve one. } }
/************************************************************* ************ LRU-CLOCK Page Replacement Algorithm ************ *************************************************************/ void LRUClockPageReplacement(){ int numberOfPageFaults = 0; frame = malloc(sizeof(struct frames)); head = malloc(sizeof(struct frames)); tail = malloc(sizeof(struct frames)); head = frame; tail = frame; clock = frame; frame->next = NULL; frame->prev = head; frame->pageNum = inputSeq[0]; frame->refBit = 1; numberOfPageFaults += 1; int i, isPageAlreadyExists = 0; for (i=1; i<strlen(inputSeq); i++){ if (isspace(inputSeq[i]) == 0){ isPageAlreadyExists = findPage(inputSeq[i]); if (isPageAlreadyExists == 1){ toggleRefBitForExistingPage(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 1){ numberOfPageFaults += 1; framesLeft -= 1; addPageToTailOfFrame(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 0){ numberOfPageFaults += 1; iterateClock(); replacePage(inputSeq[i]); } } } printf("\n# of page replacements with LRU-CLOCK = %d\n",numberOfPageFaults-availableFrames); nbOfPageReplacementByAlgo = numberOfPageFaults-availableFrames; }
// returns -1 if page not in buffer static int setPin(Buffer *buf, DiskAddress diskPage, int val) { int i = findPage(buf, diskPage); if (i < 0) return -1; buf->pin[i] = val; return 0; }
/************************************************************* ************ LRU-STACK Page Replacement Algorithm ************ *************************************************************/ void LRUStackPageReplacement(){ int numberOfPageFaults = 0; frame = malloc(sizeof(struct frames)); head = malloc(sizeof(struct frames)); tail = malloc(sizeof(struct frames)); head = frame; tail = frame; frame->next = NULL; frame->prev = head; frame->pageNum = inputSeq[0]; numberOfPageFaults += 1; int i, isPageAlreadyExists = 0; for (i=1; i<strlen(inputSeq); i++){ if (isspace(inputSeq[i]) == 0){ isPageAlreadyExists = findPage(inputSeq[i]); if (isPageAlreadyExists == 1){ removeNodeFromFrame(inputSeq[i]); addPageToTailOfFrame(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 1){ numberOfPageFaults += 1; framesLeft -= 1; addPageToTailOfFrame(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 0){ numberOfPageFaults += 1; addPageToTailOfFrame(inputSeq[i]); removeNodeFromHead(); } } } printf("\n# of page replacements with LRU-STACK = %d\n",numberOfPageFaults-availableFrames); nbOfPageReplacementByAlgo = numberOfPageFaults-availableFrames; }
void Gui::drawPage( LGraphicsView *view, QGraphicsScene *scene, bool printing) { QApplication::setOverrideCursor(Qt::WaitCursor); ldrawFile.unrendered(); ldrawFile.countInstances(); writeToTmp(); Where current(ldrawFile.topLevelFile(),0); maxPages = 1; stepPageNum = 1; QString empty; Meta meta; firstStepPageNum = -1; lastStepPageNum = -1; findPage(view,scene,maxPages,empty,current,false,meta,printing); topOfPages.append(current); maxPages--; QString string = QString("%1 of %2") .arg(displayPageNum) .arg(maxPages); setPageLineEdit->setText(string); QApplication::restoreOverrideCursor(); }
void BufferManager::write(char * data, long pageNumber, long from, long size) { cout << "Write to page: " << pageNumber << " position: " << from << " size: " << size << endl; struct BufferUnit * bUnit = &(buffer.bufferUnit[findPage(pageNumber)]); memcpy(bUnit->data + from, data, size); bUnit->flagSCH = 1; }
void Gui::countPages() { if (maxPages < 1) { writeToTmp(); statusBarMsg("Counting"); Where current(ldrawFile.topLevelFile(),0); int savedDpn = displayPageNum; displayPageNum = 1 << 31; firstStepPageNum = -1; lastStepPageNum = -1; maxPages = 1; Meta meta; QString empty; stepPageNum = 1; findPage(KpageView,KpageScene,maxPages,empty,current,false,meta,false); topOfPages.append(current); maxPages--; if (displayPageNum > maxPages) { displayPageNum = maxPages; } else { displayPageNum = savedDpn; } QString string = QString("%1 of %2") .arg(displayPageNum) .arg(maxPages); setPageLineEdit->setText(string); statusBarMsg(""); } }
void FIFO(){ printf("===========*.*===========\n" ); printf("\tAlgorithm = FIFO\n"); printf("\tPageNUM = %d\n",P); printf(" =========*.*========= \n" ); int pageLost=0; int pageLostArr[1000]; int pageLostArrLen=0; int divBaseForLostArr=50000; int i=0; int curr=0; for(i=0;i<RW;i++){ if(findPage(workLoad[i])==1){ //find success }else{ pageLost++; page[curr]=workLoad[i]; curr=(curr+1)%P; } if(i%divBaseForLostArr==0 && i>0){ pageLostArr[pageLostArrLen]=pageLost; pageLostArrLen++; printf("Till %d the page lost rate is %f\n",i,pageLost*1.0/i); } } printf("\tPage Lost = %d\n\tPage Lost Rate = %f \n", pageLost,pageLost*1.0/RW ); printf("===========*.*===========\n\n" ); }
int lrubuf::allocbufid() { lpnode * itlp; int bufid = -1;; int k; if(freebuf > 0) { for(k=0; k<bufsize; k++) { if(lru_array[k] == NULL) { bufid = k; break; } } if(bufid < 0) { cout<<"Error---> freebuf is wrong in "<<className()<<"-allocbufid()"<<endl; exit(0); } } else if(freebuf == 0) { bufid = getevict(); syncbuf(findPage(lru_array[bufid]->pageid, disk_array(lru_array[bufid]->diskId))); leavemgr(lru_array[bufid]->pageid, disk_array(lru_array[bufid]->diskId)); } else { cout<<"Error---> freebuf is wrong in "<<className()<<"-allocbufid()"<<endl; exit(0); } return bufid; }
bool cGmpagesMap::deletePage(SERIAL serial,UI08 page_num){ P_GMPAGE page_del = NULL; page_del=findPage(serial, page_num); if ( page_del==NULL) return false; if ( page_del->getNextPage() == NULL && page_del->getPageNumber()==1) //only one page for the given player -> erase map entry { gmpages_map.erase(serial); return true; } else { page_del->getPrevPage()->setNextPage(page_del->getNextPage()); if (page_del->getNextPage() != NULL ) page_del->getNextPage()->setPrevPage(page_del->getPrevPage()); delete page_del; optimize_page_indexes(serial); return true; } }
void PMSettingsDialog::slotShowPage( ) { const QObject* w = sender( ); if( w ) { int index = findPage( ( const PMSettingsDialogPage* ) w ); if( index >= 0 ) showPage( index ); } }
int flushPage(Buffer *buf, DiskAddress diskPage) { int i = findPage(buf, diskPage); if (i < 0) return -1; tfs_writePage(diskPage.FD, diskPage.pageId, (unsigned char *) buf->pages[i].block); buf->dirty[i] = 0; return 0; }
KviTalWizardPageData * findPrevEnabledPage(QWidget * pReference) { if(!pReference) return findLastEnabledPage(); KviTalWizardPageData * pData = findPage(pReference); if(!pData) return NULL; for(pData = pPageList->prev();pData;pData = pPageList->prev()) { if(pData->bEnabled) return pData; } return NULL; }
void Module::init(bool isLoadingSave, const Common::String &pageName) { // 0 0 - new game // 0 1 - module changed // 1 0 - from save if (!pageName.empty()) _page = findPage(pageName); else if (!_page) _page = _pages[0]; _page->init(isLoadingSave); }
void Module::loadState(Archive &archive) { _invMgr.loadState(archive); _variables.deserialize(archive); for (uint i = 0; i < _pages.size(); ++i) { _pages[i]->loadState(archive); } _page = findPage(archive.readString()); _page->loadManagers(); _page->getLeadActor()->loadState(archive); }
int nobuf::requestbuf(LID pageid, iofdctl * disk) { npnode * tarp; tarp = findPage(pageid, disk); if(tarp == NULL) { entermgr(pageid, disk); if((tarp = findPage(pageid, disk)) == NULL) { cout<<"Exception---> findPage fail in bufmgr-requestbuf()"<<endl; exit(0); } disk->diskRead(&pageid, (BYTE*)(buffer+tarp->bufid*PAGE_SIZE), 1); io_read_num++; if(disk->diskType() == SSD_TYPE) _ssd_read_num++; else if(disk->diskType() == HDD_TYPE) _hdd_read_num++; } return (tarp->bufid*PAGE_SIZE); }
void KivioMap::movePage( const QString& fromPageName, const QString& toPageName, bool before ) { KivioPage* pagefrom = findPage(fromPageName); KivioPage* pageto = findPage(toPageName); int from = m_lstPages.find(pagefrom); int to = m_lstPages.find(pageto); if (!before) ++to; if ( to > (int)m_lstPages.count() ) { m_lstPages.append(pagefrom); m_lstPages.take(from); } else if ( from < to ) { m_lstPages.insert(to,pagefrom); m_lstPages.take(from); } else { m_lstPages.take(from); m_lstPages.insert(to,pagefrom); } }
KviTalWizardPageData * findNextEnabledPage(QWidget * pReference) { if(!pReference) return findFirstEnabledPage(); KviTalWizardPageData * pData = findPage(pReference); if(!pData) return nullptr; for(pData = pPageList->next(); pData; pData = pPageList->next()) { if(pData->bEnabled) return pData; } return nullptr; }
void lrubuf::clearbuf() { int k; npnode * tarp; for(k=0; k<bufsize; k++) { if(lru_array[k] != NULL){ tarp = findPage(lru_array[k]->pageid, disk_array(lru_array[k]->diskId)); syncbuf(tarp); leavemgr(tarp->pageid, disk_array(tarp->diskId)); } } lru = -1; mru = -1; freebuf = bufsize; }
/* virtual */ SysStatus FCMDefault::ioComplete(uval fileOffset, SysStatus rc) { tassert(_SUCCESS(rc), err_printf("bogus return on I/O request <%ld %ld %ld>\n", _SERRCD(rc), _SCLSCD(rc), _SGENCD(rc))); //err_printf("fill Complete for %lx, trying lock....\n", fileOffset); lock.acquire(); //err_printf("got lock for fill Complete for %lx\n", fileOffset); PageDesc *pg = findPage(fileOffset); tassert(pg && pg->doingIO, err_printf("bad request from FR %lx\n", fileOffset)); tassert(!(pg->forkIO), err_printf("why are we here with forkIO set?\n")); ioCompleteInternal(pg, rc); // the FR doesn't care what we did with the frame - always return ok return 0; }
bool cGmpagesMap::optimize_page_indexes(SERIAL serial){ //rearranges pages indexes (page_number) not used for the moment P_GMPAGE tmp_page = NULL; if ((tmp_page = findPage (serial))== NULL) //No need to rearrange pages id. return false; do{ if( tmp_page->getNextPage()->getPageNumber() != (tmp_page->getPageNumber() + 1)) { tmp_page->getNextPage()->setPageNumber((UI08)(tmp_page->getPageNumber() + 1)); } tmp_page = tmp_page->getNextPage(); }while(tmp_page->getNextPage() != NULL); return true; }
void lrubuf::leavemgr(LID pageid, iofdctl * disk) { npnode * tarp = findPage(pageid, disk); npnode * itp; npnode * pre; if(tarp == NULL) { cout<<"Exception---> find exist page fail in "<<className()<<endl; exit(0); } rmlru(tarp->bufid); int hashid = pageid % bufsize; if(mgr_array[hashid] == NULL) { cout<<"Error---> mgr_array has problems in "<<className()<<" leavemgr()"<<endl; exit(0); } if(mgr_array[hashid] == tarp) mgr_array[hashid] = tarp->next; else { itp = mgr_array[hashid]->next; pre = mgr_array[hashid]; while(itp != NULL) { if(itp == tarp) break; pre = itp; itp = itp->next; } if(itp == NULL) { cout<<"Error---> mgr_array has problems in "<<className()<<" leavemgr()"<<endl; exit(0); } pre->next = itp->next; } delete tarp; freebuf++; }
void fax2ps(TIFF* tif, int npages, int* pages, char* filename) { if (npages > 0) { uint16 pn, ptotal; int i; if (!GetPageNumber(tif)) fprintf(stderr, "%s: No page numbers, counting directories.\n", filename); for (i = 0; i < npages; i++) { if (findPage(tif, pages[i])) printTIF(tif, pages[i]); else fprintf(stderr, "%s: No page number %d\n", filename, pages[i]); } } else { int pageNumber = 1; do printTIF(tif, pageNumber++); while (TIFFReadDirectory(tif)); } }
/************************************************************* ************** LRU Page Replacement Algorithm **************** *************************************************************/ void LRURefPageReplacement(){ int numberOfPageFaults = 0,j; frame = malloc(sizeof(struct frames)); head = malloc(sizeof(struct frames)); tail = malloc(sizeof(struct frames)); head = frame; tail = frame; frame->next = NULL; frame->prev = head; frame->pageNum = inputSeq[0]; for (j=0;j<8;j++) frame->refBitArray[j] = 0; int i, isPageAlreadyExists = 0; frame->refBitDecimalValue = binToDecimal(frame->refBitArray); numberOfPageFaults += 1; for (i=0; i<strlen(inputSeq); i++){ if (isspace(inputSeq[i]) == 0){ isPageAlreadyExists = findPage(inputSeq[i]); if (isPageAlreadyExists == 1){ shiftBits(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 1){ numberOfPageFaults += 1; framesLeft -= 1; addPageToTailOfFrame(inputSeq[i]); addShiftBits(inputSeq[i]); }else if (isPageAlreadyExists == 0 && isFrameAvailable() == 0){ numberOfPageFaults += 1; char victimPage = findVictimPage(); removeNodeFromFrame(victimPage); addPageToTailOfFrame(inputSeq[i]); addShiftBits(inputSeq[i]); } } } printf("\n# of page replacements with LRU-REF8 = %d\n",numberOfPageFaults-availableFrames); nbOfPageReplacementByAlgo = numberOfPageFaults-availableFrames; }
SysStatus FCMDefault::releasePage(uval fileOffset, uval dirty) { PageDesc* pg; lock.acquire(); pg = findPage(fileOffset); tassertMsg(pg && pg->pinCount,"release non locked page\n"); tassertMsg(!mapBase, "Should not be unpinning while mapBase is true\n"); if (dirty) { DILMA_TRACE_PAGE_DIRTY(this,pg,1); pg->dirty=PageDesc::SET; } pg->pinCount--; if (pg->pinCount == 0) { pinnedCount--; #if 0 //FIXME - do we need notification when pincount goes to zero // notify anyone who might have blocked on this, and free lock notify(pg, 0, 0, 1); #endif } //N.B. returns with lock released return locked_removeReference(); }
/* * This routine may need to drop locks to handle cases where the page is * not in the cache. To reinforce this, locks should not be held when * calling this routine. Lock is held on return so that operation can * complete automatically. In the future, we may return with only the * page individually locked. * N.B. lock is NOT held if no page found and can't allocate one */ PageDesc * FCMDefault::findOrAllocatePageAndLock(uval fileOffset, SysStatus &rc, uval &needsIO, uval flags) { PageDesc *pg; uval paddr; needsIO = 0; rc = 0; #ifndef ENABLE_FCM_SWITCHING lock.acquire(); #else /* #ifndef ENABLE_FCM_SWITCHING */ if (!lock.tryAcquire()) { if (!KernelInfo::ControlFlagIsSet(KernelInfo::RUN_SILENT)) { //err_printf("Lock contended... initiating switch.\n"); } //breakpoint(); ((FCMDefaultRoot *)myRoot)->switchImplToMultiRep(); // use above for normal switching below for testing null hot swap times //if (performedSwitch == 0) { // TraceOSClustObjSwapStart((uval64)myRoot); // ((FCMDefaultRoot *)myRoot)-> // switchImplToSameRep((FCMDefaultRoot *)myRoot); // TraceOSClustObjSwapDone((uval64)myRoot); // performedSwitch = 1; //} lock.acquire(); } #endif /* #ifndef ENABLE_FCM_SWITCHING */ pg = findPage(fileOffset); if (pg != NULL) { //err_printf("H"); TraceOSMemFCMDefFoundPage(fileOffset, pg->paddr); if (pg->doingIO) { pg->freeAfterIO = PageDesc::CLEAR; } } else { //err_printf("[TID#%lx:]", Scheduler::GetCurThread()); //err_printf("X"); // allocate a new page pg = addPage(fileOffset, uval(-1), pageSize); pg->doingIO = PageDesc::SET; needsIO = 1; rc = getFrame(paddr,flags); if (_FAILURE(rc)) { // must clean up pagedesc we added and wakeup anyone waiting // notify but retain lock notify(pg, 0, 0, 1); pageList.remove(fileOffset); lock.release(); return NULL; // no paging space } // traceStep8: add the code in a .C/.H file to log the event // an example may be found in mem/FCMDeafult.C traceStep8 TraceOSMemFCMDefGetPage(fileOffset, paddr); // set pagedesc paddr pg->paddr = paddr; // indicate that we have taken ownership of page //PageAllocatorKernPinned::initFrameDesc(paddr, getRef(), // fileOffset, 0); } return pg; }
int main(void) { ProtoMsg msg; msg.type = -1; msg.msgLen = 0; size_t i = 0; init_pages(); do { recvMsg(IN, &msg, sizeof(msg)); switch (msg.type) { case (PROTO_GET): { if (msg.msgLen == 0) { i = 0; } else { //this could overflow if msgLen is > PAGE_SIZE // this is counting on the router to make sure it doesn't happen . . . recvMsg(IN, gBuf, msg.msgLen); gBuf[msg.msgLen] = '\0'; i = findPage((char*)gBuf); } msg.type = PROTO_GET_ACK; if (i >= MAX_LINKS) { #ifdef PATCHED msg.msgLen = snprintf(gOutBuf, PAGE_SIZE, "#s : #s", (char*)gBuf, gPageNotFoundError); #else msg.msgLen = snprintf(gOutBuf, PAGE_SIZE, (char*)gBuf); msg.msgLen += snprintf(gOutBuf + msg.msgLen, PAGE_SIZE - msg.msgLen, " : #s", gPageNotFoundError); #endif sendMsg(OUT, &msg, sizeof(msg)); sendMsg(OUT, gOutBuf, msg.msgLen); } else { msg.msgLen = gPages[i].len; sendMsg(OUT, &msg, sizeof(msg)); sendMsg(OUT, gPages[i].data, msg.msgLen); } break; } case (PROTO_BYE): { return (0); } default: { msg.type = PROTO_ERROR; msg.msgLen = 0; break; } } } while (1); return (-1); }
void Module::changePage(const Common::String &pageName) { _page->unload(); _page = findPage(pageName); _page->init(kLoadingNewGame); }
int allocateCachePage(Buffer *buf, DiskAddress diskpage){ int i, bufIndex, oldestCache = 0, oldestBuf = -1; /* check if this file has been opened before in volatile */ if (checkVolatileFiles(buf, diskpage.FD) == -1) { buf->numVolatileFiles += 1; buf->volatileFDs = (int *)realloc(buf->volatileFDs, sizeof(int) * buf->numVolatileFiles); buf->volatileFDs[buf->numVolatileFiles-1] = diskpage.FD; } /* check if this page is already in cache */ i = findPageVolatile(buf, diskpage); if (i != -1) return i; /* check if this page is already in persistent buffer */ bufIndex = findPage(buf, diskpage); //Check if cache is full if(buf->nCacheBlocks == buf->numCacheOccupied){ //Find index of least recently used for eviction for(i = 0; i < buf->nCacheBlocks; i++){ if(buf->cache_timestamp[oldestCache] > buf->cache_timestamp[i]) { oldestCache = i; } } buf->cache_timestamp[oldestCache] = -1; //Check if buffer is full if(buf->nBufferBlocks == buf->numBufferOccupied){ //If it is full find the least recently used unpinned page and write to disk for(i = 0; i < buf->nBufferBlocks; i++){ if(buf->pin[i] == 0 && (oldestBuf == -1 || buf->buffer_timestamp[oldestBuf] > buf->buffer_timestamp[i])) { oldestBuf = i; } } if (oldestBuf == -1) // all pages were pinned return -1; writePage(buf, buf->pages[oldestBuf].address); flushPage(buf, buf->pages[oldestBuf].address); } else { //If it is not full then find empty spot and insert into buffer for(i = 0; i < buf->nBufferBlocks; i++){ if(buf->buffer_timestamp[i] == -1){ oldestBuf = i; buf->numBufferOccupied++; buf->buffer_timestamp[i] = time(NULL); break; } } } //Copy the block from the cache into the buffer memcpy(&(buf->pages[oldestBuf]), &(buf->cache[oldestCache]), sizeof(Block)); buf->pin[oldestBuf] = 1; } //Write the diskapage passed into the now open cache spot for(i = 0; i < buf->nCacheBlocks; i++){ if(buf->cache_timestamp[i] == -1){ buf->cache[i].address.pageId = diskpage.pageId; buf->cache[i].address.FD = diskpage.FD; buf->numCacheOccupied++; buf->cache_timestamp[i] = time(NULL); /* if page was already in persistent buffer, copy its data into this cache spot */ if (bufIndex != -1) { memcpy(buf->cache[i].block, &buf->pages[bufIndex].block, BLOCKSIZE); /* remove page from persistent buffer */ buf->buffer_timestamp[bufIndex] = -1; buf->pin[bufIndex] = 0; buf->numBufferOccupied--; } break; } } return i; }
std::vector<cv::Rect> HelperOpenCV::findHighLightArea(cv::Mat inputImage) { std::vector<cv::Rect> vectorRect; vectorRect.clear(); cv::Mat inputMat = inputImage.clone(); //cv::resize(inputImage, inputMat, cv::Size(1280, 1280)); cv::Rect pageRect = findPage(inputMat); int flags = 4 + (255 << 8) + (1 == 1 ? CV_FLOODFILL_FIXED_RANGE : 0); cv::Vec3b back = inputMat.at<cv::Vec3b>(0, 0); cv::Mat mask; mask.create(inputMat.rows + 2, inputMat.cols + 2, CV_8UC1); mask = cv::Scalar::all(0); cv::Mat dst = inputMat.clone(); cv::cvtColor(inputMat, dst, CV_BGRA2BGR); cv::Rect rectTop; floodFill(dst, cv::Point(0,0), cv::Scalar(255, 255, 255), &rectTop, cv::Scalar(20, 20, 20),cv::Scalar(70, 70, 70), flags); floodFill(dst, cv::Point(dst.cols - 1,0), cv::Scalar(255, 255, 255), &rectTop, cv::Scalar(20, 20, 20),cv::Scalar(70, 70, 70), flags); floodFill(dst, cv::Point(0,dst.rows - 1), cv::Scalar(255, 255, 255), &rectTop, cv::Scalar(20, 20, 20),cv::Scalar(70, 70, 70), flags); floodFill(dst, cv::Point(dst.cols - 1,dst.rows - 1), cv::Scalar(255, 255, 255), &rectTop, cv::Scalar(20, 20, 20),cv::Scalar(70, 70, 70), flags); cv::Rect ccomp; cv::Mat mask1; cv::Mat maskDark; cv::Mat maskWhite; cv::inRange(dst, cv::Scalar(150, 150, 150, 0), cv::Scalar(255, 255, 255, 255), mask1); cv::bitwise_not(mask1, mask1); cv::Mat element = getStructuringElement( cv::MORPH_RECT, cv::Size( 13, 13 ), cv::Point( 6, 6) ); cv::erode(mask1, mask1, element); cv::Mat element1 = getStructuringElement( cv::MORPH_RECT, cv::Size( 5, 5 ), cv::Point( 2, 2) ); cv::dilate(mask1, mask1, element1); cv::Mat dest; dest.create(inputMat.rows, inputMat.cols, inputMat.type()); dest = cv::Scalar(255, 255, 255); inputMat.copyTo(dest, mask1); cv::Mat mask3; cv::inRange(dest, cv::Scalar(0, 0, 0, 0), cv::Scalar(50, 50, 50, 255), mask3); cv::bitwise_not(mask3, mask3); cv::Rect rect; cv::Mat mask2; cv::Mat result; result = inputMat.clone(); cv::Mat resized; cv::resize(inputMat, resized, cv::Size(inputMat.cols + 2, inputMat.rows + 2)); mask2.create(inputMat.rows + 2, inputMat.cols + 2, CV_8UC1); mask2 = cv::Scalar::all(0); for (int i = 0; i < mask1.rows; i++) for (int j = 0; j < mask1.cols; j++) { uchar k = mask1.at<uchar>(i, j); uchar k1 = mask3.at<uchar>(i,j); if (pageRect.width != 0) if (!(i > pageRect.y && j > pageRect.x && i < pageRect.y + pageRect.height && j < pageRect.x + pageRect.width)) continue; if (k == 255 && k1 == 255) { mask2 = cv::Scalar::all(0); int area = cv::floodFill(mask1, mask2, cv::Point(j, i), cv::Scalar(0), &rect, cv::Scalar(0), cv::Scalar(20), flags); if (area > 2000) { cv::rectangle(result, rect, cv::Scalar(0, 255,0), 2); cv::Mat m; m.create(inputMat.rows + 2, inputMat.cols + 2, inputMat.type()); m = cv::Scalar(255, 255, 255); resized.copyTo(m, mask2); int dmax = 5; int k = 1; for (int l = 0; l < dmax; l++) { if ((rect.x - k >=0 && rect.x + rect.width + k < m.cols)) { rect.x = rect.x - k; rect.width += 2*k; } if ((rect.y - k >=0 && rect.y + rect.height + k < m.rows)) { rect.y = rect.y - k; rect.height += 2*k; } } vectorRect.push_back(rect); //cv::rectangle(inputImage, cv::Rect(rect.x , rect.y , (int)(rect.width ), (int)(rect.height )), cv::Scalar(0, 255,0), 2); } } } return vectorRect; }