blocks|key|178314|text|柔性碰撞库(+fcl+)库可以实现快速的碰撞检测。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|178315|以下是受支持的不同对象形状：|178316|球体|unordered-list-item|178317|盒|178318|锥状|178319|汽缸|178320|网格|178321|八叉树(可选的，octree使用octomap库http://octomap.github.com表示)|178322|我假设你的点云是从物体表面抽取的样本，这些物体占据了三维空间中的体积。所以，你必须把你的点云转换成一个网格或者一个占用率八叉树。|178323|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/flexible-collision-library/fcl#readme|1|http://octomap.github.com/^0|7|3|0|0|0|0|0|0|0|0|O|P|1|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$]]|$1|I|3|J|5|H|7|1A|8|@]|9|@]|C|$]]|$1|K|3|L|5|H|7|1B|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|1C|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|1D|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|1E|8|@]|9|@$A|1F|B|1G|1|1H]]|C|$]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

The <a href="https://github.com/flexible-collision-library/fcl#readme" rel="nofollow">fcl</a> (Flexible Collision Library) library can do fast collision detection.

Here are the supported different object shapes:

<ul>
<li>sphere</li>
<li>box</li>
<li>cone</li>
<li>cylinder</li>
<li>mesh</li>
<li>octree (optional, octrees are represented using the octomap library <a href="http://octomap.github.com" rel="nofollow">http://octomap.github.com</a>)</li>
</ul>

I assume your point clouds are samples drawn from the surface of objects that occupy a volume in 3D space. So, you'll have to transform your point clouds into a mesh or in an occupancy octree.

blocks|key|2186338|text|只是为了扩展@fferri关于如何使用fcl+(灵活冲突库)检查碰撞的答案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2186339|1.从点云创建fcl::CollisionObject。|2186340|这里我使用八叉树作为点云的概率表示。|2186341|std::shared_ptr<fcl::CollisionObject>+createCollisionObject(const+pcl::PointCloud<pcl::PointXYZ>::Ptr+pointcloud_ptr,+const+octomap::point3d&+sensor_origin_wrt_world)
{
++//+octomap+octree+settings
++const+double+resolution+=+0.01;
++const+double+prob_hit+=+0.9;
++const+double+prob_miss+=+0.1;
++const+double+clamping_thres_min+=+0.12;
++const+double+clamping_thres_max+=+0.98;

++std::shared_ptr<octomap::OcTree>+octomap_octree+=+std::make_shared<octomap::OcTree>(resolution);
++octomap_octree->setProbHit(prob_hit);
++octomap_octree->setProbMiss(prob_miss);
++octomap_octree->setClampingThresMin(clamping_thres_min);
++octomap_octree->setClampingThresMax(clamping_thres_max);

++octomap::KeySet+free_cells;
++octomap::KeySet+occupied_cells;

#if+defined(_OPENMP)
#pragma+omp+parallel
#endif
++{
#if+defined(_OPENMP)
++++auto+thread_id+=+omp_get_thread_num();
++++auto+thread_num+=+omp_get_num_threads();
#else
++++int+thread_id+=+0;
++++int+thread_num+=+1;
#endif
++++int+start_idx+=+static_cast<int>(pointcloud_ptr->size()+/+thread_num)+*+thread_id;
++++int+end_idx+=+static_cast<int>(pointcloud_ptr->size()+/+thread_num)+*+(thread_id+%2B+1);
++++if+(thread_id+==+thread_num+-+1)
++++{
++++++end_idx+=+pointcloud_ptr->size();
++++}

++++octomap::KeySet+local_free_cells;
++++octomap::KeySet+local_occupied_cells;

++++for+(auto+i+=+start_idx;+i+<+end_idx;+i%2B%2B)
++++{
++++++octomap::point3d+point((*pointcloud_ptr)[i].x,+(*pointcloud_ptr)[i].y,+(*pointcloud_ptr)[i].z);
++++++octomap::KeyRay+key_ray;
++++++if+(octomap_octree->computeRayKeys(sensor_origin_3d,+point,+key_ray))
++++++{
++++++++local_free_cells.insert(key_ray.begin(),+key_ray.end());
++++++}

++++++octomap::OcTreeKey+tree_key;
++++++if+(octomap_octree->coordToKeyChecked(point,+tree_key))
++++++{
++++++++local_occupied_cells.insert(tree_key);
++++++}
++++}

#if+defined(_OPENMP)
#pragma+omp+critical
#endif
++++{
++++++free_cells.insert(local_free_cells.begin(),+local_free_cells.end());
++++++occupied_cells.insert(local_occupied_cells.begin(),+local_occupied_cells.end());
++++}
++}

++//+free+cells+only+if+not+occupied+in+this+cloud
++for+(auto+it+=+free_cells.begin();+it+!=+free_cells.end();+%2B%2Bit)
++{
++++if+(occupied_cells.find(*it)+==+occupied_cells.end())
++++{
++++++octomap_octree->updateNode(*it,+false);
++++}
++}

++//+occupied+cells
++for+(auto+it+=+occupied_cells.begin();+it+!=+occupied_cells.end();+%2B%2Bit)
++{
++++octomap_octree->updateNode(*it,+true);
++}

++auto+fcl_octree+=+std::make_shared<fcl::OcTree>(octomap_octree);
++std::shared_ptr<fcl::CollisionGeometry>+fcl_geometry+=+fcl_octree;
++return+std::make_shared<fcl::CollisionObject>(fcl_geometry);
}|code-block|syntax|javascript|2186342|正如@fferri在评论中所说，您还可以使用pcl中的三角剖分函数从点云创建网格。但是，您应该知道GJK/EPA算法不能支持凹对象。因此，正确地说，在使用CGAL进行碰撞检测之前，您可能需要通过凸分解(例如可以使用fcl+)处理网格。|2186343|2.运动障碍物与静止点云之间的连续碰撞检测。|2186344|不幸的是，目前在fcl中实现的CCD接口没有完全支持八叉树/点云(甚至是天真的CCD解决程序)。但您可以通过下列任何一种方法来解决这个问题：|2186345|对移动障碍物的轨迹进行采样，采用离散碰撞检测(+DCD+)方法进行碰撞检测。如果障碍物的运动只是平移，很容易证明我们可以产生足够数量的样本，以确保它与使用CCD是等价的。但是，如果运动包含方向，则使用sampling%2BDCD方法的无碰撞情况实际上可能处于冲突状态。|unordered-list-item|2186346|构造移动障碍物横扫体的凸包。使用DCD确保凸包和静态点云是无碰撞的。关于如何构造运动几何的凸包，您可以看一看trajopt纸中的第五章。|2186347|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/30741008/collison-detection-between-two-point-clouds-using-pcl/30741134#comment49538733_30741134|1|https://www.cgal.org/|2|http://joschu.net/docs/trajopt-paper.pdf^0|J|3|0|7|K|0|0|0|M|3|2Z|3|A|2|0|25|4|1|0|0|8|3|0|0|1I|8|2|0^^$0|@$1|2|3|4|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1H|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1I|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@$9|1O|A|1P|1|1Q]|$9|1R|A|1S|1|1T]]|E|$]]|$1|Q|3|R|5|6|7|1U|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1V|8|@$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|U|3|V|5|W|7|1Y|8|@]|D|@]|E|$]]|$1|X|3|Y|5|W|7|1Z|8|@]|D|@$9|20|A|21|1|22]]|E|$]]|$1|Z|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]|17|$5|12|13|14|E|$15|18]]|19|$5|12|13|14|E|$15|1A]]]]

Just to extend @fferri 's answer on how to use <code>fcl</code> (Flexible Collision Library) to check collision for your case.

<h1>1. Create <code>fcl::CollisionObject</code> from the point cloud.</h1>

Here I use octree as the probabilistic representation of the point cloud.

<pre><code>std::shared_ptr&lt;fcl::CollisionObject&gt; createCollisionObject(const pcl::PointCloud&lt;pcl::PointXYZ&gt;::Ptr pointcloud_ptr, const octomap::point3d&amp; sensor_origin_wrt_world)
{
 // octomap octree settings
 const double resolution = 0.01;
 const double prob_hit = 0.9;
 const double prob_miss = 0.1;
 const double clamping_thres_min = 0.12;
 const double clamping_thres_max = 0.98;

 std::shared_ptr&lt;octomap::OcTree&gt; octomap_octree = std::make_shared&lt;octomap::OcTree&gt;(resolution);
 octomap_octree-&gt;setProbHit(prob_hit);
 octomap_octree-&gt;setProbMiss(prob_miss);
 octomap_octree-&gt;setClampingThresMin(clamping_thres_min);
 octomap_octree-&gt;setClampingThresMax(clamping_thres_max);

 octomap::KeySet free_cells;
 octomap::KeySet occupied_cells;

#if defined(_OPENMP)
#pragma omp parallel
#endif
 {
#if defined(_OPENMP)
 auto thread_id = omp_get_thread_num();
 auto thread_num = omp_get_num_threads();
#else
 int thread_id = 0;
 int thread_num = 1;
#endif
 int start_idx = static_cast&lt;int&gt;(pointcloud_ptr-&gt;size() / thread_num) * thread_id;
 int end_idx = static_cast&lt;int&gt;(pointcloud_ptr-&gt;size() / thread_num) * (thread_id + 1);
 if (thread_id == thread_num - 1)
 {
 end_idx = pointcloud_ptr-&gt;size();
 }

 octomap::KeySet local_free_cells;
 octomap::KeySet local_occupied_cells;

 for (auto i = start_idx; i &lt; end_idx; i++)
 {
 octomap::point3d point((*pointcloud_ptr)[i].x, (*pointcloud_ptr)[i].y, (*pointcloud_ptr)[i].z);
 octomap::KeyRay key_ray;
 if (octomap_octree-&gt;computeRayKeys(sensor_origin_3d, point, key_ray))
 {
 local_free_cells.insert(key_ray.begin(), key_ray.end());
 }

 octomap::OcTreeKey tree_key;
 if (octomap_octree-&gt;coordToKeyChecked(point, tree_key))
 {
 local_occupied_cells.insert(tree_key);
 }
 }

#if defined(_OPENMP)
#pragma omp critical
#endif
 {
 free_cells.insert(local_free_cells.begin(), local_free_cells.end());
 occupied_cells.insert(local_occupied_cells.begin(), local_occupied_cells.end());
 }
 }

 // free cells only if not occupied in this cloud
 for (auto it = free_cells.begin(); it != free_cells.end(); ++it)
 {
 if (occupied_cells.find(*it) == occupied_cells.end())
 {
 octomap_octree-&gt;updateNode(*it, false);
 }
 }

 // occupied cells
 for (auto it = occupied_cells.begin(); it != occupied_cells.end(); ++it)
 {
 octomap_octree-&gt;updateNode(*it, true);
 }

 auto fcl_octree = std::make_shared&lt;fcl::OcTree&gt;(octomap_octree);
 std::shared_ptr&lt;fcl::CollisionGeometry&gt; fcl_geometry = fcl_octree;
 return std::make_shared&lt;fcl::CollisionObject&gt;(fcl_geometry);
}
</code></pre>

As @fferri said in <a href="https://stackoverflow.com/questions/30741008/collison-detection-between-two-point-clouds-using-pcl/30741134#comment49538733_30741134">the comment</a>, You can also use the triangulation functions in <code>pcl</code> to create mesh from point cloud. However, you should know that the GJK/EPA algorithm cannot support concave objects. So properly you might need to process the mesh by convex decomposition (e.g. You can use <a href="https://www.cgal.org/" rel="nofollow noreferrer">CGAL</a>) before you use <code>fcl</code> for collision detection.

<h1>2. About the CCD (continuous collision detection) between the moving obstacle and the static point cloud.</h1>

Unfortunately, the current implementation of CCD interfaces in <code>fcl</code> doesn't have full support for octree/pointcloud (even the naive CCD solver). But you can work around the problem by either of the following ways:

<ul>
<li>sample the trajectory of the moving obstacle and use DCD (discrete collision detection) to check collision. If the motion of obstacle is just translation, it's easy to show that we can generate adequate numbers of samples to make sure it's equivalent to use CCD. However, if the motion contains orientation, the collision free cases using the sampling+DCD method might be actually in collision.</li>
<li>construct the convex hull of the swept volume of the moving obstacle. Use DCD to make sure the convex hull and the static point cloud is collision free. For how to construct the convex hull for a moving geometry, you can have a look at the Chapter V. in <a href="http://joschu.net/docs/trajopt-paper.pdf" rel="nofollow noreferrer">the trajopt paper</a>.</li>
</ul>

Given two point clouds such that one point cloud is static whereas other is mobile obstacle. We want to move the mobile point cloud obstacle in space and note down whether it is intersecting with the static point cloud at that position. Is there a function available in PCL to do this automatically or do we have to write our own function to do the same?

Collison Detection between two point clouds using PCL

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

给定两点云，其中一点云是静态的，而另一点云是移动障碍。我们要移动空间中的移动点云障碍物，并记下它是否与静止点云在那个位置相交。在PCL中是否有可用的函数来自动完成此操作，还是我们必须编写自己的函数才能做到这一点？

问用PCL检测两点云间的Collison
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用PCL检测两点云间的CollisonEN