void TileBoundsCalculator::setImages(const cv::Mat& r1, const cv::Mat& r2)
{
_r1 = r1;
_r2 = r2;
_calculateMin();
_exportImage(_r1, "tmp/r1.png");
_exportImage(_r2, "tmp/r2.png");
_exportImage(_min, "tmp/min.png");
}
void TileBoundsCalculator::renderImage(shared_ptr<OsmMap> map)
{
_envelope = map->calculateBounds();
renderImage(map, _r1, _r2);
_calculateMin();
_exportImage(_r1, "tmp/r1.png");
_exportImage(_r2, "tmp/r2.png");
_exportImage(_min, "tmp/min.png");
}
unsigned int SipperProxyQueue::eventDequeueBlk(SipperProxyQueueData *outdata, unsigned int count,
unsigned int timeout, bool blockFlag)
{
int oldstate;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
pthread_mutex_lock(&tEventQueueMutex);
while(sleepingConsumers == MAX_QUEUE_THR && bQueueStopped == false)
{
waitingConsumers++;
pthread_cond_wait(&waitingConsumerCond, &tEventQueueMutex);
waitingConsumers--;
}
unsigned int ret = 0;
t_EventQueueNodePtr currNode = NULL;
int consumerIdx = -1;
int alreadyTimedOut = 0;
int timeCalculated = 0;
struct timespec WaitTime;
do
{
//Logically this if condition should not be there. When the queue is
//stopped still deque should be successful till there are messages held in
//queue. This condition will raise memory leak as consumers cant get the
//messages. Only reason I thought of why this condition was added is
//during shutdown we want the consumer to come out quickly- Suriya.
//Now a CleanupFunction registeration is added to take care of the memory
//leak caused because of this condition.
if(bQueueStopped == true)
{
break;
}
for(; ret < count; ret++)
{
if(ptHeadPtr != NULL)
{
currNode = ptHeadPtr;
ptHeadPtr = ptHeadPtr->ptNextNode;
iQueueCount--;
outdata[ret] = currNode->_queueData;
if(iFreeNodes < highWaterMark)
{
currNode->ptNextNode = ptFreeList;
ptFreeList = currNode;
iFreeNodes++;
}
else
{
delete currNode;
}
if(ptHeadPtr == NULL)
{
ptTailPtr = NULL;
}
}
else
{
break;
}
}
if(ret == count || blockFlag == false)
{
break;
}
if(bQueueStopped == true)
{
pthread_cond_broadcast(&waitingConsumerCond);
break;
}
if(consumerIdx == -1)
{
consumerIdx = _getFreeThr(consumerData);
}
if((count - ret) >= highWaterMark)
{
consumerData[consumerIdx].count = highWaterMark;
}
else
{
consumerData[consumerIdx].count = count - ret;
}
if(minConsumer != -1)
{
if(consumerData[minConsumer].count > consumerData[consumerIdx].count)
{
minConsumer = consumerIdx;
}
}
else
{
minConsumer = consumerIdx;
}
//Queue is Empty.
if(sleepingFeeders)
{
int locid = _calculateMax(feederData);
pthread_cond_signal(&feederData[locid].condition);
}
if(alreadyTimedOut)
{
break;
}
sleepingConsumers++;
if(timeout == 0)
{
pthread_cond_wait(&consumerData[consumerIdx].condition,
&tEventQueueMutex);
}
else
{
if(timeCalculated == 0)
{
struct timeval currTime;
gettimeofday(&currTime, NULL);
WaitTime.tv_sec = currTime.tv_sec;
WaitTime.tv_nsec = (currTime.tv_usec * 1000);
WaitTime.tv_sec += (timeout / 1000);
long millisec = timeout % 1000;
WaitTime.tv_nsec += (millisec * 1000000);
if(WaitTime.tv_nsec >= 1000000000L)
{
WaitTime.tv_nsec -= 1000000000L;
WaitTime.tv_sec++;
}
timeCalculated = 1;
}
if(pthread_cond_timedwait(&consumerData[consumerIdx].condition,
&tEventQueueMutex, &WaitTime) == ETIMEDOUT)
{
alreadyTimedOut = 1;
}
}
sleepingConsumers--;
}while(1);
if(consumerIdx != -1)
{
consumerData[consumerIdx].count = 0;
if(minConsumer == consumerIdx)
{
minConsumer = _calculateMin(consumerData);
}
}
if(sleepingFeeders)
{
if((feederData[minFeeder].count <= iFreeNodes) ||
(iQueueCount <= lowWaterMark))
{
pthread_cond_signal(&feederData[minFeeder].condition);
}
}
if(sleepingConsumers)
{
if(consumerData[minConsumer].count <= iQueueCount)
{
pthread_cond_signal(&consumerData[minConsumer].condition);
}
}
if(waitingConsumers)
{
pthread_cond_signal(&waitingConsumerCond);
}
pthread_mutex_unlock(&tEventQueueMutex);
pthread_setcancelstate(oldstate, NULL);
return ret;
}
unsigned int SipperProxyQueue::eventEnqueueBlk(SipperProxyQueueData *indata, unsigned int count)
{
int oldstate;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);
pthread_mutex_lock(&tEventQueueMutex);
if(bQueueStopped == true)
{
pthread_mutex_unlock(&tEventQueueMutex);
pthread_setcancelstate(oldstate, NULL);
return 0;
}
while(sleepingFeeders == MAX_QUEUE_THR && bQueueStopped == false)
{
waitingFeeders++;
pthread_cond_wait(&waitingFeederCond, &tEventQueueMutex);
waitingFeeders--;
}
unsigned int ret = 0;
t_EventQueueNodePtr currNode = NULL;
int feederIdx = -1;
do
{
if(bQueueStopped == true)
{
break;
}
for(; ret < count; ret++)
{
if(ptFreeList != NULL)
{
currNode = ptFreeList;
ptFreeList = ptFreeList->ptNextNode;
iFreeNodes--;
}
else
{
if(flowControlEnabled == false)
{
currNode = new t_EventQueueNode;
}
else
{
break;
}
}
currNode->_queueData = indata[ret];
currNode->ptNextNode = NULL;
if(ptHeadPtr == NULL)
{
ptTailPtr = ptHeadPtr = currNode;
}
else
{
ptTailPtr->ptNextNode = currNode;
ptTailPtr = currNode;
}
iQueueCount++;
}
if(ret == count)
{
break;
}
if(feederIdx == -1)
{
feederIdx = _getFreeThr(feederData);
}
if((count - ret) >= highWaterMark)
{
feederData[feederIdx].count = highWaterMark;
}
else
{
feederData[feederIdx].count = count - ret;
}
if(minFeeder != -1)
{
if(feederData[minFeeder].count > feederData[feederIdx].count)
{
minFeeder = feederIdx;
}
}
else
{
minFeeder = feederIdx;
}
//Queue is Full.
if(sleepingConsumers)
{
int locid = _calculateMax(consumerData);
pthread_cond_signal(&consumerData[locid].condition);
}
sleepingFeeders++;
pthread_cond_wait(&feederData[feederIdx].condition, &tEventQueueMutex);
sleepingFeeders--;
}while(1);
if(feederIdx != -1)
{
feederData[feederIdx].count = 0;
if(minFeeder == feederIdx)
{
minFeeder = _calculateMin(feederData);
}
}
if(sleepingFeeders)
{
if((feederData[minFeeder].count <= iFreeNodes) ||
(iQueueCount <= lowWaterMark))
{
pthread_cond_signal(&feederData[minFeeder].condition);
}
}
if(sleepingConsumers)
{
if(consumerData[minConsumer].count <= iQueueCount)
{
pthread_cond_signal(&consumerData[minConsumer].condition);
}
}
if(waitingFeeders)
{
pthread_cond_signal(&waitingFeederCond);
}
pthread_mutex_unlock(&tEventQueueMutex);
pthread_setcancelstate(oldstate, NULL);
return ret;
}
