int main(int argc,char* argv[]) { LidarProcessOctree lpo(argv[1],512*1024*1024); #if 0 Misc::Timer t; { // BinaryPointSaver bps(argv[2]); double scale[3]={0.001,0.001,0.001}; double offset[3]; for(int i=0;i<3;++i) offset[i]=lpo.getDomain().getCenter(i); LasPointSaver lps(argv[2],scale,offset); // PointCounter pc; Box box(Box::Point(2.04446e6,617053.0,-1000.0),Box::Point(2.04446e6+100.0,617053.0+100.0,1000.0)); lpo.processPointsInBox(box,lps); // std::cout<<lps.getNumPoints()<<std::endl; } t.elapse(); std::cout<<"Done in "<<t.getTime()*1000.0<<" ms"<<std::endl; #elif 0 PointSaver ps(argv[2]); Box box=Box::full; for(int i=0;i<2;++i) { box.min[i]=atof(argv[3+i]); box.max[i]=atof(argv[5+i]); } lpo.processPointsInBox(box,ps); #elif 0 PointCounter pc; lpo.processPoints(pc); std::cout<<pc.getNumPoints()<<std::endl; #else Scalar radius=Scalar(0.1); PointDensityCalculator pdc(lpo,radius,4); #if 0 Box box; box.min=Point(930,530,0); box.max=Point(970,570,100); lpo.processPointsInBox(box,pdc); #else // lpo.processPoints(pdc); lpo.processNodesPostfix(pdc); #endif std::cout<<"Number of processed points: "<<pdc.numPoints<<std::endl; std::cout<<"Total number of found neighbors: "<<pdc.totalNumNeighbors<<std::endl; std::cout<<"Total number of loaded octree nodes: "<<lpo.getNumSubdivideCalls()<<", "<<lpo.getNumLoadedNodes()<<std::endl; std::cout<<"Average point density in 1/m^3: "<<pdc.totalNumNeighbors/(pdc.numPoints*4.0/3.0*3.141592654*radius*radius*radius)<<std::endl; #endif return 0; }
void PointAccumulator::savePoints(void) { /* Create a temporary octree for the current in-memory point set: */ std::cout<<std::endl<<"Storing "<<points.size()<<" points as temporary octree..."<<std::flush; char tofnt[1024]; strcpy(tofnt,tempOctreeFileNameTemplate.c_str()); Misc::Timer t; TempOctree* to=new TempOctree(tofnt,maxNumPointsPerNode,&points[0],points.size()); t.elapse(); std::cout<<" done in "<<t.getTime()*1000.0<<" ms"<<std::endl; tempOctrees.push_back(to); /* Clear the point set: */ points.clear(); }
int main(int argc,char* argv[]) { LidarProcessOctree lpo(argv[1],512*1024*1024); Misc::Timer t; size_t numLeafPoints=0; for(LidarProcessOctree::PointIterator pIt=lpo.beginNodes();pIt!=lpo.endNodes();++pIt) ++numLeafPoints; t.elapse(); std::cout<<numLeafPoints<<" leaf points, "; std::cout<<"done in "<<t.getTime()*1000.0<<" ms"<<std::endl; return 0; }
void VideoViewer::videoFrameCallback(const Video::FrameBuffer* frameBuffer) { double timeStamp=saveVideoTimer.peekTime(); /* Start a new value in the input triple buffer: */ Images::RGBImage& image=videoFrames.startNewValue(); /* Extract an RGB image from the provided frame buffer into the new value: */ videoExtractor->extractRGB(frameBuffer,image.modifyPixels()); /* Finish the new value in the triple buffer and wake up the main loop: */ videoFrames.postNewValue(); Vrui::requestUpdate(); if(saveVideoFrames) { /* Create a filename for the new video frame: */ char videoFrameFileName[1024]; snprintf(videoFrameFileName,sizeof(videoFrameFileName),saveVideoFrameNameTemplate.c_str(),saveVideoNextFrameIndex); /* Save the new video frame: */ Images::writeImageFile(image,videoFrameFileName); std::cout<<"Saving frame "<<videoFrameFileName<<" at "<<timeStamp*1000.0<<" ms"<<std::endl; /* Increment the frame counter: */ ++saveVideoNextFrameIndex; } }
int main(int argc,char* argv[]) { /* Parse command line: */ char* serverName=0; int trackerIndex=0; int printMode=0; bool printButtonStates=false; bool printNewlines=false; for(int i=1;i<argc;++i) { if(argv[i][0]=='-') { if(strcasecmp(argv[i],"-t")==0||strcasecmp(argv[i],"--trackerIndex")==0) { ++i; trackerIndex=atoi(argv[i]); } else if(strcasecmp(argv[i],"-alltrackers")==0) trackerIndex=-1; else if(strcasecmp(argv[i],"-p")==0) printMode=0; else if(strcasecmp(argv[i],"-o")==0) printMode=1; else if(strcasecmp(argv[i],"-f")==0) printMode=2; else if(strcasecmp(argv[i],"-v")==0) printMode=3; else if(strcasecmp(argv[i],"-b")==0) printButtonStates=true; else if(strcasecmp(argv[i],"-n")==0) printNewlines=true; } else serverName=argv[i]; } if(serverName==0) { std::cerr<<"Usage: "<<argv[0]<<" [(-t | --trackerIndex) <trackerIndex>] [-p | -o | -f | -v] [-b] <serverName:serverPort>"<<std::endl; return 1; } /* Initialize device client: */ Vrui::VRDeviceClient* deviceClient=0; try { /* Split the server name into hostname:port: */ char* colonPtr=0; for(char* cPtr=serverName;*cPtr!='\0';++cPtr) if(*cPtr==':') colonPtr=cPtr; int portNumber=0; if(colonPtr!=0) { portNumber=atoi(colonPtr+1); *colonPtr='\0'; } deviceClient=new Vrui::VRDeviceClient(serverName,portNumber); } catch(std::runtime_error error) { std::cerr<<"Caught exception "<<error.what()<<" while initializing VR device client"<<std::endl; return 1; } /* Print output header line: */ switch(printMode) { case 0: std::cout<<" Pos X Pos Y Pos Z "<<std::endl; break; case 1: std::cout<<" Pos X Pos Y Pos Z Axis X Axis Y Axis Z Angle "<<std::endl; break; case 2: std::cout<<" Pos X Pos Y Pos Z XA X XA Y XA Z YA X YA Y YA Z ZA X ZA Y ZA Z "<<std::endl; break; } /* Run main loop: */ deviceClient->activate(); deviceClient->startStream(); bool loop=true; Misc::Timer t; int numPackets=0; while(loop) { /* Print new device state: */ if(!printNewlines) std::cout<<"\r"; deviceClient->lockState(); const Vrui::VRDeviceState& state=deviceClient->getState(); switch(printMode) { case 0: if(trackerIndex<0) { printTrackerPos(state,0); for(int i=1;i<state.getNumTrackers();++i) { std::cout<<" "; printTrackerPos(state,i); } } else printTrackerPos(state,trackerIndex); break; case 1: printTrackerPosOrient(state,trackerIndex); break; case 2: printTrackerFrame(state,trackerIndex); break; case 3: printValuators(state); break; } if(printButtonStates) { std::cout<<" "; printButtons(state); } deviceClient->unlockState(); if(printNewlines) std::cout<<std::endl; else std::cout<<std::flush; /* Check for a key press event: */ fd_set readFdSet; FD_ZERO(&readFdSet); FD_SET(fileno(stdin),&readFdSet); struct timeval timeout; timeout.tv_sec=0; timeout.tv_usec=0; bool dataWaiting=select(fileno(stdin)+1,&readFdSet,0,0,&timeout)>=0&&FD_ISSET(fileno(stdin),&readFdSet); if(dataWaiting) loop=false; if(loop) { /* Wait for next packet: */ deviceClient->getPacket(); ++numPackets; } } std::cout<<std::endl; t.elapse(); std::cout<<"Received "<<numPackets<<" device data packets in "<<t.getTime()*1000.0<<" ms ("<<double(numPackets)/t.getTime()<<" packets/s)"<<std::endl; deviceClient->stopStream(); deviceClient->deactivate(); /* Clean up and terminate: */ delete deviceClient; return 0; }
int main(int argc,char* argv[]) { /* Parse the command line: */ SharedJelloServer::Index numAtoms(4,4,8); SharedJelloServer::Box domain(SharedJelloServer::Box::Point(-60.0,-36.0,0.0),SharedJelloServer::Box::Point(60.0,60.0,96.0)); int listenPortID=-1; // Assign any free port double updateTime=0.02; // Aim for 50 updates/sec for(int i=1;i<argc;++i) { if(argv[i][0]=='-') { if(strcasecmp(argv[i]+1,"numAtoms")==0) { /* Read the number of atoms: */ ++i; for(int j=0;j<3&&i<argc;++j,++i) numAtoms[j]=atoi(argv[i]); } else if(strcasecmp(argv[i]+1,"domain")==0) { /* Read the simulation domain: */ ++i; for(int j=0;j<3&&i<argc;++j,++i) domain.min[j]=SharedJelloServer::Box::Scalar(atof(argv[i])); for(int j=0;j<3&&i<argc;++j,++i) domain.max[j]=SharedJelloServer::Box::Scalar(atof(argv[i])); } else if(strcasecmp(argv[i]+1,"port")==0) { /* Read the server listening port: */ ++i; if(i<argc) listenPortID=atoi(argv[i]); } else if(strcasecmp(argv[i]+1,"tick")==0) { /* Read the server update time interval: */ ++i; if(i<argc) updateTime=atof(argv[i]); } } } /* Ignore SIGPIPE and leave handling of pipe errors to TCP sockets: */ struct sigaction sigPipeAction; sigPipeAction.sa_handler=SIG_IGN; sigemptyset(&sigPipeAction.sa_mask); sigPipeAction.sa_flags=0x0; sigaction(SIGPIPE,&sigPipeAction,0); /* Create a shared Jell-O server: */ SharedJelloServer sjs(numAtoms,domain,listenPortID); std::cout<<"SharedJelloServer::main: Created Jell-O server listening on port "<<sjs.getListenPortID()<<std::endl<<std::flush; /* Run the simulation loop full speed: */ Misc::Timer timer; double lastFrameTime=timer.peekTime(); double nextUpdateTime=timer.peekTime()+updateTime; int numFrames=0; while(true) { /* Calculate the current time step duration: */ double newFrameTime=timer.peekTime(); double timeStep=newFrameTime-lastFrameTime; lastFrameTime=newFrameTime; /* Perform a simulation step: */ sjs.simulate(timeStep); ++numFrames; /* Check if it's time for a state update: */ if(lastFrameTime>=nextUpdateTime) { /* Send a state update to all connected clients: */ sjs.sendServerUpdate(); // std::cout<<"\rFrame rate: "<<double(numFrames)/updateTime<<" fps"<<std::flush; nextUpdateTime+=updateTime; numFrames=0; } } return 0; }
int main(int argc,char* argv[]) { /* Set default values for all parameters: */ unsigned int memoryCacheSize=512; unsigned int tempOctreeMaxNumPointsPerNode=4096; std::string tempOctreeFileNameTemplate="/tmp/Pointe_Preprocessor_TempOctree"; unsigned int maxNumPointsPerNode=4096; std::string tempPointFileNameTemplate="/tmp/Pointe_Preprocessor_TempPoints"; const char * fileName=0; float valueMinimum=Math::Constants<float>::max; float valueMaximum=Math::Constants<float>::min; float * histogram; try { /* Open Pointe-Samhlaigh's configuration file: */ Misc::ConfigurationFile configFile(POINTE_CONFIGFILENAME); Misc::ConfigurationFileSection cfg=configFile.getSection("/Pointe_Preprocessor"); /* Override program settings from configuration file: */ memoryCacheSize=cfg.retrieveValue<unsigned int>("./memoryCacheSize",memoryCacheSize); tempOctreeMaxNumPointsPerNode=cfg.retrieveValue<unsigned int>("./tempOctreeMaxNumPointsPerNode",tempOctreeMaxNumPointsPerNode); tempOctreeFileNameTemplate=cfg.retrieveValue<std::string>("./tempOctreeFileNameTemplate",tempOctreeFileNameTemplate); maxNumPointsPerNode=cfg.retrieveValue<unsigned int>("./maxNumPointsPerNode",maxNumPointsPerNode); tempPointFileNameTemplate=cfg.retrieveValue<std::string>("./tempPointFileNameTemplate",tempPointFileNameTemplate); } catch(std::runtime_error err) { /* Just ignore the error */ } /* Initialize transient parameters: */ const char* outputFileName=0; PointFileType pointFileType=XYZI; bool havePoints=false; /* Parse the command line and load all input files: */ Misc::Timer loadTimer; PointeAccumulator pa; pa.setMemorySize(memoryCacheSize,tempOctreeMaxNumPointsPerNode); pa.setTempOctreeFileNameTemplate(tempOctreeFileNameTemplate+"XXXXXX"); for(int i=1;i<argc;++i) { if(argv[i][0]=='-') { if(strcasecmp(argv[i]+1,"o")==0) { ++i; if(i<argc) outputFileName=argv[i]; else std::cerr<<"Dangling -o flag on command line"<<std::endl; } else if(strcasecmp(argv[i]+1,"np")==0) { ++i; if(i<argc) maxNumPointsPerNode=(unsigned int)(atoi(argv[i])); else std::cerr<<"Dangling -np flag on command line"<<std::endl; } else if(strcasecmp(argv[i]+1,"cs")==0) { ++i; if(i<argc) { memoryCacheSize=(unsigned int)(atoi(argv[i])); pa.setMemorySize(memoryCacheSize,tempOctreeMaxNumPointsPerNode); } else std::cerr<<"Dangling -cs flag on command line"<<std::endl; } else if(strcasecmp(argv[i]+1,"to")==0) { ++i; if(i<argc) { if(!havePoints) { tempOctreeFileNameTemplate=argv[i]; pa.setTempOctreeFileNameTemplate(tempOctreeFileNameTemplate+"XXXXXX"); } else std::cerr<<"Ignoring -to flag; must be specified before any input point sets are read"<<std::endl; } else std::cerr<<"Dangling -to flag on command line"<<std::endl; } else if(strcasecmp(argv[i]+1,"tp")==0) { ++i; if(i<argc) tempPointFileNameTemplate=argv[i]; else std::cerr<<"Dangling -tp flag on command line"<<std::endl; } else if(strcasecmp(argv[i]+1,"xyzi")==0) pointFileType=XYZI; else std::cerr<<"Unrecognized command line option "<<argv[i]<<std::endl; } else { PointFileType thisPointFileType=pointFileType; switch(thisPointFileType) { case XYZI: std::cout<<"Processing XYZI input file "<<argv[i]<<"..."<<std::flush; histogram = new float[256]; fileName=argv[i]; loadPointFileXyzi(pa, fileName, &valueMaximum, &valueMinimum); for(int index=0;index<256;index++) histogram[index]=0.0f; createHistogram(fileName, histogram, valueMaximum, valueMinimum); havePoints=true; std::cout<<" done."<<std::endl; break; default: std::cerr<<"Input file "<<argv[i]<<" has an unrecognized file format"<<std::endl; } } } /* Check if an output file name was given: */ if(outputFileName==0) { std::cerr<<"Usage: "<<argv[0]<<"-o <output file name> -np <max points per node> <input file spec>"<<std::endl; std::cerr<<"Input file spec: <format spec> <file name>"<<std::endl; std::cerr<<"Format spec: -XYZI"<<std::endl; std::cerr<<" -XYZRGB"<<std::endl; return 1; } /* Finish reading points: */ pa.finishReading(); loadTimer.elapse(); /* Construct an octree with less than maxPointsPerNode points per leaf: */ Misc::Timer createTimer; OctreeCreator tree(pa.getMaxNumCacheablePoints(),maxNumPointsPerNode,pa.getTempOctrees(),tempPointFileNameTemplate+"XXXXXX", histogram, valueMaximum, valueMinimum); /* Delete the temporary point octrees: */ pa.deleteTempOctrees(); createTimer.elapse(); /* Write the octree structure and data to the destination file: */ Misc::Timer writeTimer; tree.write(outputFileName); writeTimer.elapse(); std::cout<<"Time to load input data: "<<loadTimer.getTime()<<"s, time to create octree: "<<createTimer.getTime()<<"s, time to write final octree files: "<<writeTimer.getTime()<<"s"<<std::endl; return 0; }
void doStuff() { if(!stuffDone) { timer.start(); tex = siika->_textureManager->createTexture("tekstuuri.png"); siika->_shaderManager->useDefaultShader(true, true); //siika->_shaderManager->useShader(true, true); for (int i = 0; i < 50; i++) { spriteVector.push_back(siika->_spriteManager->createSprite(glm::vec2(100, 100), glm::vec2(64, 64), glm::vec2(32,32), tex, glm::vec2(0, 0), glm::vec2(1.0, 1.0))); } scream = siika->_audioManager->createAudio("wilhelm_scream.ogg"); scream->setMaxPlayerCount(10); teksti = siika->_textManager->createText(); teksti->setFont("arial.ttf"); teksti->setText("hello siika"); teksti->setPosition(0, 0.5); teksti->setFontSize(72); stuffDone = true; } std::vector<int> keys = siika->_input->getDownKeys(); for (int i = 0; i < keys.size(); i++) { s2d_info("%i",keys[i]); } for (int i = 0; i < siika->_input->touchPositionsActive(); i++) { position = siika->_input->touchPosition(i)._positionCurrent; scream->play(); } for (int i = 0; i < siika->_input->sticksActive(); i++) { orientation = siika->_input->stick(i)._rotation; } green += 2; for (int i = 0; i < spriteVector.size(); i++) spriteVector[i]->setColor(graphics::Color(0, green-i*10, blue-i*10, 255)); teksti->setColor(graphics::Color(0, green, blue, 255)); blue += 2; if(blue > 254) blue = 0; if(green > 252) green = 0; pos = pos + 0.01; if(pos > 1.0f) pos = -1.0; for (int i = 0; i < spriteVector.size();i++) spriteVector[i]->setPosition(glm::vec2(position.x+i, position.y+i*2)); for (int i = 0; i < spriteVector.size(); i++) { spriteVector[i]->setRotation(orientation); if (timer.getElapsedTime(TIME::SECONDS) > 2) { spriteVector[i]->step(); } } if (timer.getElapsedTime(TIME::SECONDS) > 2) timer.reset(); siika->_graphicsContext->clear(); // EBIN XD siika->_spriteManager->drawSprites(); siika->_textManager->drawTexts(); siika->_graphicsContext->swap(); //core::MemoryManager::getInstance().getCount(); }
int main(int argc,char* argv[]) { /* Open the depth stream file: */ IO::FilePtr depthFrameFile(IO::openFile("/work/okreylos/3DVideo/Kinect/DepthFrames.dat")); depthFrameFile->setEndianness(Misc::LittleEndian); /* Read the file header: */ unsigned int size[2]; depthFrameFile->read(size,2); /* Create a background frame: */ unsigned short* backgroundFrame=new unsigned short[size[1]*size[0]]; unsigned short* bfPtr=backgroundFrame; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr) *bfPtr=0x07ffU; unsigned int numCaptureFrames=150; /* Create the depth frame writer: */ IO::FilePtr compressedDepthFrameFile(IO::openFile("/work/okreylos/3DVideo/Kinect/CompressedDepthFrames.dat",IO::File::WriteOnly)); Kinect::DepthFrameWriter depthFrameWriter(*compressedDepthFrameFile,size); /* Process all frames from the depth frame file: */ size_t totalSize=0; double totalTime=0.0; double maxTime=0.0; unsigned int numFrames=0; while(!depthFrameFile->eof()) { /* Read the next frame's time stamp: */ double timeStamp=depthFrameFile->read<double>(); /* Read the next depth frame: */ Kinect::FrameBuffer frame(size[0],size[1],size[1]*size[0]*sizeof(unsigned short)); unsigned short* frameBuffer=static_cast<unsigned short*>(frame.getBuffer()); depthFrameFile->read(frameBuffer,size[1]*size[0]); if(numCaptureFrames>0) { /* Add the depth frame to the background frame: */ unsigned short* bfPtr=backgroundFrame; const unsigned short* dfPtr=frameBuffer; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr,++dfPtr) if(*bfPtr>*dfPtr-2) *bfPtr=*dfPtr-2; --numCaptureFrames; } else { /* Remove background from the depth frame: */ const unsigned short* bfPtr=backgroundFrame; unsigned short* dfPtr=frameBuffer; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr,++dfPtr) if(*dfPtr>=*bfPtr) *dfPtr=0x07ffU; } /* Compress and save the depth frame: */ Misc::Timer compressTime; compressedDepthFrameFile->write<double>(timeStamp); size_t compressedSize=depthFrameWriter.writeFrame(frame); compressTime.elapse(); double time=compressTime.getTime(); totalSize+=compressedSize; totalTime+=time; if(maxTime<time) maxTime=time; ++numFrames; } std::cout<<"Total compression time: "<<totalTime*1000.0<<" ms, total file size: "<<totalSize<<", "<<numFrames<<" frames"<<std::endl; std::cout<<"Maximum compression time: "<<maxTime*1000.0<<" ms"<<std::endl; std::cout<<"Compression frame rate: "<<double(numFrames)/totalTime<<" Hz"<<std::endl; std::cout<<"Bandwidth: "<<double(totalSize)*30.0/double(numFrames)/(1024.0*1024.0)<<"MB/s"<<std::endl; return 0; }
void* ClusterJello::simulationThreadMethodMaster(void) { /* Enable immediate cancellation of this thread: */ Threads::Thread::setCancelState(Threads::Thread::CANCEL_ENABLE); Threads::Thread::setCancelType(Threads::Thread::CANCEL_ASYNCHRONOUS); /* Simulate the crystal state until interrupted: */ Misc::Timer timer; double lastFrameTime=timer.peekTime(); double nextUpdateTime=timer.peekTime()+updateTime; while(true) { /* Calculate the current time step duration: */ double newFrameTime=timer.peekTime(); double timeStep=newFrameTime-lastFrameTime; lastFrameTime=newFrameTime; /* Check if the simulation parameters have been changed: */ if(simulationParameters.hasNewValue()) { /* Update the Jell-O crystal's simulation parameters: */ const SimulationParameters& sp=simulationParameters.lockNewValue(); crystal->setAtomMass(sp.atomMass); crystal->setAttenuation(sp.attenuation); crystal->setGravity(sp.gravity); } /* Check if the application has delivered new dragger states: */ if(draggerStates.hasNewValue()) { /* Process the new dragger states: */ const DraggerStates& ds=draggerStates.lockNewValue(); for(int draggerIndex=0;draggerIndex<ds.numDraggers;++draggerIndex) { if(ds.draggerActives[draggerIndex]) { /* Check if this dragger has just become active: */ if(!atomLocks.isEntry(ds.draggerIDs[draggerIndex])) { /* Find the atom picked by the dragger: */ AtomLock al; if(ds.draggerRayBaseds[draggerIndex]) al.draggedAtom=crystal->pickAtom(ds.draggerRays[draggerIndex]); else al.draggedAtom=crystal->pickAtom(ds.draggerTransformations[draggerIndex].getOrigin()); /* Try locking the atom: */ if(crystal->lockAtom(al.draggedAtom)) { /* Calculate the dragging transformation: */ al.dragTransformation=ds.draggerTransformations[draggerIndex]; al.dragTransformation.doInvert(); al.dragTransformation*=crystal->getAtomState(al.draggedAtom); /* Store the atom lock in the hash table: */ atomLocks.setEntry(AtomLockHasher::Entry(ds.draggerIDs[draggerIndex],al)); } } /* Check if the dragger has an atom lock: */ AtomLockHasher::Iterator alIt=atomLocks.findEntry(ds.draggerIDs[draggerIndex]); if(!alIt.isFinished()) { /* Set the position/orientation of the locked atom: */ ONTransform transform=ds.draggerTransformations[draggerIndex]; transform*=alIt->getDest().dragTransformation; crystal->setAtomState(alIt->getDest().draggedAtom,transform); } } else { /* Check if this dragger has just become inactive: */ AtomLockHasher::Iterator alIt=atomLocks.findEntry(ds.draggerIDs[draggerIndex]); if(!alIt.isFinished()) { /* Release the atom lock: */ crystal->unlockAtom(alIt->getDest().draggedAtom); atomLocks.removeEntry(alIt); } } } } /* Advance the simulation time by the last frame time: */ crystal->simulate(timeStep); /* Update the application's Jell-O state if the update interval is over: */ if(lastFrameTime>=nextUpdateTime) { if(clusterPipe!=0) { /* Broadcast the crystal state to all slave nodes: */ crystal->writeAtomStates(*clusterPipe); clusterPipe->finishMessage(); } /* Update the application's proxy crystal state: */ JelloCrystal& pc=proxyCrystal.startWrite(); pc.copyAtomStates(*crystal); proxyCrystal.finishWrite(); Vrui::requestUpdate(); /* Start the next update interval: */ nextUpdateTime+=updateTime; } } return 0; }
int main(int argc,char* argv[]) { /* Open the uncompressed depth stream file: */ IO::FilePtr depthFrameFile(IO::openFile("/work/okreylos/3DVideo/Kinect/DepthFrames.dat")); depthFrameFile->setEndianness(Misc::LittleEndian); /* Read the file header: */ unsigned int size[2]; depthFrameFile->read(size,2); /* Create a background frame: */ unsigned short* backgroundFrame=new unsigned short[size[1]*size[0]]; unsigned short* bfPtr=backgroundFrame; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr) *bfPtr=0x07ffU; unsigned int numCaptureFrames=150; /* Create the depth frame writer and reader: */ IO::FilePtr compressedDepthFrameFile(IO::openFile("/work/okreylos/3DVideo/Kinect/CompressedDepthFrames.dat",IO::File::ReadWrite)); Kinect::DepthFrameWriter depthFrameWriter(*compressedDepthFrameFile,size); compressedDepthFrameFile->flush(); Kinect::DepthFrameReader depthFrameReader(*compressedDepthFrameFile); /* Process all frames from the two depth frame files: */ double totalTime=0.0; double maxTime=0.0; unsigned int numFrames=0; while(!depthFrameFile->eof()) { /* Read the next uncompressed depth frame: */ Kinect::FrameBuffer frame0(size[0],size[1],size[1]*size[0]*sizeof(unsigned short)); frame0.timeStamp=depthFrameFile->read<double>(); unsigned short* frameBuffer0=frame0.getData<unsigned short>(); depthFrameFile->read(frameBuffer0,size[1]*size[0]); if(numCaptureFrames>0) { /* Add the depth frame to the background frame: */ unsigned short* bfPtr=backgroundFrame; const unsigned short* dfPtr=frameBuffer0; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr,++dfPtr) if(*bfPtr>*dfPtr-2) *bfPtr=*dfPtr-2; --numCaptureFrames; } else { /* Remove background from the depth frame: */ const unsigned short* bfPtr=backgroundFrame; unsigned short* dfPtr=frameBuffer0; for(unsigned int y=0;y<size[1];++y) for(unsigned int x=0;x<size[0];++x,++bfPtr,++dfPtr) if(*dfPtr>=*bfPtr) *dfPtr=0x07ffU; } /* Write the compressed depth frame: */ depthFrameWriter.writeFrame(frame0); compressedDepthFrameFile->flush(); /* Read the next compressed depth frame: */ Misc::Timer uncompressTime; Kinect::FrameBuffer frame1=depthFrameReader.readNextFrame(); uncompressTime.elapse(); double time=uncompressTime.getTime(); totalTime+=time; if(maxTime<time) maxTime=time; ++numFrames; /* Compare the two frames: */ unsigned int numPixels=size[0]*size[1]; const unsigned short* f0Ptr=frameBuffer0; const unsigned short* f1Ptr=frame1.getData<unsigned short>(); while(numPixels>0) { if(*f0Ptr!=*f1Ptr) std::cerr<<"Difference in frame "<<numFrames-1<<", "<<numPixels<<" pixels left"<<std::endl; ++f0Ptr; ++f1Ptr; --numPixels; } } std::cout<<"Total decompression time: "<<totalTime*1000.0<<" ms, "<<numFrames<<" frames"<<std::endl; std::cout<<"Maximum decompression time: "<<maxTime*1000.0<<" ms"<<std::endl; std::cout<<"Decompression frame rate: "<<double(numFrames)/totalTime<<" Hz"<<std::endl; return 0; }
void SpaceBall::deviceThreadMethod(void) { /* Create free-running timer to estimate tracker velocities: */ Misc::Timer timer; bool notFirstMeasurement=false; /* Receive lines from the serial port until interrupted: */ while(true) { /* Read characters until an end-of-line is encountered: */ unsigned char packet[256]; readPacket(256,packet); /* Determine the packet type: */ switch(packet[0]) { case 'D': { Vrui::VRDeviceState::TrackerState ts; /* Parse a data packet: */ short int rawData[6]; rawData[0]=(short int)(((unsigned int)packet[ 3]<<8)|(unsigned int)packet[ 4]); rawData[1]=(short int)(((unsigned int)packet[ 5]<<8)|(unsigned int)packet[ 6]); rawData[2]=(short int)(((unsigned int)packet[ 7]<<8)|(unsigned int)packet[ 8]); rawData[3]=(short int)(((unsigned int)packet[ 9]<<8)|(unsigned int)packet[10]); rawData[4]=(short int)(((unsigned int)packet[11]<<8)|(unsigned int)packet[12]); rawData[5]=(short int)(((unsigned int)packet[13]<<8)|(unsigned int)packet[14]); /* Calibrate linear data: */ PositionOrientation::Vector translation; for(int i=0;i<3;++i) translation[i]=double(rawData[i])*linearGain; translation[2]=-translation[2]; // Z-axis values are negated (?!?) /* Calibrate angular data: */ PositionOrientation::Vector rotationAxis; for(int i=0;i<3;++i) rotationAxis[i]=double(rawData[i+3])*angularGain; rotationAxis[2]=-rotationAxis[2]; // Z-axis values are negated (?!?) /* Construct incremental transformation: */ PositionOrientation t=PositionOrientation::translate(translation); PositionOrientation::Scalar rotationAngle=Geometry::mag(rotationAxis); PositionOrientation::Rotation rotation=PositionOrientation::Rotation::rotateAxis(rotationAxis,rotationAngle); t*=PositionOrientation::rotate(rotation); /* Accumulate current device position/orientation: */ currentPositionOrientation*=t; // currentPositionOrientation.leftMultiply(t); ts.positionOrientation=currentPositionOrientation; /* Calculate linear and angular velocities: */ timer.elapse(); if(notFirstMeasurement) { /* Estimate velocities by dividing position/orientation differences by elapsed time since last measurement: */ double time=timer.getTime(); ts.linearVelocity=translation/Vrui::VRDeviceState::TrackerState::LinearVelocity::Scalar(time); ts.angularVelocity=rotationAxis/Vrui::VRDeviceState::TrackerState::AngularVelocity::Scalar(time); } else { /* Force initial velocities to zero: */ ts.linearVelocity=Vrui::VRDeviceState::TrackerState::LinearVelocity::zero; ts.angularVelocity=Vrui::VRDeviceState::TrackerState::AngularVelocity::zero; notFirstMeasurement=true; } /* Update tracker state: */ setTrackerState(0,ts); break; } case '.': { /* Parse a button event packet: */ int buttonMask=0x0; buttonMask|=int(packet[2]&0x3f); buttonMask|=int(packet[2]&0x80)>>1; buttonMask|=int(packet[1]&0x1f)<<7; /* Update the current button states: */ for(int i=0;i<12;++i) setButtonState(i,buttonMask&(1<<i)); break; } } } }