bool ImageRefocus::createRefocusInstance() {
ALOGI("<createRefocusInstance>createRefocusInstance start");
// init
mRefocusInitInfo.pTuningInfo = &mRefocusTuningInfo;
getTime(&mStartSec, &mStartNsec);
mRefocus = mRefocus->createInstance(DRV_REFOCUS_OBJ_SW);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<createRefocusInstance>performance createInstance time:%d", mTimeDiff);
MUINT32 initResult;
getTime(&mStartSec, &mStartNsec);
initResult = mRefocus->RefocusInit((MUINT32 *)&mRefocusInitInfo, 0);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<createRefocusInstance>performance RefocusInit time %d", mTimeDiff);
if (initResult != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus createRefocusInstance fail ");
return FAIL;
}
ALOGI("<createRefocusInstance>createRefocusInstance success ");
return SUCCESS;
}
void ImageRefocus::saveRefocusImage(const char *saveFileName, int inSampleSize) {
char file[FILE_NAME_LENGTH];
FILE *fp;
unsigned char *jpgBuf = NULL;
unsigned int jpegSize = 0;
mRefocusImageInfo.TouchCoordX = mRefocusImageInfo.TouchCoordX * inSampleSize;
mRefocusImageInfo.TouchCoordY = mRefocusImageInfo.TouchCoordY * inSampleSize;
mRefocusImageInfo.DepthOfField = mRefocusImageInfo.DepthOfField * inSampleSize;
getTime(&mStartSec, &mStartNsec);
initRefocusIMGSource(mSourceFileName, mRefocusImageInfo.TargetWidth * inSampleSize,
mRefocusImageInfo.TargetHeight * inSampleSize, 0);
if (createRefocusInstance() && setBufferAddr() && generate()) {
ALOGI("<saveRefocusImage>image refocus init end, success");
} else {
ALOGI("ERROR: image refocus init fail!!!");
return;
}
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<saveRefocusImage>performance generate time:%d", mTimeDiff);
sprintf(file, "%s", saveFileName);
ALOGI("<saveRefocusImage>test file:%s", file);
fp = fopen(file, "w");
if (fp == NULL) {
ALOGI("ERROR: Open file %s failed!!!", file);
return;
}
// should free this memory when not use it !!!
int imageWidth = mRefocusResultInfo.RefocusImageWidth;
int imageHeight = mRefocusResultInfo.RefocusImageHeight;
jpgBuf = (unsigned char *) malloc(imageWidth * imageHeight);
if (jpgBuf == NULL) {
ALOGI("ERROR: Can not allocate memory!!!");
fclose(fp);
return;
}
if (NULL != m_DebugUtils) {
m_DebugUtils->dumpBufferToFile("save.yuv", mRefocusResultInfo.RefocusedYUVImageAddr,
imageWidth*imageHeight*3/2);
}
ALOGI("<saveRefocusImage>RefocusedYUVImageAddr:%p", (size_t)mRefocusResultInfo.RefocusedYUVImageAddr);
getTime(&mStartSec, &mStartNsec);
m_pJpegFactory->yv12ToJpg((unsigned char *)mRefocusResultInfo.RefocusedYUVImageAddr, imageWidth * imageHeight,
imageWidth, imageHeight, jpgBuf, imageWidth * imageHeight, &jpegSize);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<saveRefocusImage>performance yv12ToJpg time:%d", mTimeDiff);
dumpBufferToFile(jpgBuf, jpegSize, file);
free(jpgBuf);
fclose(fp);
jpgBuf = NULL;
}
bool ImageRefocus::generate() {
MUINT32 result;
// algorithm - gen depth map
ALOGI("<generate>generate start,RcfyError:%d,JPSOrientation:%d",
mRefocusImageInfo.RcfyError, mRefocusImageInfo.JPSOrientation);
getTime(&mStartSec, &mStartNsec);
result = mRefocus->RefocusFeatureCtrl(REFOCUS_FEATURE_ADD_IMG, (void *)&mRefocusImageInfo, NULL);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<generate>REFOCUS_FEATURE_ADD_IMG time:%d, result:%d", mTimeDiff, result);
if (result != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus ADD_IMG fail ");
return FAIL;
}
getTime(&mStartSec, &mStartNsec);
result = mRefocus->RefocusMain();
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<generate>RefocusMain time:%d, result:%d", mTimeDiff, result);
if (result != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus RefocusMain fail ");
return FAIL;
}
getTime(&mStartSec, &mStartNsec);
result = mRefocus->RefocusFeatureCtrl(REFOCUS_FEATURE_GET_RESULT, NULL, (void *)&mRefocusResultInfo);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<generate>REFOCUS_FEATURE_GET_RESULT time:%d, result:%d", mTimeDiff, result);
ALOGI("<generate>RefocusImageWidth:%d,RefocusImageHeight:%d,DepthBufferWidth:%d,DepthBufferHeight:%d",
mRefocusResultInfo.RefocusImageWidth, mRefocusResultInfo.RefocusImageHeight,
mRefocusResultInfo.DepthBufferWidth, mRefocusResultInfo.DepthBufferHeight);
ALOGI("<generate>DepthBufferSize:%d,DepthBufferAddr:%p", mRefocusResultInfo.DepthBufferSize,
mRefocusImageInfo.DepthBufferAddr);
if (result != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus GET_RESULT fail ");
return FAIL;
}
if (mRefocusImageInfo.DepthBufferAddr == NULL) {
MUINT8* depthBuffer = new MUINT8[mRefocusResultInfo.DepthBufferSize];
memcpy(depthBuffer, mRefocusResultInfo.DepthBufferAddr, mRefocusResultInfo.DepthBufferSize);
mRefocusImageInfo.DepthBufferAddr = depthBuffer;
mRefocusImageInfo.DepthBufferSize = mRefocusResultInfo.DepthBufferSize;
copyRefocusResultInfo(&mRefocusResultInfo);
ALOGI("<generate>copy depthBuffer from %p to %p", mRefocusResultInfo.DepthBufferAddr, depthBuffer);
}
return SUCCESS;
}
bool ImageRefocus::setBufferAddr() {
ALOGI("<setBufferAddr> start");
// get buffer size
MUINT32 result;
MUINT32 buffer_size;
getTime(&mStartSec, &mStartNsec);
ALOGI("<setBufferAddr> TargetWidth %d, TargetHieght %d, TargetImgAddr %p ImgNum %d, Width %d Height %d ImgAddr %p "
"DepthBufferAddr %p DepthBufferSize %d Orientation %d MainCamPos %d", mRefocusImageInfo.TargetWidth,
mRefocusImageInfo.TargetHeight, mRefocusImageInfo.TargetImgAddr, mRefocusImageInfo.ImgNum,
mRefocusImageInfo.Width, mRefocusImageInfo.Height, mRefocusImageInfo.ImgAddr,
mRefocusImageInfo.DepthBufferAddr, mRefocusImageInfo.DepthBufferSize ,
mRefocusImageInfo.JPSOrientation , mRefocusImageInfo.MainCamPos);
result = mRefocus->RefocusFeatureCtrl(REFOCUS_FEATURE_GET_WORKBUF_SIZE, (void *)&mRefocusImageInfo,
(void *)&buffer_size);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<setBufferAddr>performance get_workbuff_size time:%d", mTimeDiff);
ALOGI("<setBufferAddr>REFOCUS_FEATURE_GET_WORKBUF_SIZE buffer size %d, result %d ", buffer_size, result);
if (result != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus GET_WORKBUF_SIZE fail ");
return FAIL;
}
// set buffer address
// unsigned char *pWorkingBuffer = new unsigned char[buffer_size];
pWorkingBuffer = (unsigned char *) malloc(buffer_size);
mRefocusInitInfo.WorkingBuffAddr = (MUINT8*)pWorkingBuffer;
getTime(&mStartSec, &mStartNsec);
ALOGI("<setBufferAddr> SET_WORKBUF_ADDR start");
result = mRefocus->RefocusFeatureCtrl(REFOCUS_FEATURE_SET_WORKBUF_ADDR,
(void *)&mRefocusInitInfo.WorkingBuffAddr, NULL);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<setBufferAddr>performance mRefocus->set_workbuff_size time:%d", mTimeDiff);
if (result != S_REFOCUS_OK) {
ALOGI("ERROR: image refocus SET_WORKBUF_ADDR fail ");
return FAIL;
}
ALOGI("<setBufferAddr> SET_WORKBUF_ADDR success");
return SUCCESS;
}
void GameLoop::loop()
{
beforeExeTime = clock();
long deltaTime = getTimeDiff();
// Set state
if(!this->m_States[this->m_CurrentState]->isLoaded())
{
// display loading screen
loaders::LoadState::loadState(this->m_States[this->m_CurrentState]);
}
// calc user movement
// calc ai movement
// calc physics
// pre render (pixel shaders, camera effects)
// render
static int frameNum = 0;
if(frame)
frameNum++;
if(frameNum > 1743)
frameNum = 0;
((renderers::OpenGLRender*)m_Renderer)->frame = frameNum;
m_Renderer->draw(m_States[this->m_CurrentState]);
// post render
long t_current = clock();
afterExeTime = clock();
exeTimer = t_current - afterExeTime + 5;
if (exeTimer < 5)
{
exeTimer = 5;
}
}
std::ostream& pLog() {
timeval time = getTimeDiff();
std::ostream& str = std::clog;
str << "[" << time.tv_sec << "." << time.tv_usec << "] ";
return str;
}
std::ostream& pError() {
timeval time = getTimeDiff();
std::ostream& str = std::cerr;
str << "[" << time.tv_sec << "." << time.tv_usec << "] ";
return str;
}
/**@brief Start a new lap, log the time since last time point and reset the currentLap_ to now
*
* @param newLapName A name for the new lap, defaults to current lap number
* @param lastLapName A name for the last lap if a change is desired otherwise is logged as currentLapName_;
*/
void startNewLap(const std::string & newLapName = "",
const std::string & lastLapName = ""){
auto timeNew = sch::high_resolution_clock::now();
if(lastLapName == ""){
lapTimes_.emplace_back(currentLapName_, getTimeDiff(currentLap_, timeNew));
}else{
lapTimes_.emplace_back(lastLapName, getTimeDiff(currentLap_, timeNew));
}
if(newLapName == ""){
currentLapName_ = to_string(lapTimes_.size() + 1);
}else{
currentLapName_ = newLapName;
}
currentLap_ = timeNew;
}
/**
* Handle SIGINT and close socket and SIGUSR1
*
* For SIGUSR1 do calculations for correct output
*
* @param int sig Signal code
*/
void term(int sig)
{
if(sig == SIGUSR1)
{
printf("=== [ Interval %d/%d ] === \n", count, arg.interval*arg.rate);
time_fix = getTimeDiff();
time_t ti;
struct tm *foo;
time( &ti);
foo = localtime( &ti );
char tim[20];
strftime(tim, 20, "%Y-%m-%d-%H:%M:%S", foo);
char *filename = malloc(sizeof(char)*96);
sprintf(filename, "%s%s-%d-%d", OUTPUT_FILE_PREFIX, arg.server, arg.size, arg.rate);
FILE* fp = fopen(filename, "a");
// calculate interval
fprintf(fp, "%s, %d, %d, %d, %d, %d, %.3f, %.3f, %.3f\n",
tim, // Time
arg.interval, // IntLen
arg.interval*arg.rate, // Pckt Sent
count, // Pckt Recv
arg.interval*arg.rate*arg.size, // Bytes Send
count*arg.size, // Bytes Recv
(((double)rtt_sum)/count)/1000, // Avg Delay
((double)(diff_max-diff_min)/1000), // Jitter PDV(x) = t(x) - A(x)
(out_of_order == 0) ? 0.0 : (out_of_order/count) // OutOfOrder %
);
fclose(fp);
free(filename);
count = -1;
rtt_sum = 0;
out_of_order = 0;
diff_min = -1;
diff_max = 0;
time_fix = getTimeDiff()-time_fix;
}
else
{
close(sockfd);
//printf("Exiting\n");
exit(0);
}
}
void getTimeDiffFromNow(const char* dateTime, uint32 &days, uint32 &hours)
{
days = 0;
hours = 0;
std::string now_str = getNowAsDateTime();
return getTimeDiff(now_str.c_str(), dateTime, days, hours);
}
/**
* Receive data from server and set corresponding values to global variables
*
* @param arguments arg Arguments structure
*/
void receiveData(arguments arg)
{
char *recvline = malloc(arg.size+1);
memset(recvline, 0, arg.size);
int n = 1;
uint32_t tim = 0, seq = 0, last_seq = 0, diff = 0;
count = -1;
rtt_sum = 0;
out_of_order = 0;
diff_min = -1;
diff_max = 0;
uint32_t last_tim = 0;
struct timeval tv;
tv.tv_sec = 10; /* 10 Secs Timeout */
tv.tv_usec = 0; // Not init'ing this can cause strange errors
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,sizeof(struct timeval));
while (n != 0)
{
n = recvfrom(sockfd, recvline, arg.size, 0, NULL, NULL);
count++;
memcpy(&seq, recvline, 4);
memcpy(&tim, recvline+4, 4);
if(seq != last_seq && last_tim != tim)
{
diff = getTimeDiff()-tim;
if(seq < last_seq)
{
out_of_order++;
}
else
{
last_seq = seq;
}
printf("Received #%d\t- #%d\t- %d.%dms\n", count, seq, (diff/1000), (diff%1000));
time_fix = 0;
rtt_sum += diff;
if(diff_min > diff)
{
diff_min = diff;
}
if(diff_max < diff)
{
diff_max = diff;
}
last_tim = tim;
}
}
free(recvline);
}
int main(int argc, char *argv[])
{
int sockfd, portno, n;
struct sockaddr_in serv_addr;
struct hostent *server;
struct timespec start,stop;
long accum;
char buffer[256];
bzero(buffer,256);
if (argc < 4) {
fprintf(stderr,"usage %s hostname port message_length\n", argv[0]);
exit(0);
}
portno = atoi(argv[2]);
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
server = gethostbyname(argv[1]);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");
int message_length = atoi(argv[3]);
char *string = (char*)malloc(message_length*sizeof(char*));
rand_str(string,message_length);
clock_gettime(CLOCK_REALTIME, &start);
n = write(sockfd,string,strlen(string));
if (n < 0)
error("ERROR writing to socket");
n = read(sockfd,buffer,255);
clock_gettime(CLOCK_REALTIME, &stop);
if (n < 0)
error("ERROR reading from socket");
accum = (stop.tv_sec - start.tv_sec)*1000000000 + (stop.tv_nsec - start.tv_nsec);
uint64_t diff = getTimeDiff(start, stop);
printf("Latency : %llu\n", (unsigned long long int)diff);
//printf("%s\n",buffer);
return 0;
}
void Device::updateTimeDiff() {
printf("Updating time diff...\n");
struct timeval tp1;
struct timeval tp2;
double mach_time;
sleep(1);
gettimeofday(&tp1, NULL);
double ms1 = tp1.tv_sec * 1000 + tp1.tv_usec / 1000.0;
sendCommand(TCPDeviceCommandGetMachTime, NULL, 0);
int n = read(cmd_fd, &mach_time, 255);
if (n < 0) {
perror("ERROR reading from socket");
return;
}
gettimeofday(&tp2, NULL);
double ms2 = tp2.tv_sec * 1000 + tp2.tv_usec / 1000.0;
double ms = ms2 - ms1;
double time_diff = (ms1 + ms / 2) - mach_time;
_time_diff->add(time_diff);
parser->time_diff = getTimeDiff();
printf("Device: %s\n", name);
printf("---------------------------\n");
printf("mach_time: %f\n", mach_time);
printf("%f time diff (server - device)\n", time_diff);
printf("%f ms elapsed\n", ms);
printf("ms1: %f\nms2: %f\n", ms1, ms2);
printf("%f avg diff\n", getTimeDiff());
printf("\n");
}
void ImageRefocus::saveDepthMapInfo(MUINT8* depthBufferArray, MUINT8* xmpDepthBufferArray) {
ALOGI("<saveDepthMapInfo>DepthBufferSize %d ", mRefocusResultInfo.DepthBufferSize);
memcpy(depthBufferArray, (MUINT8*)mRefocusResultInfo.DepthBufferAddr, mRefocusResultInfo.DepthBufferSize);
memcpy(xmpDepthBufferArray, (MUINT8*)mRefocusResultInfo.XMPDepthMapAddr,
mRefocusResultInfo.XMPDepthWidth * mRefocusResultInfo.XMPDepthHeight);
if (mDepthRotation != ORIENTATION_0) {
getTime(&mStartSec, &mStartNsec);
int offset = 0;
int bufferWidth = 0;
int bufferHeight = 0;
int depthBufferWidth = mRefocusResultInfo.DepthBufferWidth;
int depthBufferHeight = mRefocusResultInfo.DepthBufferHeight;
int metaBufferWidth = mRefocusResultInfo.MetaBufferWidth;
int metaBufferHeight = mRefocusResultInfo.MetaBufferHeight;
char name[FILE_NAME_LENGTH];
for (int i = 0; i < DEPTH_BUFFER_SECTION_SIZE; i++) {
if (i == WMI_DEPTH_MAP_INDEX) {
offset = 0;
bufferWidth = depthBufferWidth;
bufferHeight = depthBufferHeight;
} else if (i == VAR_BUFFER_INDEX || i == DVEC_MAP_INDEX) {
continue; // no need to rotate
} else if (i == DS4_BUFFER_Y_INDEX) {
offset = depthBufferWidth * depthBufferHeight + (i - 1) * metaBufferWidth * metaBufferHeight;
bufferWidth = depthBufferWidth;
bufferHeight = depthBufferHeight;
} else {
offset = depthBufferWidth * depthBufferHeight + (i - 1)* metaBufferWidth * metaBufferHeight;
bufferWidth = metaBufferWidth;
bufferHeight = metaBufferHeight;
}
ALOGI("<saveDepthMapInfo>rotate section %d: offset %d, bufferWidth %d, bufferHeight %d", i, offset,
bufferWidth, bufferHeight);
if (NULL != m_DebugUtils) {
sprintf(name, "section_%d_before_rotate.ppm", i);
m_DebugUtils->dumpBufferToPPM(name, depthBufferArray + offset, bufferWidth, bufferHeight, 5, 3);
}
rotateBuffer((MUINT8*)mRefocusResultInfo.DepthBufferAddr + offset, depthBufferArray + offset,
bufferWidth, bufferHeight, mDepthRotation);
if (NULL != m_DebugUtils) {
sprintf(name, "section_%d_after_rotate.ppm", i);
m_DebugUtils->dumpBufferToPPM(name, depthBufferArray + offset, bufferHeight, bufferWidth, 5, 3);
}
}
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<saveDepthMapInfo>mRefocus->saveDepthMapInfo,rotating depthBuffer costs time:%d", mTimeDiff);
}
}
// prints the current state of the airport parking, waits for
// semaphore to be released before printing.
void printAirport() {
sem_wait(&mutex);
printf("\nAirport State:\n");
for (int i=0; i<NUM_PARKING_BAYS; ++i) {
if (parking[i] == NULL) {
printf("%d: Empty\n", i);
} else {
printf("%d: %s (has parked for %.2f seconds)\n", i,
parking[i]->flight_number, getTimeDiff(parking[i]->time_landed));
}
}
printf("\n");
sem_post(&mutex);
return;
}
void IsoView::draw(AGPainter &p)//const AGRect &r)
{
if(!inited)
{
init();
inited=true;
shallUpdate=false;
}
if(shallUpdate)
{
update();
shallUpdate=false;
}
updatePositions();
doTick();
mTime+=getTimeDiff();
AntargisView::draw(p);
// overlay selection-rectangle and energy
std::set
<AVItem*>::iterator i=mSelected.begin();
for(;i!=mSelected.end() ;i++)
{
AGRect ar=getRect(*i);
// ar=r.project(ar);
p.drawRect(ar,getSelectColor());
}
std::map<AVItem*,AntEntity*>::iterator k=mEntities.end();// FIXME: don't draw anything ATM begin();
for(;k!=mEntities.end();k++)
{
AGRect ar=getRect(k->first);
// ar=r.project(ar);
// draw energy
ar.y-=10;
ar.h=6;
p.drawRect(ar,AGColor(0xFF,0,0)); // first red
ar.w=(short)(ar.w*k->second->getEnergy());
p.drawRect(ar,AGColor(0,0xFF,0)); // overpaint with green
}
// overlay rain
mRain.draw(p);
}
int main(int argc, char *argv[])
{
if(argc != 3)
{
printf("Usage: binary filename filesize\n");
exit(1);
}
uint64_t diff;
struct timespec start, end;
char filename[1024];
strcpy(filename, argv[1]);
char buffer[BUFFER_SIZE];
int i;
for(i=0; i<BUFFER_SIZE-1; i++)
buffer[i] = 'a';
buffer[BUFFER_SIZE] = '\0';
int fd, total_written=0, num_written=0, times=0;
//int file_size=100*1024; // This will be multiplied by BUFFER_SIZE
int file_size = atoi(argv[2]);
int k, iterations = 5;
clock_gettime(CLOCK_REALTIME, &start);
fd = open(filename, O_RDWR);
if(fd == -1)
perror("fd is -1");
num_written = write(fd, buffer, BUFFER_SIZE);
// fsync(fd);
if (num_written != BUFFER_SIZE)
{
printf("Error=> bytes written %d, BUFFER_SIZE %d\n", num_written, BUFFER_SIZE);
close(fd);
exit(1);
}
fsync(fd);
clock_gettime(CLOCK_REALTIME, &end);
diff = getTimeDiff(start, end);
printf("Total bytes written %d\t", total_written);
//printf("Time for write of %s, %d bytes - %llu\n", filename, total_written, (long long unsigned int)diff);
printf("%llu\n", (long long unsigned int)diff);
close(fd);
//system("sudo sh -c \"sync; echo 3 > /proc/sys/vm/drop_caches\"");
return 0;
}
int doWrite() {
static unsigned int dataCounter=0;
static int first=1;
static struct timeval lastTime;
struct timeval newTime;
float timeDiff;
int retVal;
if(first) {
gettimeofday(&lastTime,0);
first=0;
}
// if(numBytesInBuffer%2==1) numBytesInBuffer++;
if(numBytesInBuffer>6000)
printf("Trying to write %d bytes -- %d\n",numBytesInBuffer,laptopDebug);
if(!laptopDebug) {
retVal=writeLosData(losBuffer,numBytesInBuffer);
if(retVal!=0) {
syslog(LOG_ERR,"Error sending los buffer\n");
fprintf(stderr,"Error sending los buffer\n");
}
}
else {
retVal=0;
// retVal=fake_los_write(losBuffer,numBytesInBuffer,fakeOutputDir);
}
dataCounter+=numBytesInBuffer;
// printf("%d %d\n",numBytesInBuffer,dataCounter);
if(dataCounter>100000) {
gettimeofday(&newTime,0);
timeDiff=getTimeDiff(lastTime,newTime);
printf("Transferred %u bytes in %2.2f seconds (%3.4f bytes/sec)\n",dataCounter,timeDiff,((float)dataCounter)/timeDiff);
dataCounter=0;
lastTime=newTime;
}
numBytesInBuffer=0;
return retVal;
}
/*
* Borwein calculation of PI
*/
void* calculatePi(void *args){
int tid;
double p16 = 1, pi = 0;
unsigned long long int k;
uint64_t diff;
struct timespec start, end;
tid = ((targs*)(args))->tid;
//printf("Starting thread: %d\n",tid);
clock_gettime(CLOCK_MONOTONIC, &start);
for(k=0; k<=precision; k++){
pi += 1.0/p16 * (4.0/(8*k + 1) - 2.0/(8*k + 4) - 1.0/(8*k + 5) - 1.0/(8*k+6));
p16 *= 16;
}
clock_gettime(CLOCK_MONOTONIC,&end);
printf("Pi_calculation_elapsed_time:\t%llu\n", (long long unsigned int) getTimeDiff(start,end));
//printf("Ending thread: %d\n",tid);
return NULL;
}
bool ImageRefocus::generateRefocusImage(MUINT8* array, int touchCoordX, int touchCoordY, int depthOfField) {
ALOGI("<generateRefocusImage>touchCoordX:%d,touchCoordY:%d,depthOfField:%d",
touchCoordX, touchCoordY, depthOfField);
mRefocusImageInfo.TouchCoordX = touchCoordX;
mRefocusImageInfo.TouchCoordY = touchCoordY;
mRefocusImageInfo.DepthOfField = depthOfField;
if (!generate()) {
ALOGI("ERROR:generate fail!!!");
return FAIL;
}
getTime(&mStartSec, &mStartNsec);
memcpy(array, (MUINT8*)mRefocusResultInfo.RefocusedRGBAImageAddr,
mRefocusResultInfo.RefocusImageWidth*mRefocusResultInfo.RefocusImageHeight*4);
getTime(&mEndSec, &mEndNsec);
mTimeDiff = getTimeDiff(mStartSec, mStartNsec, mEndSec, mEndNsec);
ALOGI("<generateRefocusImage> memcpy time:%d", mTimeDiff);
if (mRefocusResultInfo.RefocusImageWidth == 0 || mRefocusResultInfo.RefocusImageHeight == 0) {
ALOGI("ERROR:error RefocusImageWidth and RefocusImageHeight!!!");
return FAIL;
}
return SUCCESS;
}
/**
* Main loop sending data to server and signals to fork child
*
* @param arguments arg Arguments structure
*/
void sendData(arguments arg)
{
char *sendline = malloc(arg.size);
memset(sendline, 1, arg.size);
uint32_t time = 0;
int sleep = 1000000/arg.rate;
unsigned tout = arg.timeout*1000000;
do
{
memcpy(sendline, &count, sizeof(count));
time = getTimeDiff();
//printf("Send data %u\n", count);
memcpy(sendline+4, &time, sizeof(time));
sendto(sockfd, sendline, arg.size, 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
count++;
if(count%(arg.interval*arg.rate) == 0)
{
kill(arg.pid, SIGUSR1);
}
usleep(sleep);
}
while(tout > time);
if(count%(arg.interval*arg.rate) != 0)
{
kill(arg.pid, SIGUSR1);
}
free(sendline);
}
int main(int argc,char **argv) {
pcap_t *pcap;
char pcapErr[PCAP_ERRBUF_SIZE], line[80] ;
char* title;
int datalink;
char timeDuration[MAX_BUF_SIZE];
char file_name[MAX_BUF_SIZE];
if (argc != 2) {
printf("Usage: ./wiretap file.pcap\n");
printf(" ./wiretap file.pcap > output.txt\n");
exit(1);
}
strcpy(file_name, argv[1]);
pcap = pcap_open_offline(file_name, pcapErr);
if (pcap == NULL) {
fprintf(stderr, "pcap_open_offline failed: %s\n", pcapErr);
exit(EXIT_FAILURE);
}
datalink = pcap_datalink(pcap);
if(datalink != Ethernet) {
printf("not Ethernet!\n");
exit(EXIT_FAILURE);
}
pcap_loop(pcap,-1,my_callback,NULL);
getTimeDiff(timeDuration);
print_summary(timebuffer, start_time, timeDuration);
printf("=== Link layer ===\n\n");
print("Source ethernet addresses", eth_src_addr, packets);
free_nodes(eth_src_addr);
print("Destination ethernet addresses", eth_dest_addr, packets);
free_nodes(eth_dest_addr);
printf("=== Network Layer ===\n\n");
print("Network layer protocols", net_layer, packets);
free_nodes(net_layer);
print("Source IP addresses", IP_src_addr, ip_packets);
free_nodes(IP_src_addr);
print("Destination IP addresses", IP_dest_addr, ip_packets);
free_nodes(IP_dest_addr);
print("TTLs",TTL_list, ip_packets);
free_nodes(TTL_list);
print_arp(arp_participants);
free_arp_nodes(arp_participants);
printf("=== Transport Layer ===\n\n");
print("Transport Layer protocols", transLayer, ip_packets);
free_nodes(transLayer);
printf("=== Transport Layer: TCP ===\n\n");
print("Source TCP ports", TCP_src_ports, TCP_packets);
free_nodes(TCP_src_ports);
print("Destination TCP ports", TCP_dest_ports, TCP_packets);
free_nodes(TCP_dest_ports);
print("TCP flags", TCP_flags, TCP_packets);
free_nodes(TCP_flags);
print("TCP options", TCP_options, TCP_packets);
free_nodes(TCP_options);
printf("=== Transport Layer: UDP ===\n\n");
print("Source UDP ports", UDP_src_ports, UDP_packets);
free_nodes(UDP_src_ports);
print("Destination UDP ports", UDP_dest_ports, UDP_packets);
free_nodes(UDP_dest_ports);
printf("=== Transport Layer: ICMP ===\n\n");
print("Source IPs for ICMP", ICMP_src_IP, ICMP_packets);
free_nodes(ICMP_src_IP);
print("Destination IPs for ICMP", ICMP_dest_IP, ICMP_packets);
free_nodes(ICMP_dest_IP);
print("ICMP types", ICMP_TYPE, ICMP_packets);
free_nodes(ICMP_TYPE);
print("ICMP codes", ICMP_CODE, ICMP_packets);
free_nodes(ICMP_CODE);
print("ICMP responses", ICMP_RESPONSE, ICMP_packets);
free_nodes(ICMP_RESPONSE);
pcap_close(pcap);
}
/*
* Zstream implementation for seq (right event)
*/
void _seq_win_cep_r(void* exec)
{
EtalisEvent* Event_b = (EtalisEvent*)exec;
EtalisExecNode* rule_ = Event_b->RootModel->parentNode;
assert(Event_b != NULL && rule_ != NULL);
EtalisEvent* Event_a = StackPop(rule_->leftChild->eventStack);
if(Event_a == NULL) /* stack is empty*/
{
free(Event_b);
return;
}
/* Event a is in the stack */
/* a complex event will be generated if the conditions are met */
/* testing if the conditions could be proven correct */
if(getTimeDiff(&(Event_b->timestamps[0]),&(Event_a->timestamps[0])) > rule_->window_size) /* out of the window*/
{
/* printf(" --- Time difference is %d > window size of %d\n",Event_b->timestamps[0]-Event_a->timestamps[0],rule_->window_size);
*/
free(Event_a); /* check this */
free(Event_b);
return;
}
if (Event_b->RootModel->event.arity != 0 )
{
if(aprio_validation(Event_b) != ETALIS_OK) /* argument a priori conditions must be true*/
{
#ifdef DEBUG
log_err("Event could be validated !");
#endif
free(Event_a); /* check*/
free(Event_b);
return;
}
/* event arguments must be valide - implicite condition */
if(validate_arguments(Event_b,Event_a) != ETALIS_OK)
{
#ifdef DEBUG
printf("Event arguments could not be validated ! \n");
#endif
free(Event_a); /* check*/
free(Event_b);
return;
}
}
EtalisEventNode* cplxEvModel=NULL; /* Complex Event Root Model */
/* the rest depends on the CEP policy */
if (_conf.policy==recent) /* recent policy */
{
cplxEvModel = rule_->parentEvent;
/* triggering the complex event */
EtalisEvent* cplxEvent = (EtalisEvent*)malloc(sizeof(EtalisEvent));
cplxEvent->RootModel = rule_->parentEvent;
/* bind the arguments of the complex event */ /* todo validate */
cplxEvent->args = (int*)malloc(sizeof(int)*cplxEvModel->event.arity);
size_t arg_iterator=0;
for(arg_iterator=0; arg_iterator<cplxEvModel->event.arity; arg_iterator++)
{
switch (cplxEvModel->arg_links[arg_iterator].event_)
{
case 1 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_a->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
case 2 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_b->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
}
}
cplxEvent->timestamps[0] = Event_a->timestamps[0]; /* timestamp structure as suggested by the ETALIS paper */
cplxEvent->timestamps[1] = Event_b->timestamps[1];
triggerEvent_intern_no_hash(cplxEvent); /* trigger the complex event (we already know the EventModel, so we don't need to search for it in the _event_hash) */
/* garbage collect : we don't need these events anymore */
free(Event_a);
free(Event_b);
return;
}
else if (_conf.policy==unrestricted)
{
/* TODO */
return ;
}
}
void _seq_batch_r(void* exec)
{
EtalisEvent* Event_b = (EtalisEvent*)exec;
if (Event_b == NULL) return;
EtalisExecNode* rule_ = Event_b->RootModel->parentNode;
EtalisEvent* Event_a=NULL;
/* calculate EAT */
float EAT = getHighResStamp(&Event_b->timestamps[1]) - rule_->window_size; /* TODO fix */
if (rule_->leftChild->is_temp)
{
_seq_batch_r(StackPop(rule_->leftChild->childNode->rightChild->eventStack));
}
do
{
/*if (getHighResStamp(&Event_b->timestamps[0]) < EAT ) { free(Event_b); continue;} /* problem : all atomic right side events does not fulfill this condition */
Event_a = StackPop(rule_->leftChild->eventStack);
while( Event_a != NULL && getTimeDiff(&(Event_b->timestamps[0]),&(Event_a->timestamps[1])) >= 0 ) /* problem : recursion */
{
/*if (getHighResStamp(&Event_a->timestamps[0]) < EAT )*/ /* EAT is not compatible with timestamps */
if (Event_b->timestamps[1].time - Event_a->timestamps[0].time > rule_->window_size)
{
free (Event_a);
Event_a = StackPop(rule_->leftChild->eventStack);
continue; /* normally you don't have to continue here, because events are already choronogically ordered in the stack */ /* fix this */
}
if(validate_arguments(Event_b,Event_a) != ETALIS_OK)
{
#ifdef DEBUG
printf("Event arguments could not be validated ! \n");
#endif
free(Event_a); /* check*/
Event_a = StackPop(rule_->leftChild->eventStack);
continue;
}
EtalisEventNode* cplxEvModel=NULL; /* Complex Event Root Model */
/* the rest depends on the CEP policy */
if (_conf.policy==recent) /* recent policy */
{
cplxEvModel = rule_->parentEvent;
/* triggering the complex event */
EtalisEvent* cplxEvent = (EtalisEvent*)malloc(sizeof(EtalisEvent));
cplxEvent->RootModel = rule_->parentEvent;
/* bind the arguments of the complex event */ /* todo validate */
cplxEvent->args = (int*)malloc(sizeof(int)*cplxEvModel->event.arity);
size_t arg_iterator=0;
for(arg_iterator=0; arg_iterator<cplxEvModel->event.arity; arg_iterator++)
{
switch (cplxEvModel->arg_links[arg_iterator].event_)
{
case 1 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_a->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
case 2 :
*((int*)cplxEvent->args+arg_iterator)=*((int*)Event_b->args+(cplxEvModel->arg_links[arg_iterator].argument_number));
break;
}
}
cplxEvent->timestamps[0] = Event_a->timestamps[0]; /* timestamp structure as suggested by the ETALIS paper */
cplxEvent->timestamps[1] = Event_b->timestamps[1];
triggerEvent_intern_no_hash(cplxEvent); /* trigger the complex event (we already know the EventModel, so we don't need to search for it in the _event_hash) */
/* garbage collect : we don't need these events anymore */
free(Event_a);
free(Event_b);
return;
}
else if (_conf.policy==unrestricted)
{
/* TODO */
return ;
}
Event_a = StackPop(rule_->leftChild->eventStack);
}
}
while (Event_b = StackPop(Event_b->RootModel->eventStack));
}
void XLog::log(const char* input) {
std::cout << std::fixed;
std::cout<<std::setprecision(3);
std::cout<<"Seconds: "<<getTimeDiff()<<" "<<logName<<" || "<<input<<std::endl;
}
int
main (int argc, char ** argv)
{
typedef pcl::PointXYZRGB PointT;
std::string scene_dir, input_mask_dir, output_dir = "/tmp/dol/";
bool visualize = false;
bool save_views = false;
size_t min_mask_points = 50;
bool first_frame_only=false; // used for evaluation when only using the first view
v4r::object_modelling::IOL m;
po::options_description desc("Evaluation Dynamic Object Learning with Ground Truth\n======================================\n **Allowed options");
desc.add_options()
("help,h", "produce help message")
("scenes_dir,s", po::value<std::string>(&scene_dir)->required(), "input directory with .pcd files of the scenes. Each folder is considered as seperate sequence. Views are sorted alphabetically and object mask is applied on first view.")
("input_mask_dir,m", po::value<std::string>(&input_mask_dir)->required(), "directory containing the object masks used as a seed to learn the object in the first cloud")
("output_dir,o", po::value<std::string>(&output_dir)->default_value(output_dir), "Output directory where the model, training data, timing information and parameter values will be stored")
("save_views", po::bool_switch(&save_views), "if true, also saves point clouds, camera pose and object masks for each training views. This is necessary for recognition.")
("radius,r", po::value<double>(&m.param_.radius_)->default_value(m.param_.radius_), "Radius used for region growing. Neighboring points within this distance are candidates for clustering it to the object model.")
("dot_product", po::value<double>(&m.param_.eps_angle_)->default_value(m.param_.eps_angle_), "Threshold for the normals dot product used for region growing. Neighboring points with a surface normal within this threshold are candidates for clustering it to the object model.")
("dist_threshold_growing", po::value<double>(&m.param_.dist_threshold_growing_)->default_value(m.param_.dist_threshold_growing_), "")
("seed_res", po::value<double>(&m.param_.seed_resolution_)->default_value(m.param_.seed_resolution_), "")
("voxel_res", po::value<double>(&m.param_.voxel_resolution_)->default_value(m.param_.voxel_resolution_), "")
("ratio", po::value<double>(&m.param_.ratio_supervoxel_)->default_value(m.param_.ratio_supervoxel_), "")
("do_erosion", po::value<bool>(&m.param_.do_erosion_)->default_value(m.param_.do_erosion_), "")
("do_mst_refinement", po::value<bool>(&m.param_.do_mst_refinement_)->default_value(m.param_.do_mst_refinement_), "")
("do_sift_based_camera_pose_estimation", po::value<bool>(&m.param_.do_sift_based_camera_pose_estimation_)->default_value(m.param_.do_sift_based_camera_pose_estimation_), "")
("transfer_latest_only", po::value<bool>(&m.param_.transfer_indices_from_latest_frame_only_)->default_value(m.param_.transfer_indices_from_latest_frame_only_), "")
("chop_z,z", po::value<double>(&m.param_.chop_z_)->default_value(m.param_.chop_z_), "Cut-off distance of the input clouds with respect to the camera. Points further away than this distance will be ignored.")
("normal_method,n", po::value<int>(&m.param_.normal_method_)->default_value(m.param_.normal_method_), "")
("ratio_cluster_obj_supported", po::value<double>(&m.param_.ratio_cluster_obj_supported_)->default_value(m.param_.ratio_cluster_obj_supported_), "")
("ratio_cluster_occluded", po::value<double>(&m.param_.ratio_cluster_occluded_)->default_value(m.param_.ratio_cluster_occluded_), "")
("stat_outlier_removal_meanK", po::value<int>(&m.sor_params_.meanK_)->default_value(m.sor_params_.meanK_), "MeanK used for statistical outlier removal (see PCL documentation)")
("stat_outlier_removal_std_mul", po::value<double>(&m.sor_params_.std_mul_)->default_value(m.sor_params_.std_mul_), "Standard Deviation multiplier used for statistical outlier removal (see PCL documentation)")
("inlier_threshold_plane_seg", po::value<double>(&m.p_param_.inlDist)->default_value(m.p_param_.inlDist), "")
("min_points_smooth_cluster", po::value<int>(&m.p_param_.minPointsSmooth)->default_value(m.p_param_.minPointsSmooth), "Minimum number of points for a cluster")
("min_plane_points", po::value<int>(&m.p_param_.minPoints)->default_value(m.p_param_.minPoints), "Minimum number of points for a cluster to be a candidate for a plane")
("smooth_clustering", po::value<bool>(&m.p_param_.smooth_clustering)->default_value(m.p_param_.smooth_clustering), "If true, does smooth clustering. Otherwise only plane clustering.")
("visualize,v", po::bool_switch(&visualize), "turn visualization on")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
if (vm.count("help"))
{
std::cout << desc << std::endl;
return false;
}
try { po::notify(vm); }
catch(std::exception& e)
{
std::cerr << "Error: " << e.what() << std::endl << std::endl << desc << std::endl;
return false;
}
m.initSIFT();
v4r::io::createDirIfNotExist(output_dir);
ofstream param_file;
param_file.open ((output_dir + "/param.nfo").c_str());
m.printParams(param_file);
param_file << "stat_outlier_removal_meanK" << m.sor_params_.meanK_ << std::endl
<< "stat_outlier_removal_std_mul" << m.sor_params_.std_mul_ << std::endl
<< "inlier_threshold_plane_seg" << m.p_param_.inlDist << std::endl
<< "min_points_smooth_cluster" << m.p_param_.minPointsSmooth << std::endl
<< "min_plane_points" << m.p_param_.minPoints << std::endl;
param_file.close();
std::vector< std::string> sub_folder_names = v4r::io::getFoldersInDirectory( scene_dir );
if( sub_folder_names.empty() )
sub_folder_names.push_back("");
v4r::io::createDirIfNotExist(output_dir + "/models");
for (const std::string &sub_folder_name : sub_folder_names)
{
const std::string output_rec_model = output_dir + "/" + sub_folder_name + "/models";
v4r::io::createDirIfNotExist(output_rec_model);
const std::string annotations_dir = input_mask_dir + "/" + sub_folder_name;
std::vector< std::string > mask_file_v = v4r::io::getFilesInDirectory(annotations_dir, ".*.txt", false);
for (size_t o_id=0; o_id<mask_file_v.size(); o_id++)
{
const std::string mask_file = annotations_dir + "/" + mask_file_v[o_id];
size_t idx_tmp;
std::vector<size_t> mask;
std::ifstream initial_mask_file ( mask_file.c_str() );
while (initial_mask_file >> idx_tmp)
mask.push_back(idx_tmp);
initial_mask_file.close();
if ( mask.size() < min_mask_points) // not enough points to grow an object
continue;
const std::string scene_path = scene_dir + "/" + sub_folder_name;
std::vector< std::string > views = v4r::io::getFilesInDirectory(scene_path, ".*.pcd", false);
std::cout << "Learning object from mask " << mask_file << " for scene " << scene_path << std::endl;
timeval start, stop;
gettimeofday(&start, NULL);
for(size_t v_id=0; v_id<views.size(); v_id++)
{
const std::string view_file = scene_path + "/" + views[ v_id ];
pcl::PointCloud<PointT>::Ptr pCloud(new pcl::PointCloud<PointT>());
pcl::io::loadPCDFile(view_file, *pCloud);
const Eigen::Matrix4f trans = v4r::RotTrans2Mat4f(pCloud->sensor_orientation_, pCloud->sensor_origin_);
pCloud->sensor_origin_ = Eigen::Vector4f::Zero(); // for correct visualization
pCloud->sensor_orientation_ = Eigen::Quaternionf::Identity();
if (v_id==0)
m.learn_object(*pCloud, trans, mask);
else
{
if(!first_frame_only)
m.learn_object(*pCloud, trans);
}
}
gettimeofday(&stop, NULL);
std::string out_fn = mask_file_v[o_id];
boost::replace_last (out_fn, "mask.txt", "dol");
m.save_model(output_rec_model, out_fn, save_views);
if (visualize)
m.visualize();
m.clear();
// write running time to file
const std::string timing_fn = output_dir+"/"+sub_folder_name+"/timing.nfo";
double learning_time = getTimeDiff(stop, start);
ofstream f( timing_fn.c_str() );
f << learning_time;
f.close();
}
}
return 0;
}
double totalTime(){
return getTimeDiff(start_);
}
/**@brief Get formatted time since last point formatted
*
* @param decPlaces How many decimal places to round to
* @return A string with the time formatted for hrs, min, secs etc.
*/
std::string timeLapFormatted(int32_t decPlaces = 6){
return getTimeFormat(getTimeDiff(currentLap_),true, decPlaces);
}
/**@brief Get time in seconds since last point
* @return A double for time in seconds
*/
double timeLap(){
return getTimeDiff(currentLap_);
}
/**@brief Get formatted time since start formatted
*
* @param decPlaces How many decimal places to round to
* @return A string with the time formatted for hrs, min, secs etc.
*/
std::string totalTimeFormatted(int32_t decPlaces = 6){
return getTimeFormat(getTimeDiff(start_),true, decPlaces);
}
