[CC]点云密度计算

1.计算点云最近点的平均距离（点云的平均距离）http://pointclouds.org/documentation/tutorials/correspondence_grouping.php

double computeCloudResolution (const pcl::PointCloud<PointType>::ConstPtr &cloud)
{
  double res = 0.0;
  int n_points = 0;
  int nres;
  std::vector<int> indices (2);
  std::vector<float> sqr_distances (2);
  pcl::search::KdTree<PointType> tree;
  tree.setInputCloud (cloud);

  for (size_t i = 0; i < cloud->size (); ++i)
  {
    if (! pcl_isfinite ((*cloud)[i].x))
    {
      continue;
    }
    //Considering the second neighbor since the first is the point itself.
    nres = tree.nearestKSearch (i, 2, indices, sqr_distances);
    if (nres == 2)
    {
      res += sqrt (sqr_distances[1]);
      ++n_points;
    }
  }
  if (n_points != 0)
  {
    res /= n_points;
  }
  return res;
}

assert(m_app);
    if (!m_app)
        return;

    const ccHObject::Container& selectedEntities = m_app->getSelectedEntities();
    size_t selNum = selectedEntities.size();
    if (selNum!=1)
    {
        m_app->dispToConsole("Select only one cloud!",ccMainAppInterface::ERR_CONSOLE_MESSAGE);
        return;
    }

    ccHObject* ent = selectedEntities[0];
    assert(ent);
    if (!ent || !ent->isA(CC_TYPES::POINT_CLOUD))
    {
        m_app->dispToConsole("Select a real point cloud!",ccMainAppInterface::ERR_CONSOLE_MESSAGE);
        return;
    }

    ccPointCloud* m_cc_cloud = static_cast<ccPointCloud*>(ent);

    //input cloud
    unsigned count = m_cc_cloud->size();
    bool hasNorms = m_cc_cloud->hasNormals();
    CCVector3 bbMin, bbMax;
    m_cc_cloud->getBoundingBox(bbMin,bbMax);
    const CCVector3d& globalShift = m_cc_cloud->getGlobalShift();
    double globalScale = m_cc_cloud->getGlobalScale();

    pcl::PointCloud<PointXYZ>::Ptr pcl_cloud (new pcl::PointCloud<PointXYZ>);
    try
    {
        unsigned pointCount = m_cc_cloud->size();
        pcl_cloud->resize(pointCount);

        for (unsigned i = 0; i < pointCount; ++i)
        {
            const CCVector3* P = m_cc_cloud->getPoint(i);
            pcl_cloud->at(i).x = static_cast<float>(P->x);
            pcl_cloud->at(i).y = static_cast<float>(P->y);
            pcl_cloud->at(i).z = static_cast<float>(P->z);
        }
    }
    catch(...)
    {
        //any error (memory, etc.)
        pcl_cloud.reset();
    }
    if (!target_indices_ || target_indices_->size () == 0)
    {
        target_indices_.reset (new std::vector <int> (static_cast <int> (pcl_cloud->size ())));
        int index = 0;
        for (std::vector <int>::iterator it = target_indices_->begin (), it_e = target_indices_->end (); it != it_e; it++)
            *it = index++;
    }
    Eigen::Vector4f pt_min, pt_max;
    pcl::getMinMax3D (*pcl_cloud, *target_indices_, pt_min, pt_max);
    double diameter_ = (pt_max - pt_min).norm ();//点云中最远的两个点的距离
    double dis=computeCloudResolution(pcl_cloud);
    m_app->dispToConsole(QString("cross distance (c=%1)
mean distance(m=%2)").arg(diameter_,0,'f').arg(dis,0,'f'),ccMainAppInterface::STD_CONSOLE_MESSAGE);