void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
if (event.getKeySym () == "r" && event.keyDown ())
{
boost::mutex::scoped_lock startLock(updateOnlineMutex);
std::cout << "r was pressed => starting construction " << std::endl;
PointCloud<pcl::PointXYZRGB>::Ptr deep_copy (new PointCloud<pcl::PointXYZRGB>( *onlineView ) );
if(noFrames == 0)
{
cloudA = deep_copy;
boost::thread workerThread(alignFrames);
cout << "Started recording --> " << endl;
start = true;
}
noFrames++;
startLock.unlock();
}else if (event.getKeySym () == "p" && event.keyDown ())
{
stop = true;
condQ.notify_one();
//surfaceConst.fastTranguilation(global);
}else if(event.getKeySym() == "s" && event.keyDown())
{
boost::mutex::scoped_lock saveLock(updateOnlineMutex);
std::cout << "s was pressed => saving" << std::endl;
PointCloud<pcl::PointXYZRGB>::Ptr deep_copy (new PointCloud<pcl::PointXYZRGB>( *onlineView ) );
std::stringstream tmp;
tmp << noFrames << ".pcd";
pcl::io::savePCDFileBinary(tmp.str() , *deep_copy);
noFrames++;
saveLock.unlock();
}
}
void
keyboardEventOccurred(const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *>(viewer_void);
if(event.getKeySym() == "d" && event.keyDown())
cout << "d";
if(event.getKeySym() == "n" && event.keyDown())
viewer->removeAllPointClouds();
}
// change camera view point
void chCameraViewPoint (const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
boost::shared_ptr<visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "a" && event.keyDown ())
viewer->setCameraPosition(camera_left[0], camera_left[1], camera_left[2], camera_left[3], camera_left[4], camera_left[5]);
if (event.getKeySym () == "s" && event.keyDown ())
viewer->setCameraPosition(camera_front[0], camera_front[1], camera_front[2], camera_front[3], camera_front[4], camera_front[5]);
if (event.getKeySym () == "d" && event.keyDown ())
viewer->setCameraPosition(camera_right[0], camera_right[1], camera_right[2], camera_right[3], camera_right[4], camera_right[5]);
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
if ( (event.getKeySym () == "r" || event.getKeySym () == "R") && event.keyDown ())
{
cout << "r was pressed => change between regular/graph representation" << endl;
graphRepresentation = !graphRepresentation;
}
else if ( (event.getKeySym () == "p" || event.getKeySym () == "P") && event.keyDown ())
showPointCloud = !showPointCloud;
else if ( (event.getKeySym () == "l" || event.getKeySym () == "L") && event.keyDown ())
showPbMap = !showPbMap;
}
void myCallback (const pcl::visualization::KeyboardEvent& event, void* cookie)
{
if(event.getKeySym () == "q" && event.keyDown ())
{
pressedQ=true;
}
else if(event.getKeySym () == "a" && event.keyDown ())
{
pressedA=true;
}
else
return;
}
void keyboardCallback(const pcl::visualization::KeyboardEvent &event, void *) {
std::string special_key = event.getKeyCode() ? "" : "special ";
if (event.keyDown())
Logger::log(Logger::INFO, "The %skey %c was pressed.", special_key.c_str(), event.getKeyCode());
else
Logger::log(Logger::INFO, "The %skey %c was released.", special_key.c_str(), event.getKeyCode());
}
void
KeyboardEventOccurred(const pcl::visualization::KeyboardEvent &event, void * data)
{
R200Grabber * g = (R200Grabber*)data;
std::shared_ptr<DSAPI> p = g->getDSAPI();
if(event.keyDown())
{
if(event.getKeySym() == "o")
{
p->accessHardware()->setDepthControlParameters(DSGetDepthControlPreset(DS_DEPTHCONTROL_PRESET_OFF));
std::cout << "activated DS_DEPTHCONTROL_PRESET_OFF" << std::endl;
}
if(event.getKeySym() == "p")
{
p->accessHardware()->setDepthControlParameters(DSGetDepthControlPreset(DS_DEPTHCONTROL_PRESET_LOW));
std::cout << "activated DS_DEPTHCONTROL_PRESET_LOW" << std::endl;
}
if(event.getKeySym() == "k")
{
p->accessHardware()->setDepthControlParameters(DSGetDepthControlPreset(DS_DEPTHCONTROL_PRESET_MEDIUM));
std::cout << "activated DS_DEPTHCONTROL_PRESET_MEDIUM" << std::endl;
}
if(event.getKeySym() == "l")
{
p->accessHardware()->setDepthControlParameters(DSGetDepthControlPreset(DS_DEPTHCONTROL_PRESET_HIGH));
std::cout << "activated DS_DEPTHCONTROL_PRESET_HIGH" << std::endl;
}
if(event.getKeySym() == "m")
{
p->accessHardware()->setDepthControlParameters(DSGetDepthControlPreset(DS_DEPTHCONTROL_PRESET_OPTIMIZED));
std::cout << "activated DS_DEPTHCONTROL_PRESET_OPTIMIZED" << std::endl;
}
}
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
if ( (event.getKeySym () == "r" || event.getKeySym () == "R") && event.keyDown ())
{
graphRepresentation = !graphRepresentation;
}
}
void SimpleOpenNIViewer::keyboard_callback (const pcl::visualization::KeyboardEvent& event, void* cookie)
{
unsigned char key = 0;
string* message = (string*)cookie;
cout << (*message) << " :: ";
if (event.getKeyCode())
{
key = event.getKeyCode();
//cout << "the key \'" << event.getKeyCode() << "\' (" << (int)event.getKeyCode() << ") was";
}
else
;//cout << "the special key \'" << event.getKeySym() << "\' was";
if (event.keyDown())
;//cout << " pressed" << endl;
else
{
if(key )
{
proc_key(key);
//cout << " released" << endl;
}
}
}
void keyboard_cb(const pcl::visualization::KeyboardEvent &event, void* viewer_void) {
if (event.getKeySym () == "q" && event.keyDown ()) {
std::cout << "Exiting." << std::endl;
viewer.close();
}
if (event.getKeySym () == "s" && event.keyDown ()) {
if (running) {
running = false;
std::cout << "Stopping modelling." << std::endl;
} else {
running = true;
std::cout << "Starting modelling." << std::endl;
}
}
}
void
KeyboardEventOccurred(const pcl::visualization::KeyboardEvent &event, void * data)
{
std::string pressed;
pressed = event.getKeySym();
PlySaver * s = (PlySaver*)data;
if(event.keyDown())
{
if(pressed == "s")
{
pcl::PLYWriter writer;
std::chrono::high_resolution_clock::time_point p = std::chrono::high_resolution_clock::now();
std::string now = std::to_string((long)std::chrono::duration_cast<std::chrono::milliseconds>(p.time_since_epoch()).count());
cv::Mat color;
for(size_t i = 0; i < s->kinects_.size(); ++i){
writer.write ("cloud_"+ std::to_string(i) + "_" + now + ".ply", *(s->clouds_[i]), s->binary_, s->use_camera_);
s->kinects_[i]->getColor(color);
cv::imwrite("color_" + std::to_string(i) + "_" + now + ".jpg", color);
}
std::cout << "saved " << "cloud and color " + now << std::endl;
}
if(pressed == "x")
{
for(auto & k : s->kinects_){
k->storeParameters();
}
std::cout << "stored calibration parameters" << std::endl;
}
}
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* cookie)
{
if (event.getKeySym () == "space" && event.keyDown ()) // Save annotation file
{
viewer->spinOnce();
}
}
/** \brief callback function for the PCLvisualizer */
void
keyboard_callback (const pcl::visualization::KeyboardEvent &event, void *cookie)
{
if (event.keyDown())
{
switch (event.getKeyCode())
{
case 27:
case (int)'q':
case (int)'Q':
case (int)'e':
case (int)'E':
cout << "Exiting program" << endl;
quit = true;
break;
case (int)'s':
case (int)'S':
cout << "Saving volume and cloud" << endl;
save = true;
break;
default:
break;
}
}
}
void
keyboardEventOccurred (const pcl::visualization::KeyboardEvent& event,
void* nothing)
{
if (event.getKeySym () == "space" && event.keyDown ())
next_iteration = true;
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* viewer_void) {
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "n" && event.keyDown () && pausing)
{
std::cout << "n was pressed => next frame" << std::endl;
pausing = false;
}
}
static void onSwitchKeyPressed(const pcl::visualization::KeyboardEvent& e, void* data)
{
SwitchKeyBinding* binding = (SwitchKeyBinding*) data;
if(e.keyDown() && e.getKeySym() == binding->key)
{
binding->s.toggle();
}
}
/**
* @function keyboardEventOccurred
*/
void keyboardEventOccurred( const pcl::visualization::KeyboardEvent &_event,
void *_nothing ) {
// Save cloud when pressing space
if( _event.getKeySym() == "space" && _event.keyDown() ) {
gProcessCloud = true;
}
}
void
keyboardEventOccurred(const pcl::visualization::KeyboardEvent& event,
void* nothing)
{
if (event.getKeySym() == "space" && event.keyDown())
boost::this_thread::sleep(boost::posix_time::seconds(5));
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,
void* viewer_void) {
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer =
*static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
double dd = 0.01;
if (event.getKeySym () == "a" && event.keyDown ()) (*T)(0,3) += dd;
if (event.getKeySym () == "d" && event.keyDown ()) (*T)(0,3) -= dd;
if (event.getKeySym () == "w" && event.keyDown ()) (*T)(1,3) += dd;
if (event.getKeySym () == "s" && event.keyDown ()) (*T)(1,3) -= dd;
if (event.getKeySym () == "j" && event.keyDown ()) {
printf("\nasdf\nasdf\nasdf\n");
(*T)(2,3) += dd;
}
if (event.getKeySym () == "l" && event.keyDown ()) (*T)(2,3) -= dd;
if (event.getKeySym () == "n" && event.keyDown ()) {
T = &T1;
printf("Working on transform 1\n");
}
if (event.getKeySym () == "m" && event.keyDown ()) {
T = &T2;
printf("Working on transform 2\n");
}
if (event.getKeySym () == "k" && event.keyDown ()) {
T = &T3;
printf("Working on transform 3\n");
}
if (event.getKeySym () == "i" && event.keyDown ()) seeAll = !seeAll;
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event, void* viewer_void){
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "n" && event.keyDown ())
{
std::cout << "n was pressed => changing viewing point" << std::endl;
viewer->removeAllPointClouds();
//viewer->addPointCloud(cloud,"keyboardId");
}
}
/*---------------------------------------------*-
* KEYBOARD EVENT TRACKING
* Keys we like: (* = all PCL owned)
* 'q' = quit*
* 'r' = recentre the view*
* 'c' = capture
-*---------------------------------------------*/
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,void* viewer_void)
{
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "c"&&event.keyDown ())
{
std::cout <<"c was pressed => capturing a pointcloud"<< std::endl;
std::string filename = "KinectCap";
filename.append(boost::lexical_cast<std::string>(cloud_id));
filename.append(".pcd");
pcl::io::savePCDFileASCII (filename, *cloud);
cloud_id++;
}
if (event.getKeySym() == "d" && event.keyDown())
{
std::cout << "d was pressed => going to detect now" << std::endl;
do_detection = true;
}
}
//Defining callback
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,void* viewer_void)
{
if (event.getKeySym () == "s" && event.keyDown ())
{
std::cout << "s was pressed : starting" << std::endl;
v.save_cloud();
}
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,
void* viewer_void)
{
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym() == "n" && event.keyDown ())
{
pressed = true;
}
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,
void* viewer_void)
{
static bool existSight = false;
pcl::visualization::PCLVisualizer *viewer = static_cast<pcl::visualization::PCLVisualizer*> (viewer_void);
if (event.getKeySym () == "f" && event.keyDown ())
{
//viewer->removeShape ("o1");
//viewer->removePointCloud("p1");
//viewer->resetCameraViewpoint("o2");
//viewer->setCameraPosition(1,1,1,3,2,1);
//viewer->setCameraPosition(_x--,_y,_z,x,y,z);
}
if (event.getKeySym () == "j" && event.keyDown ()){
// get camera
std::vector<pcl::visualization::Camera> cameras;
viewer->getCameras(cameras);
pcl::visualization::Camera &c = *cameras.begin();
camera_info(*cameras.begin());
// remove camera point and line of sight
if(existSight){
viewer->removePointCloud("camera");
viewer->removeShape("sight");
}
existSight = true;
// add camera point
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGB>);
cloud->points.push_back(create_point(c.pos[0], c.pos[1], c.pos[2], 0, 0, 255));
pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgbs(cloud);
viewer->addPointCloud<pcl::PointXYZRGB> (cloud, rgbs,"camera");
viewer->setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 30, "camera");
// add line of sight
pcl::PointXYZ cameraPos(c.pos[0], c.pos[1], c.pos[2]);
pcl::PointXYZ view(c.view[0], c.view[1], c.view[2]);
viewer->addLine(cameraPos, view, "sight");
/*pcl::PointCloud<pcl::PointXYZ>::Ptr scene (new pcl::PointCloud<pcl::PointXYZ>());*/
/*viewer->renderView(300, 600, scene);*/
}
}
///Keyboard Event Tracking
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,
void* viewer_void)
{
boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<pcl::visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "c" && event.keyDown ())
{
std::cout << "c was pressed => capturing a pointcloud" << std::endl;
std::string filename = "KinectCap";
filename.append(boost::lexical_cast<std::string>(cloud_id));
filename.append(".pcd");
pcl::io::savePCDFileASCII (filename, *cloud);
cloud_id++;
}
if (event.getKeySym () == "b" && event.keyDown ())
{
std::cout << "b was pressed" << std::endl;
if (BackgroundSub == false)
{
//Start background subtraction
if (hasBackground == false)
{
//Copy over the current cloud as a BG cloud.
pcl::copyPointCloud(*cloud, *bgcloud);
hasBackground = true;
}
BackgroundSub = true;
}
else
{
//Stop Background Subtraction
BackgroundSub = false;
}
}
if (event.getKeySym () == "v" && event.keyDown ())
{
std::cout << "v was pressed" << std::endl;
Voxelize = !Voxelize;
}
}
void
OpenNIFrameSource::onKeyboardEvent (const pcl::visualization::KeyboardEvent & event)
{
// When the spacebar is pressed, trigger a frame capture
mutex_.lock ();
if (event.keyDown () && event.getKeySym () == "e")
{
active_ = false;
}
mutex_.unlock ();
}
void
OpenNICapture::onKeyboardEvent (const pcl::visualization::KeyboardEvent & event)
{
// When the spacebar is pressed, trigger a frame capture
mutex_.lock ();
if (event.keyDown () && event.getKeySym () == "space")
{
trigger_ = true;
}
mutex_.unlock ();
}
void keyboardEventOccurred (const pcl::visualization::KeyboardEvent &event,
void *stop_void)
{
boost::shared_ptr<bool> stop = *static_cast<boost::shared_ptr<bool>*> (stop_void);
if (event.getKeySym () == "s" && event.keyDown ())
{
*stop = ! *stop;
if (*stop) std::cout << "Computing is now stopped!\n";
else std::cout << "Computing commencing!\n";
}
}
void Viewer::keyboardEventOccurred( const pcl::visualization::KeyboardEvent &event, void* data ) {
if( ( event.getKeySym() == "d" || event.getKeySym() == "D" ) && event.keyDown() ) {
if( event.getKeySym() == "d" ) {
selectedDepth++;
}
else {
selectedDepth--;
if( selectedDepth < 0 )
selectedDepth = 15;
}
selectedDepth = selectedDepth % 16;
std::cout << "Selected Depth " << selectedDepth << "\n";
}
if( ( event.getKeySym() == "v" || event.getKeySym() == "V" ) && event.keyDown() ) {
if( event.getKeySym() == "v" ) {
selectedViewDir++;
if( selectedViewDir == 7 )
selectedViewDir = -1;
}
else {
selectedViewDir--;
if( selectedViewDir < -1 )
selectedViewDir = 6;
}
std::cout << "Selected View Dir " << selectedViewDir << "\n";
}
if( ( event.getKeySym() == "p" ) && event.keyDown() ) {
processFrame = true;
}
if( ( event.getKeySym() == "s" ) && event.keyDown() ) {
displayScene = !displayScene;
}
if( ( event.getKeySym() == "m" ) && event.keyDown() ) {
displayMap = !displayMap;
}
if( ( event.getKeySym() == "a" ) && event.keyDown() ) {
displayAll = !displayAll;
}
if( ( event.getKeySym() == "c" ) && event.keyDown() ) {
displayCorr = !displayCorr;
}
if( ( event.getKeySym() == "f" ) && event.keyDown() ) {
forceRedraw = true;
}
}
void showModel(const pcl::visualization::KeyboardEvent &event, void* viewer_void)
{
boost::shared_ptr<visualization::PCLVisualizer> viewer = *static_cast<boost::shared_ptr<visualization::PCLVisualizer> *> (viewer_void);
if (event.getKeySym () == "m" && event.keyDown ())
{
if(show == true)
{
viewer->removeAllShapes();
show = false;
reshow = false;
}
else
{
show = true;
reshow = true;
}
}
if (event.getKeySym () == "b" && event.keyDown ())
{
if(skel == true)
{
viewer->removeAllShapes();
skel = false;
reshow = true;
}
else
{
viewer->removeAllShapes();
skel = true;
reshow = true;
}
}
}