### Start DistCC Daemon

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/distcc.md

Example command to start the distcc daemon on an Ubuntu system.

```default
/etc/init.d/distcc start
```

--------------------------------

### Stereo Example CMakeLists.txt

Source: https://github.com/pointcloudlibrary/pcl/blob/master/examples/stereo/CMakeLists.txt

CMakeLists.txt configuration for the PCL stereo example.

```cmake
if(NOT BUILD_visualization)
  return()
endif()

PCL_SUBSYS_DEPEND(build NAME ${SUBSYS_NAME} DEPS visualization)

## Find VTK
if(NOT VTK_FOUND)
  set(DEFAULT FALSE)
  set(REASON "VTK was not found.")
else()
  set(DEFAULT TRUE)
  set(REASON)
endif()

PCL_ADD_EXAMPLE(pcl_example_stereo_baseline FILES example_stereo_baseline.cpp
                LINK_WITH pcl_common pcl_visualization pcl_stereo pcl_io)
```

--------------------------------

### Add Example: pcl_example_copy_point_cloud

Source: https://github.com/pointcloudlibrary/pcl/blob/master/examples/common/CMakeLists.txt

Defines a PCL example that demonstrates copying a point cloud.

```cmake
PCL_ADD_EXAMPLE(pcl_example_copy_point_cloud FILES example_copy_point_cloud.cpp LINK_WITH pcl_common)
```

--------------------------------

### Build Qt

Source: https://github.com/pointcloudlibrary/pcl/wiki/QT_installers

Commands to build and clean Qt.

```bash
nmake
nmake clean
```

--------------------------------

### Class and Struct Naming Examples

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Provides examples of correctly named classes and structs according to the style guide.

```cpp
class ExampleClass;
class PFHEstimation;
```

--------------------------------

### Compile and Run (No Qt Project Configured)

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/qt_colorize_cloud.md

Instructions for compiling and running the example if the Qt project is not configured, involving CMake and make.

```bash
cmake ../src && make -j2 && ./pcl_visualizer
```

--------------------------------

### Visualization Setup

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/tutorials/content/global_hypothesis_verification.md

This code snippet demonstrates setting up a PCL visualizer to display the scene and the recognized model instances, including keypoints if enabled.

```cpp
  /**
   *  Visualization
   */
  pcl::visualization::PCLVisualizer viewer ("Hypotheses Verification");
  viewer.addPointCloud (scene, "scene_cloud");

  pcl::PointCloud<PointType>::Ptr off_scene_model (new pcl::PointCloud<PointType> ());
  pcl::PointCloud<PointType>::Ptr off_scene_model_keypoints (new pcl::PointCloud<PointType> ());

  pcl::PointCloud<PointType>::Ptr off_model_good_kp (new pcl::PointCloud<PointType> ());
  pcl::transformPointCloud (*model, *off_scene_model, Eigen::Vector3f (-1, 0, 0), Eigen::Quaternionf (1, 0, 0, 0));
  pcl::transformPointCloud (*model_keypoints, *off_scene_model_keypoints, Eigen::Vector3f (-1, 0, 0), Eigen::Quaternionf (1, 0, 0, 0));
  pcl::transformPointCloud (*model_good_kp, *off_model_good_kp, Eigen::Vector3f (-1, 0, 0), Eigen::Quaternionf (1, 0, 0, 0));

  if (show_keypoints_)
  {
    CloudStyle modelStyle = style_white;
    pcl::visualization::PointCloudColorHandlerCustom<PointType> off_scene_model_color_handler (off_scene_model, modelStyle.r, modelStyle.g, modelStyle.b);
    viewer.addPointCloud (off_scene_model, off_scene_model_color_handler, "off_scene_model");
    viewer.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, modelStyle.size, "off_scene_model");
  }

  if (show_keypoints_)
  {
    CloudStyle goodKeypointStyle = style_violet;
    pcl::visualization::PointCloudColorHandlerCustom<PointType> model_good_keypoints_color_handler (off_model_good_kp, goodKeypointStyle.r, goodKeypointStyle.g,
                                                                                                    goodKeypointStyle.b);
    viewer.addPointCloud (off_model_good_kp, model_good_keypoints_color_handler, "model_good_keypoints");
    viewer.setPointCloudRenderingProperties (pcl::visualization::PCL_VISUALIZER_POINT_SIZE, goodKeypointStyle.size, "model_good_keypoints");

```

