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;
}
