int
main ()
{
SimpleOpenNIViewer v;
v.run ();
return 0;
}
int main(int argc, char* argv[])
{
std::cout << "Press 's' key to capture a pcd\n";
if( argc > 4 )
{
help(argv[0]);
return 0;
}
else
{
for(int i = 1; i < argc; i++ )
{
const char* s = argv[i];
if( strcmp( s, "-f" ) == 0 )
{
i++;
filename = argv[i];
}
else
{
help(argv[0]);
return fprintf( stderr, "Unknown option %s\n", s ), -1;
}
}
}
SimpleOpenNIViewer v;
v.run ();
return 0;
}
int
main (int argc, char** argv)
{
// Default values
int num_cameras(1);
/*
* Parse command line arguments
*/
if (pcl::console::find_argument (argc, argv, "-h") >= 0)
{
printUsage (argv[0]);
return 0;
}
// Number of cameras
if (pcl::console::find_argument(argc, argv, "-n") >= 0)
{
pcl::console::parse_argument(argc, argv, "-n", num_cameras);
}
SimpleOpenNIViewer v (num_cameras);
v.run ();
return 0;
}
int main (int argc, char* argv[])
{
assert(argc > 1);
id = (atoi(argv[1]));
SimpleOpenNIViewer v;
v.run ();
return 0;
}
int main ()
{
boost::thread workerThread(visualize);
SimpleOpenNIViewer v;
v.run ();
workerThread.join();
return 0;
}
int
main (int, char **)
{
SimpleOpenNIViewer v;
v.run ();
return (0);
}
int
main (int argc, char **argv)
{
SimpleOpenNIViewer v;
v.run ();
return (0);
}
/* ******************************************************************************************** */
int main (int argc, char* argv[]) {
assert(argc > 1);
id = (atoi(argv[1]));
pthread_mutex_init(&lock, NULL);
pthread_mutex_init(&lock2, NULL);
SimpleOpenNIViewer v;
v.run ();
return 0;
}
int main ()
{
InitSharedMemory();
SimpleOpenNIViewer v;
//pcl::gpu::printShortCudaDeviceInfo
v.run ();
return 0;
}
int
main (int argc, char **argv)
{
OctreePointCloudCompression<PointXYZRGBA>* octreeCoder;
pcl::io::compression_Profiles_e compressionProfile;
bool showStatistics;
double pointResolution;
float octreeResolution;
bool doVoxelGridDownDownSampling;
unsigned int iFrameRate;
bool doColorEncoding;
unsigned int colorBitResolution;
bool bShowInputCloud;
// default values
showStatistics = false;
pointResolution = 0.001;
octreeResolution = 0.01f;
doVoxelGridDownDownSampling = false;
iFrameRate = 30;
doColorEncoding = false;
colorBitResolution = 6;
compressionProfile = pcl::io::MED_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR;
bShowInputCloud = false;
std::string fileName = "pc_compressed.pcc";
std::string hostName = "localhost";
bool bServerFileMode;
bool bEnDecode;
bool validArguments;
validArguments = false;
bServerFileMode = false;
bEnDecode = false;
float min_v = 0.0f, max_v = 3.0f;
pcl::console::parse_2x_arguments (argc, argv, "-minmax", min_v, max_v, false);
std::string field_name ("z");
pcl::console::parse_argument (argc, argv, "-field", field_name);
if (pcl::console::find_argument (argc, argv, "-e")>0)
bShowInputCloud = true;
if (pcl::console::find_argument (argc, argv, "-s")>0)
{
bEnDecode = true;
bServerFileMode = true;
validArguments = true;
}
if (pcl::console::parse_argument (argc, argv, "-c", hostName)>0)
{
bEnDecode = false;
bServerFileMode = true;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-x")>0)
{
bEnDecode = true;
bServerFileMode = false;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-d")>0)
{
bEnDecode = false;
bServerFileMode = false;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-t")>0)
showStatistics = true;
if (pcl::console::find_argument (argc, argv, "-a")>0)
{
doColorEncoding = true;
compressionProfile = pcl::io::MANUAL_CONFIGURATION;
}
if (pcl::console::find_argument (argc, argv, "-v")>0)
{
doVoxelGridDownDownSampling = true;
compressionProfile = pcl::io::MANUAL_CONFIGURATION;
}
pcl::console::parse_argument (argc, argv, "-f", fileName);
pcl::console::parse_argument (argc, argv, "-r", pointResolution);
pcl::console::parse_argument (argc, argv, "-i", iFrameRate);
pcl::console::parse_argument (argc, argv, "-o", octreeResolution);
pcl::console::parse_argument (argc, argv, "-b", colorBitResolution);
std::string profile;
if (pcl::console::parse_argument (argc, argv, "-p", profile)>0)
{
if (profile == "lowC")
compressionProfile = pcl::io::LOW_RES_OFFLINE_COMPRESSION_WITH_COLOR;
else if (profile == "lowNC")
compressionProfile = pcl::io::LOW_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR;
else if (profile == "medC")
compressionProfile = pcl::io::MED_RES_OFFLINE_COMPRESSION_WITH_COLOR;
else if (profile =="medNC")
compressionProfile = pcl::io::MED_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR;
else if (profile == "highC")
compressionProfile = pcl::io::HIGH_RES_OFFLINE_COMPRESSION_WITH_COLOR;
else if (profile == "highNC")
compressionProfile = pcl::io::HIGH_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR;
else
{
print_usage ("Unknown profile parameter..\n");
return -1;
}
if (compressionProfile != MANUAL_CONFIGURATION)
{
// apply selected compression profile
// retrieve profile settings
const pcl::io::configurationProfile_t selectedProfile = pcl::io::compressionProfiles_[compressionProfile];
// apply profile settings
pointResolution = selectedProfile.pointResolution;
octreeResolution = float (selectedProfile.octreeResolution);
doVoxelGridDownDownSampling = selectedProfile.doVoxelGridDownSampling;
iFrameRate = selectedProfile.iFrameRate;
doColorEncoding = selectedProfile.doColorEncoding;
colorBitResolution = selectedProfile.colorBitResolution;
}
}
if (pcl::console::find_argument (argc, argv, "-?")>0)
{
print_usage ("");
return 1;
}
if (!validArguments)
{
print_usage ("Please specify compression mode..\n");
return -1;
}
octreeCoder = new OctreePointCloudCompression<PointXYZRGBA> (compressionProfile, showStatistics, pointResolution,
octreeResolution, doVoxelGridDownDownSampling, iFrameRate,
doColorEncoding, static_cast<unsigned char> (colorBitResolution));
if (!bServerFileMode)
{
if (bEnDecode)
{
// ENCODING
ofstream compressedPCFile;
compressedPCFile.open (fileName.c_str(), ios::out | ios::trunc | ios::binary);
if (!bShowInputCloud)
{
EventHelper v (compressedPCFile, octreeCoder, field_name, min_v, max_v);
v.run ();
}
else
{
SimpleOpenNIViewer v (compressedPCFile, octreeCoder);
v.run ();
}
} else
{
// DECODING
ifstream compressedPCFile;
compressedPCFile.open (fileName.c_str(), ios::in | ios::binary);
compressedPCFile.seekg (0);
compressedPCFile.unsetf (ios_base::skipws);
pcl::visualization::CloudViewer viewer ("PCL Compression Viewer");
while (!compressedPCFile.eof())
{
PointCloud<PointXYZRGBA>::Ptr cloudOut (new PointCloud<PointXYZRGBA> ());
octreeCoder->decodePointCloud ( compressedPCFile, cloudOut);
viewer.showCloud (cloudOut);
}
}
} else
{
// switch to ONLINE profiles
if (compressionProfile == pcl::io::LOW_RES_OFFLINE_COMPRESSION_WITH_COLOR)
compressionProfile = pcl::io::LOW_RES_ONLINE_COMPRESSION_WITH_COLOR;
else if (compressionProfile == pcl::io::LOW_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR)
compressionProfile = pcl::io::LOW_RES_ONLINE_COMPRESSION_WITHOUT_COLOR;
else if (compressionProfile == pcl::io::MED_RES_OFFLINE_COMPRESSION_WITH_COLOR)
compressionProfile = pcl::io::MED_RES_ONLINE_COMPRESSION_WITH_COLOR;
else if (compressionProfile == pcl::io::MED_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR)
compressionProfile = pcl::io::MED_RES_ONLINE_COMPRESSION_WITHOUT_COLOR;
else if (compressionProfile == pcl::io::HIGH_RES_OFFLINE_COMPRESSION_WITH_COLOR)
compressionProfile = pcl::io::HIGH_RES_ONLINE_COMPRESSION_WITH_COLOR;
else if (compressionProfile == pcl::io::HIGH_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR)
compressionProfile = pcl::io::HIGH_RES_ONLINE_COMPRESSION_WITHOUT_COLOR;
if (bEnDecode)
{
// ENCODING
try
{
boost::asio::io_service io_service;
tcp::endpoint endpoint (tcp::v4 (), 6666);
tcp::acceptor acceptor (io_service, endpoint);
tcp::iostream socketStream;
std::cout << "Waiting for connection.." << std::endl;
acceptor.accept (*socketStream.rdbuf ());
std::cout << "Connected!" << std::endl;
if (!bShowInputCloud)
{
EventHelper v (socketStream, octreeCoder, field_name, min_v, max_v);
v.run ();
}
else
{
SimpleOpenNIViewer v (socketStream, octreeCoder);
v.run ();
}
std::cout << "Disconnected!" << std::endl;
boost::this_thread::sleep(boost::posix_time::seconds(3));
}
catch (std::exception& e)
{
std::cerr << e.what () << std::endl;
}
}
else
{
// DECODING
std::cout << "Connecting to: " << hostName << ".." << std::endl;
try
{
tcp::iostream socketStream (hostName.c_str (), "6666");
std::cout << "Connected!" << std::endl;
pcl::visualization::CloudViewer viewer ("Decoded Point Cloud - PCL Compression Viewer");
while (!socketStream.fail())
{
FPS_CALC ("drawing");
PointCloud<PointXYZRGBA>::Ptr cloudOut (new PointCloud<PointXYZRGBA> ());
octreeCoder->decodePointCloud (socketStream, cloudOut);
viewer.showCloud (cloudOut);
}
}
catch (std::exception& e)
{
std::cout << "Exception: " << e.what () << std::endl;
}
}
}
delete (octreeCoder);
return (0);
}
int
main (int argc, char ** argv)
{
std::string device_id ("");
pcl::OpenNIGrabber::Mode image_mode = pcl::OpenNIGrabber::OpenNI_Default_Mode;
if (argc >= 2)
{
device_id = argv[1];
if (device_id == "--help" || device_id == "-h")
{
usage (argv);
return (0);
}
else if (device_id == "-l")
{
if (argc >= 3)
{
pcl::OpenNIGrabber grabber (argv[2]);
boost::shared_ptr<openni_wrapper::OpenNIDevice> device = grabber.getDevice ();
std::vector<std::pair<int, XnMapOutputMode> > modes;
if (device->hasImageStream ())
{
cout << endl << "Supported image modes for device: " << device->getVendorName () << " , " << device->getProductName () << endl;
modes = grabber.getAvailableImageModes ();
for (std::vector<std::pair<int, XnMapOutputMode> >::const_iterator it = modes.begin (); it != modes.end (); ++it)
{
cout << it->first << " = " << it->second.nXRes << " x " << it->second.nYRes << " @ " << it->second.nFPS << endl;
}
}
}
else
{
openni_wrapper::OpenNIDriver& driver = openni_wrapper::OpenNIDriver::getInstance ();
if (driver.getNumberDevices () > 0)
{
for (unsigned deviceIdx = 0; deviceIdx < driver.getNumberDevices (); ++deviceIdx)
{
cout << "Device: " << deviceIdx + 1 << ", vendor: " << driver.getVendorName (deviceIdx) << ", product: " << driver.getProductName (deviceIdx)
<< ", connected: " << driver.getBus (deviceIdx) << " @ " << driver.getAddress (deviceIdx) << ", serial number: \'" << driver.getSerialNumber (deviceIdx) << "\'" << endl;
}
}
else
cout << "No devices connected." << endl;
cout <<"Virtual Devices available: ONI player" << endl;
}
return (0);
}
}
else
{
openni_wrapper::OpenNIDriver& driver = openni_wrapper::OpenNIDriver::getInstance ();
if (driver.getNumberDevices() > 0)
cout << "Device Id not set, using first device." << endl;
}
unsigned mode;
if (pcl::console::parse (argc, argv, "-imagemode", mode) != -1)
image_mode = static_cast<pcl::OpenNIGrabber::Mode> (mode);
pcl::OpenNIGrabber grabber (device_id, pcl::OpenNIGrabber::OpenNI_Default_Mode, image_mode);
SimpleOpenNIViewer v (grabber);
v.run ();
return (0);
}
int
main(int argc, char ** argv)
{
std::string device_id("");
pcl::OpenNIGrabber::Mode depth_mode = pcl::OpenNIGrabber::OpenNI_Default_Mode;
pcl::OpenNIGrabber::Mode image_mode = pcl::OpenNIGrabber::OpenNI_Default_Mode;
bool xyz = false;
if (argc >= 2)
{
device_id = argv[1];
if (device_id == "--help" || device_id == "-h")
{
usage(argv);
return 0;
}
else if (device_id == "-l")
{
if (argc >= 3)
{
pcl::OpenNIGrabber grabber(argv[2]);
boost::shared_ptr<openni_wrapper::OpenNIDevice> device = grabber.getDevice();
cout << "Supported depth modes for device: " << device->getVendorName() << " , " << device->getProductName() << endl;
std::vector<std::pair<int, XnMapOutputMode > > modes = grabber.getAvailableDepthModes();
for (std::vector<std::pair<int, XnMapOutputMode > >::const_iterator it = modes.begin(); it != modes.end(); ++it)
{
cout << it->first << " = " << it->second.nXRes << " x " << it->second.nYRes << " @ " << it->second.nFPS << endl;
}
if (device->hasImageStream ())
{
cout << endl << "Supported image modes for device: " << device->getVendorName() << " , " << device->getProductName() << endl;
modes = grabber.getAvailableImageModes();
for (std::vector<std::pair<int, XnMapOutputMode > >::const_iterator it = modes.begin(); it != modes.end(); ++it)
{
cout << it->first << " = " << it->second.nXRes << " x " << it->second.nYRes << " @ " << it->second.nFPS << endl;
}
}
}
else
{
openni_wrapper::OpenNIDriver& driver = openni_wrapper::OpenNIDriver::getInstance();
if (driver.getNumberDevices() > 0)
{
for (unsigned deviceIdx = 0; deviceIdx < driver.getNumberDevices(); ++deviceIdx)
{
cout << "Device: " << deviceIdx + 1 << ", vendor: " << driver.getVendorName(deviceIdx) << ", product: " << driver.getProductName(deviceIdx)
<< ", connected: " << (int) driver.getBus(deviceIdx) << " @ " << (int) driver.getAddress(deviceIdx) << ", serial number: \'" << driver.getSerialNumber(deviceIdx) << "\'" << endl;
}
}
else
cout << "No devices connected." << endl;
cout <<"Virtual Devices available: ONI player" << endl;
}
return 0;
}
}
else
{
openni_wrapper::OpenNIDriver& driver = openni_wrapper::OpenNIDriver::getInstance();
if (driver.getNumberDevices() > 0)
cout << "Device Id not set, using first device." << endl;
}
unsigned mode;
if (pcl::console::parse(argc, argv, "-depthmode", mode) != -1)
depth_mode = (pcl::OpenNIGrabber::Mode) mode;
if (pcl::console::parse(argc, argv, "-imagemode", mode) != -1)
image_mode = (pcl::OpenNIGrabber::Mode) mode;
if (pcl::console::find_argument(argc, argv, "-xyz") != -1)
xyz = true;
pcl::OpenNIGrabber grabber (device_id, depth_mode, image_mode);
if (xyz) // only if xyz flag is set, since grabber provides at least XYZ and XYZI pointclouds
{
SimpleOpenNIViewer<pcl::PointXYZ> v (grabber);
v.run ();
}
else if (grabber.providesCallback<pcl::OpenNIGrabber::sig_cb_openni_point_cloud_rgb> ())
{
SimpleOpenNIViewer<pcl::PointXYZRGBA> v (grabber);
v.run ();
}
else
{
SimpleOpenNIViewer<pcl::PointXYZI> v (grabber);
v.run ();
}
return (0);
}
int
main (int argc, char **argv)
{
OrganizedPointCloudCompression<PointXYZRGBA>* organizedCoder;
bool showStatistics;
bool doColorEncoding;
bool bShowInputCloud;
bool bRawImageEncoding;
bool bGrayScaleConversion;
std::string fileName = "pc_compressed.pcc";
std::string hostName = "localhost";
bool bServerFileMode;
bool bEnDecode;
bool validArguments;
validArguments = false;
bServerFileMode = false;
bEnDecode = false;
showStatistics = false;
doColorEncoding = false;
bShowInputCloud = false;
bRawImageEncoding = false;
bGrayScaleConversion = false;
if (pcl::console::find_argument (argc, argv, "-e")>0)
bShowInputCloud = true;
if (pcl::console::find_argument (argc, argv, "-r")>0)
bRawImageEncoding = true;
if (pcl::console::find_argument (argc, argv, "-g")>0)
bGrayScaleConversion = true;
if (pcl::console::find_argument (argc, argv, "-s")>0)
{
bEnDecode = true;
bServerFileMode = true;
validArguments = true;
}
if (pcl::console::parse_argument (argc, argv, "-c", hostName)>0)
{
bEnDecode = false;
bServerFileMode = true;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-a")>0)
{
doColorEncoding = true;
}
if (pcl::console::find_argument (argc, argv, "-x")>0)
{
bEnDecode = true;
bServerFileMode = false;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-d")>0)
{
bEnDecode = false;
bServerFileMode = false;
validArguments = true;
}
if (pcl::console::find_argument (argc, argv, "-t")>0)
showStatistics = true;
pcl::console::parse_argument (argc, argv, "-f", fileName);
if (pcl::console::find_argument (argc, argv, "-?")>0)
{
print_usage ("");
return 1;
}
if (!validArguments)
{
print_usage ("Please specify compression mode..\n");
return -1;
}
organizedCoder = new OrganizedPointCloudCompression<PointXYZRGBA> ();
if (!bServerFileMode)
{
if (bEnDecode)
{
// ENCODING
ofstream compressedPCFile;
compressedPCFile.open (fileName.c_str(), ios::out | ios::trunc | ios::binary);
if (!bShowInputCloud)
{
EventHelper v (compressedPCFile, organizedCoder, doColorEncoding, showStatistics, bRawImageEncoding, bGrayScaleConversion);
v.run ();
}
else
{
SimpleOpenNIViewer v (compressedPCFile, organizedCoder, doColorEncoding, showStatistics, bRawImageEncoding, bGrayScaleConversion);
v.run ();
}
} else
{
// DECODING
ifstream compressedPCFile;
compressedPCFile.open (fileName.c_str(), ios::in | ios::binary);
compressedPCFile.seekg (0);
compressedPCFile.unsetf (ios_base::skipws);
pcl::visualization::CloudViewer viewer ("PCL Compression Viewer");
while (!compressedPCFile.eof())
{
PointCloud<PointXYZRGBA>::Ptr cloudOut (new PointCloud<PointXYZRGBA> ());
organizedCoder->decodePointCloud ( compressedPCFile, cloudOut );
viewer.showCloud (cloudOut);
}
}
} else
{
if (bEnDecode)
{
// ENCODING
try
{
boost::asio::io_service io_service;
tcp::endpoint endpoint (tcp::v4 (), 6666);
tcp::acceptor acceptor (io_service, endpoint);
tcp::iostream socketStream;
std::cout << "Waiting for connection.." << std::endl;
acceptor.accept (*socketStream.rdbuf ());
std::cout << "Connected!" << std::endl;
if (!bShowInputCloud)
{
EventHelper v (socketStream, organizedCoder, doColorEncoding, showStatistics, bRawImageEncoding, bGrayScaleConversion);
v.run ();
}
else
{
SimpleOpenNIViewer v (socketStream, organizedCoder, doColorEncoding, showStatistics, bRawImageEncoding, bGrayScaleConversion);
v.run ();
}
std::cout << "Disconnected!" << std::endl;
std::this_thread::sleep_for(3s);
}
catch (std::exception& e)
{
std::cerr << e.what () << std::endl;
}
}
else
{
// DECODING
std::cout << "Connecting to: " << hostName << ".." << std::endl;
try
{
tcp::iostream socketStream (hostName.c_str (), "6666");
std::cout << "Connected!" << std::endl;
pcl::visualization::CloudViewer viewer ("Decoded Point Cloud - PCL Compression Viewer");
while (!socketStream.fail())
{
FPS_CALC ("drawing");
PointCloud<PointXYZRGBA>::Ptr cloudOut (new PointCloud<PointXYZRGBA> ());
organizedCoder->decodePointCloud (socketStream, cloudOut);
viewer.showCloud (cloudOut);
}
}
catch (std::exception& e)
{
std::cout << "Exception: " << e.what () << std::endl;
}
}
}
delete (organizedCoder);
return (0);
}