--------------------------------

### Install PCL with a different triplet type

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_vcpkg_windows.md

Command to install PCL with a specific triplet type, for example, x64-windows.

```powershell
./vcpkg install pcl –triplet triplet_type
```

```powershell
./vcpkg install pcl –triplet x64-windows
```

--------------------------------

### Install Apache and PHP

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/generate_local_doc.md

Installs Apache web server and PHP for enabling the search feature.

```bash
$ sudo apt-get install apache2 php5 libapache2-mod-php5
```

--------------------------------

### Example of a simple point + color scenario

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl2.md

An example illustrating the proposed data structure for a point and color scenario.

```default
cloud = { "pos" => pos_space, "color" => color_space }
pos_space = ( "float with euclidean 2-norm distance", { "x", "y", "z" }, [[(0.3,0,1.3) , ... , (1.2,3.1,2)], ... , [(1,0.3,1) , ... , (2,0,3.5)]] )
color_space = ( "uint8 with rgb distance", { "r", "g", "b" }, [[(0,255,0), ... , (128,255,32)] ... [(12,54,31) ... (255,0,192)]] )
```

--------------------------------

### Install PCL without extra dependencies

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/installing_homebrew.md

You can specify options to control which parts of PCL are installed. For example, to build just the libraries without extra dependencies, execute the following command:

```bash
$ brew install pcl --without-apps --without-tools --without-vtk --without-qt
```

--------------------------------

### More Complete Sample

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/tutorials/content/cloud_viewer.md

A comprehensive example showcasing how to run code on the visualization thread using CloudViewer, including callbacks for single-run and per-iteration functions, and demonstrating interaction with the underlying PCLVisualizer.

```cpp
#include <pcl/visualization/cloud_viewer.h>
#include <iostream>
#include <pcl/common/io.h>
#include <pcl/io/pcd_io.h>    
int user_data;
void 
viewerOneOff (pcl::visualization::PCLVisualizer& viewer)
{
    viewer.setBackgroundColor (1.0, 0.5, 1.0);
    pcl::PointXYZ o;
    o.x = 1.0;
    o.y = 0;
    o.z = 0;
    viewer.addSphere (o, 0.25, "sphere", 0);
    std::cout << "i only run once" << std::endl;
    
}
void 
viewerPsycho (pcl::visualization::PCLVisualizer& viewer)
{
    static unsigned count = 0;
    std::stringstream ss;
    ss << "Once per viewer loop: " << count++;
    viewer.removeShape ("text", 0);
    viewer.addText (ss.str(), 200, 300, "text", 0);
    
    //FIXME: possible race condition here:
    user_data++;
}
int 
main ()
{
    pcl::PointCloud<pcl::PointXYZRGBA>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBA>);
    pcl::io::loadPCDFile ("my_point_cloud.pcd", *cloud);
    
    pcl::visualization::CloudViewer viewer("Cloud Viewer");
    
    //blocks until the cloud is actually rendered
    viewer.showCloud(cloud);
    
    //use the following functions to get access to the underlying more advanced/powerful
    //PCLVisualizer
    
    //This will only get called once
    viewer.runOnVisualizationThreadOnce (viewerOneOff);
    
    //This will get called once per visualization iteration
    viewer.runOnVisualizationThread (viewerPsycho);
    while (!viewer.wasStopped ()) 
    {
    //you can also do cool processing here
    //FIXME: Note that this is running in a separate thread from viewerPsycho
    //and you should guard against race conditions yourself...
    user_data++;
    }
    return 0;
}
```

--------------------------------

### Running the Program (Basic)

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/global_hypothesis_verification.md

This is an example of how to launch the compiled executable with two PCD files as input.

```bash
./global_hypothesis_verification milk.pcd milk_cartoon_all_small_clorox.pcd
```

--------------------------------

### Get root access for install command

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/compiling_pcl_docker.md

Command to enter the Docker container with root privileges to execute the install command.

```bash
docker exec -it <container_name>
```

--------------------------------

### Configure Qt

Source: https://github.com/pointcloudlibrary/pcl/wiki/QT_installers

Command to configure Qt build for Windows.

```bash
configure -opensource -confirm-license -fast -debug-and-release -nomake examples -nomake demos -no-qt3support -no-xmlpatterns -no-multimedia -no-phonon -no-accessibility -no-openvg -no-webkit -no-script -no-scripttools -no-dbus -no-declarative
```

--------------------------------

### Constant Declaration Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Shows the naming convention for constants.

```cpp
const static int MY_CONSTANT = 1000;
```

--------------------------------

### Throwing an Exception

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/exceptions_guide.md

Example of using the PCL_THROW_EXCEPTION macro to throw a custom exception.

```cpp
if (my_requirements != the_parameters_used_)
  PCL_THROW_EXCEPTION (MyException, "my requirements are not met " << the_parameters_used);
```

--------------------------------

### Generating fake data

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/minimal_example.md

This snippet shows how to generate fake point cloud data for testing purposes.

```cpp
pcl::PointCloud<pcl::PointCloudXYZ> cloud;
cloud.insert (cloud.end (), PointXYZ (1, 1, 1));
```

--------------------------------

### Complete SamplesConfig.xml example

Source: https://github.com/pointcloudlibrary/pcl/wiki/MacOS

An example of a complete SamplesConfig.xml file with the added properties for depth image registration.

```xml
<OpenNI>
  <Licenses>
  </Licenses>
  <Log writeToConsole="true" writeToFile="false">
    <LogLevel value="1"/>
      <Masks>
        <Mask name="ALL" on="true"/>
      </Masks>
      <Dumps>
      </Dumps>
  </Log>
  <ProductionNodes>
    <Node type="Depth" name="Dept##>
      <Configuration>
        <Property type="int" name="RegistrationType" value="2"/>
        <Property type="int" name="Registration" value="1"/>
      </Configuration>
    </Node>
    <Node type="Image" name="Image1" stopOnError="false">
      <Configuration>
      </Configuration>
    </Node>
  </ProductionNodes>
</OpenNI>
```

--------------------------------

### Defining a new Exception

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/exceptions_guide.md

Example of how to define a new exception by inheriting from PCLException.

```cpp
#include <pcl/exceptions.h>

/** \class MyException
  * \brief An exception that is thrown when I want it.
  */

class PCL_EXPORTS MyException : public PCLException
{
  public:
    MyException (const std::string& error_description,
                 const char* file_name = NULL,
                 const char* function_name = NULL,
                 unsigned line_number = 0)
      : pcl::PCLException (error_description, file_name, function_name, line_number) { } 
};
```

--------------------------------

### Qt Build Configuration

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/tutorials/content/compiling_pcl_dependencies_windows.md

Configuring and building Qt from source using the command prompt.

```default
prompt> cd c:\Qt\4.8.0
```

```default
prompt> configure -opensource -confirm-license -fast -debug-and-release -nomake examples -nomake demos -no-qt3support -no-xmlpatterns -no-multimedia -no-phonon -no-accessibility -no-openvg -no-webkit -no-script -no-scripttools -no-dbus -no-declarative
```

```default
prompt> nmake
```

```default
prompt> nmake clean
```

--------------------------------

### Variable Declaration Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Shows the standard naming convention for variables.

```cpp
int my_variable;
```

--------------------------------

### Exception Handling with try-catch

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/exceptions_guide.md

Example of how to handle specific exceptions using try-catch blocks.

```cpp
// Here we call myFunction which can throw MyException
try
{
  myObject.myFunction (some_number);
  // You can put more exceptions throwing instruction within same try block
}
// We catch only MyException to be very specific
catch (pcl::MyException& e)
{
  // Code to deal with the exception maybe changing myObject.the_parameters_used_
}

// Here we catch any exception
#if 0
catch (exception& e)
{
  // Code to deal with the exception maybe changing myObject.the_parameters_used_
}
#endif
```

--------------------------------

### Qt Build Command

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/compiling_pcl_dependencies_windows.md

Building Qt using nmake.

```default
prompt> nmake
```

--------------------------------

### Documenting Exceptions

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/exceptions_guide.md

Example of documenting a function that can throw an exception using Doxygen tags.

```cpp
/** Function that does cool stuff
  * \param nb number of points
  * \throws MyException
  */
void
myFunction (int nb);
```

--------------------------------

### Running the Program (with increased bin size)

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/global_hypothesis_verification.md

This example demonstrates how to run the program with a modified 'cg_size' parameter to simulate more false positives.

```bash
./global_hypothesis_verification milk.pcd milk_cartoon_all_small_clorox.pcd --cg_size 0.035
```

--------------------------------

### Iterator Naming Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Illustrates how to name iterator variables to indicate what they iterate over.

```cpp
std::list<int> pid_list;
std::list<int>::iterator pid_it;
```

--------------------------------

### PCLViewer Class Constructor - QVTK Window Setup

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/qt_colorize_cloud.md

Sets up the QVTK window for visualization.

```cpp
  // Set up the QVTK window
#if VTK_MAJOR_VERSION > 8
  auto renderer = vtkSmartPointer<vtkRenderer>::New();
  auto renderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
  renderWindow->AddRenderer(renderer);
  viewer_.reset(new pcl::visualization::PCLVisualizer(renderer, renderWindow, "viewer", false));
  ui->qvtkWidget->setRenderWindow(viewer_->getRenderWindow());
  viewer_->setupInteractor(ui->qvtkWidget->interactor(), ui->qvtkWidget->renderWindow());
#else
  viewer_.reset(new pcl::visualization::PCLVisualizer("viewer", false));
  ui->qvtkWidget->SetRenderWindow(viewer_->getRenderWindow());
  viewer_->setupInteractor(ui->qvtkWidget->GetInteractor(), ui->qvtkWidget->GetRenderWindow());
#endif

```

--------------------------------

### Template Class Method Implementation

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Example of brace placement for template class method implementations.

```cpp
template <typename T> void
Foo<T>::bar ()
{
  ...
```

--------------------------------

### Simple OpenNI Viewer Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/openni_grabber.md

A basic example demonstrating how to set up and use the OpenNI Grabber to display point cloud data from a compatible camera using a cloud viewer.

```cpp
#include <pcl/io/openni_grabber.h>
#include <pcl/visualization/cloud_viewer.h>


#include <chrono>
#include <thread>

using namespace std::chrono_literals;


class SimpleOpenNIViewer
{
  public:
    SimpleOpenNIViewer () : viewer ("PCL OpenNI Viewer") {}

    void cloud_cb_ (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud)
    {
      if (!viewer.wasStopped())
        viewer.showCloud (cloud);
    }

    void run ()
    {
      pcl::Grabber* interface = new pcl::OpenNIGrabber();

      std::function<void (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr&)> f =
        [this] (const pcl::PointCloud<pcl::PointXYZ>::ConstPtr& cloud) { cloud_cb_ (cloud); };

      interface->registerCallback (f);

      interface->start ();

      while (!viewer.wasStopped())
      {
        std::this_thread::sleep_for(1s);
      }

      interface->stop ();
    }

    pcl::visualization::CloudViewer viewer;
};

int main ()
{
  SimpleOpenNIViewer v;
  v.run ();
  return 0;
}
```

--------------------------------

### PCLViewer Class Constructor - UI and Cloud Setup

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/qt_colorize_cloud.md

Sets up the UI, window title, and generates a random point cloud.

```cpp
{ 
  ui->setupUi (this);
  this->setWindowTitle ("PCL viewer");

  // Setup the cloud pointer
  cloud_.reset (new PointCloudT);
  // The number of points in the cloud
  cloud_->resize (500);

  // Fill the cloud with random points
  for (std::size_t i = 0; i < cloud_->size (); ++i)
  {
    (*cloud_)[i].x = 1024 * rand () / (RAND_MAX + 1.0f);
    (*cloud_)[i].y = 1024 * rand () / (RAND_MAX + 1.0f);
    (*cloud_)[i].z = 1024 * rand () / (RAND_MAX + 1.0f);
  }

```

--------------------------------

### Function and Method Naming Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Demonstrates the naming convention for functions and methods, including arguments.

```cpp
int
applyExample (int example_arg);
```

--------------------------------

### pcl_viewer Usage Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/walkthrough.md

Example usage of pcl_viewer for multi-viewport rendering.

```bash
pcl_viewer -multiview 1 data/partial_cup_model.pcd data/partial_cup_model.pcd data/partial_cup_model.pcd
```

--------------------------------

### Member Variable Naming Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Demonstrates the naming convention for member variables, including the trailing underscore.

```cpp
int example_int_;
```

--------------------------------

### Class Member Indentation and Access Qualifiers

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/pcl_style_guide.md

Example showing class member indentation and the placement of access qualifiers.

```cpp
namespace foo
{

class Bar
{
  int i;
  public:
    int j;
  protected:
    void
    baz ();
};
}
```

--------------------------------

### Dinast Grabber Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/dinast_grabber.md

A small example demonstrating how to set up a pcl::PointCloud<XYZI> callback to a Dinast camera device.

```cpp
#include <pcl/common/time.h>
#include <pcl/io/dinast_grabber.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/point_types.h>

#include <chrono>
#include <thread>

using namespace std::chrono_literals;

template <typename PointType>
class DinastProcessor {
public:
  using Cloud = pcl::PointCloud<PointType>;
  using CloudConstPtr = typename Cloud::ConstPtr;

  DinastProcessor(pcl::Grabber& grabber)
  : interface(grabber), viewer("Dinast Cloud Viewer")
  {}

  void
  cloud_cb_(CloudConstPtr cloud_cb)
  {
    static unsigned count = 0;
    static double last = pcl::getTime();
    if (++count == 30) {
      double now = pcl::getTime();
      std::cout << "Average framerate: " << double(count) / double(now - last) << " Hz"
                << std::endl;
      count = 0;
      last = now;
    }
    if (!viewer.wasStopped())
      viewer.showCloud(cloud_cb);
  }

  int
  run()
  {

    std::function<void(const CloudConstPtr&)> f = [this](const CloudConstPtr& cloud) {
      cloud_cb_(cloud);
    };

    boost::signals2::connection c = interface.registerCallback(f);

    interface.start();

    while (!viewer.wasStopped()) {
      std::this_thread::sleep_for(1s);
    }

    interface.stop();

    return 0;
  }

  pcl::Grabber& interface;
  pcl::visualization::CloudViewer viewer;
};

int
main()
{
  pcl::DinastGrabber grabber;
  DinastProcessor<pcl::PointXYZI> v(grabber);
  v.run();
  return 0;
}

```

--------------------------------

### Application Setup and Execution

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/gpu_people.md

The application object is created, the RDF detector is assigned, and the main loop is started.

```cpp
    // Create the app
    PeoplePCDApp app(*capture);
    app.people_detector_.rdf_detector_ = rdf;

    // executing
    app.startMainLoop ();
```

--------------------------------

### Install Dependencies

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/generate_local_doc.md

Installs the necessary dependencies for generating PCL documentation.

```bash
$ sudo apt-get install doxygen graphviz sphinx3 python-pip
$ sudo pip install sphinxcontrib-doxylink
```

--------------------------------

### KLDAdaptiveParticleFilterOMPTracker Example

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/tracking.md

This C++ code demonstrates the setup and usage of the KLDAdaptiveParticleFilterOMPTracker for real-time point cloud tracking using an OpenNI device.

```cpp
#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <functional>

#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/tracking/kld.h>
#include <pcl/tracking/particle_filter.h>
#include <pcl/tracking/coherent_point_cloud.h>
#include <pcl/tracking/distance_coherence.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/kdtree/kdtree_flann.h>
#include <pcl/common/transforms.h>
#include <pcl/registration/icp.h>
#include <pcl/filters/voxel_grid.h>
#include <pcl/io/openni_grabber.h>

#include <Eigen/Core

#define USE_CALLBACK_THREAD

// Define point types
typedef pcl::PointXYZ PointT;
typedef pcl::PointCloud<PointT> Cloud;
typedef pcl::PointCloud<PointT>::Ptr CloudPtr;
typedef pcl::PointCloud<PointT>::ConstPtr CloudConstPtr;

// Define particle type
typedef pcl::tracking::ParticleXYZRPY ParticleT;

// Global variables
CloudPtr target_cloud (new Cloud ());
CloudPtr particle_cloud (new Cloud ());

bool new_cloud_ = false;

// Tracker object
pcl::tracking::ParticleFilter<PointT>::Ptr tracker_;

// Viewer object
pcl::visualization::CloudViewer* viewer_ = nullptr;

// Downsampling grid size
float downsampling_grid_size_ = 0.002f;

// Callback function for processing new clouds
void cloud_cb (const CloudConstPtr& cloud)
{
  if (!new_cloud_)
  {
    particle_cloud = boost::make_shared<Cloud> (*cloud);
    new_cloud_ = true;
  }
}

// Visualization callback
void viz_cb (pcl::visualization::PCLVisualizer& viz)
{
  if (new_cloud_)
  {
    if (!viewer_->wasStopped ())
    {
      viewer_->showCloud (particle_cloud);
      new_cloud_ = false;
    }
  }
}

// Function to approximate grid sampling
void gridSampleApprox (const CloudPtr& cloud, CloudPtr& result, float grid_size)
{
  pcl::VoxelGrid<PointT> grid;
  grid.setLeafSize (grid_size, grid_size, grid_size);
  grid.setInputCloud (cloud);
  grid.filter (*result);
}

int
main (int argc, char** argv)
{
  if (argc < 3)
    {
      PCL_WARN("Please set device_id pcd_filename(e.g. $ %s '#1' sample.pcd)\n", argv[0]);
      exit (1);
    }

  //read pcd file
  target_cloud.reset(new Cloud());
  if(pcl::io::loadPCDFile (argv[2], *target_cloud) == -1){
    std::cout << "pcd file not found" << std::endl;
    exit(-1);
  }

  std::string device_id = std::string (argv[1]);  

  int counter = 0;

  //Set parameters
  new_cloud_ = false;
  downsampling_grid_size_ =  0.002;

  std::vector<double> default_step_covariance = std::vector<double> (6, 0.015 * 0.015);
default_step_covariance[3] *= 40.0;
default_step_covariance[4] *= 40.0;
default_step_covariance[5] *= 40.0;

  std::vector<double> initial_noise_covariance = std::vector<double> (6, 0.00001);
  std::vector<double> default_initial_mean = std::vector<double> (6, 0.0);

  pcl::tracking::KLDAdaptiveParticleFilterOMPTracker<PointT, ParticleT>::Ptr tracker
    (new pcl::tracking::KLDAdaptiveParticleFilterOMPTracker<PointT, ParticleT> (8));

  ParticleT bin_size;
  bin_size.x = 0.1f;
  bin_size.y = 0.1f;
  bin_size.z = 0.1f;
  bin_size.roll = 0.1f;
  bin_size.pitch = 0.1f;
  bin_size.yaw = 0.1f;


  //Set all parameters for  KLDAdaptiveParticleFilterOMPTracker
  tracker->setMaximumParticleNum (1000);
  tracker->setDelta (0.99);
  tracker->setEpsilon (0.2);
  tracker->setBinSize (bin_size);

  //Set all parameters for  ParticleFilter
  tracker_ = tracker;
  tracker_->setTrans (Eigen::Affine3f::Identity ());
  tracker_->setStepNoiseCovariance (default_step_covariance);
  tracker_->setInitialNoiseCovariance (initial_noise_covariance);
  tracker_->setInitialNoiseMean (default_initial_mean);
  tracker_->setIterationNum (1);
  tracker_->setParticleNum (600);
  tracker_->setResampleLikelihoodThr(0.00);
  tracker_->setUseNormal (false);


  //Setup coherence object for tracking
  pcl::tracking::ApproxNearestPairPointCloudCoherence<PointT>::Ptr coherence
    (new pcl::tracking::ApproxNearestPairPointCloudCoherence<PointT>);

  pcl::tracking::DistanceCoherence<PointT>::Ptr distance_coherence
    (new pcl::tracking::DistanceCoherence<PointT>);
  coherence->addPointCoherence (distance_coherence);

  pcl::search::Octree<PointT>::Ptr search (new pcl::search::Octree<PointT> (0.01));
  coherence->setSearchMethod (search);
  coherence->setMaximumDistance (0.01);

  tracker_->setCloudCoherence (coherence);

  //prepare the model of tracker's target
  Eigen::Vector4f c;
  Eigen::Affine3f trans = Eigen::Affine3f::Identity ();
  CloudPtr transed_ref (new Cloud);
  CloudPtr transed_ref_downsampled (new Cloud);

  pcl::compute3DCentroid<PointT> (*target_cloud, c);
  trans.translation ().matrix () = Eigen::Vector3f (c[0], c[1], c[2]);
  pcl::transformPointCloud<PointT> (*target_cloud, *transed_ref, trans.inverse());
  gridSampleApprox (transed_ref, *transed_ref_downsampled, downsampling_grid_size_);

  //set reference model and trans
  tracker_->setReferenceCloud (transed_ref_downsampled);
  tracker_->setTrans (trans);

  //Setup OpenNIGrabber and viewer
  viewer_ = new pcl::visualization::CloudViewer("PCL OpenNI Tracking Viewer");
  pcl::Grabber* interface = new pcl::OpenNIGrabber (device_id);
  std::function<void (const CloudConstPtr&)> f = cloud_cb;
  interface->registerCallback (f);

  viewer_->runOnVisualizationThread (viz_cb, "viz_cb");

  //Start viewer and object tracking
  interface->start();
  while (!viewer_->wasStopped ())
    std::this_thread::sleep_for(std::chrono::seconds(1));
  interface->stop();

  return (0);
}

```

--------------------------------

### Install the documentation

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/generate_local_doc.md

Command to install the generated PCL documentation.

```bash
$ sudo make install
```

--------------------------------

### Qt Configuration Command

Source: https://github.com/pointcloudlibrary/pcl/blob/master/doc/advanced/content/compiling_pcl_dependencies_windows.md

Configuring a minimal build of Qt with Open Source license.

```default
prompt> configure -opensource -confirm-license -fast -debug-and-release -nomake examples -nomake demos -no-qt3support -no-xmlpatterns -no-multimedia -no-phonon -no-accessibility -no-openvg -no-webkit -no-script -no-scripttools -no-dbus -no-declarative
```