openMP---第一篇
openMP 处理for循环
//////////////////////////////////////////////////////////////////////////////////////////////
template <typename PointInT, typename PointOutT> void
pcl::MovingLeastSquares<PointInT, PointOutT>::performProcessing (PointCloudOut &output)
{
// Compute the number of coefficients
nr_coeff_ = (order_ + ) * (order_ + ) / ; size_t mls_result_index = ; #ifdef _OPENMP
// (Maximum) number of threads
const unsigned int threads = threads_ == ? : threads_;
// Create temporaries for each thread in order to avoid synchronization
typename PointCloudOut::CloudVectorType projected_points (threads);
typename NormalCloud::CloudVectorType projected_points_normals (threads);
std::vector<PointIndices> corresponding_input_indices (threads);
#endif // For all points
#ifdef _OPENMP
#pragma omp parallel for schedule (dynamic,1000) num_threads (threads)
#endif
for (int cp = ; cp < static_cast<int> (indices_->size ()); ++cp)
{
// Allocate enough space to hold the results of nearest neighbor searches
// \note resize is irrelevant for a radiusSearch ().
std::vector<int> nn_indices;
std::vector<float> nn_sqr_dists; // Get the initial estimates of point positions and their neighborhoods
if (searchForNeighbors ((*indices_)[cp], nn_indices, nn_sqr_dists))
{
// Check the number of nearest neighbors for normal estimation (and later for polynomial fit as well)
if (nn_indices.size () >= )
{
// This thread's ID (range 0 to threads-1)
#ifdef _OPENMP
const int tn = omp_get_thread_num ();
// Size of projected points before computeMLSPointNormal () adds points
size_t pp_size = projected_points[tn].size ();
#else
PointCloudOut projected_points;
NormalCloud projected_points_normals;
#endif // Get a plane approximating the local surface's tangent and project point onto it
const int index = (*indices_)[cp]; if (cache_mls_results_)
mls_result_index = index; // otherwise we give it a dummy location. #ifdef _OPENMP
computeMLSPointNormal (index, nn_indices, projected_points[tn], projected_points_normals[tn], corresponding_input_indices[tn], mls_results_[mls_result_index]); // Copy all information from the input cloud to the output points (not doing any interpolation)
for (size_t pp = pp_size; pp < projected_points[tn].size (); ++pp)
copyMissingFields (input_->points[(*indices_)[cp]], projected_points[tn][pp]);
#else
computeMLSPointNormal (index, nn_indices, projected_points, projected_points_normals, *corresponding_input_indices_, mls_results_[mls_result_index]); // Append projected points to output
output.insert (output.end (), projected_points.begin (), projected_points.end ());
if (compute_normals_)
normals_->insert (normals_->end (), projected_points_normals.begin (), projected_points_normals.end ());
#endif
}
}
} #ifdef _OPENMP
// Combine all threads' results into the output vectors
for (unsigned int tn = ; tn < threads; ++tn)
{
output.insert (output.end (), projected_points[tn].begin (), projected_points[tn].end ());
corresponding_input_indices_->indices.insert (corresponding_input_indices_->indices.end (),
corresponding_input_indices[tn].indices.begin (), corresponding_input_indices[tn].indices.end ());
if (compute_normals_)
normals_->insert (normals_->end (), projected_points_normals[tn].begin (), projected_points_normals[tn].end ());
}
#endif // Perform the distinct-cloud or voxel-grid upsampling
performUpsampling (output);
}
template <typename PointT> void
pcl::FastBilateralFilterOMP<PointT>::applyFilter (PointCloud &output)
{
if (!input_->isOrganized ())
{
PCL_ERROR ("[pcl::FastBilateralFilterOMP] Input cloud needs to be organized.\n");
return;
} copyPointCloud (*input_, output);
float base_max = -std::numeric_limits<float>::max (),
base_min = std::numeric_limits<float>::max ();
bool found_finite = false;
for (size_t x = ; x < output.width; ++x)
{
for (size_t y = ; y < output.height; ++y)
{
if (pcl_isfinite (output (x, y).z))
{
if (base_max < output (x, y).z)
base_max = output (x, y).z;
if (base_min > output (x, y).z)
base_min = output (x, y).z;
found_finite = true;
}
}
}
if (!found_finite)
{
PCL_WARN ("[pcl::FastBilateralFilterOMP] Given an empty cloud. Doing nothing.\n");
return;
}
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for (long int i = ; i < static_cast<long int> (output.size ()); ++i)
if (!pcl_isfinite (output.at(i).z))
output.at(i).z = base_max; const float base_delta = base_max - base_min; const size_t padding_xy = ;
const size_t padding_z = ; const size_t small_width = static_cast<size_t> (static_cast<float> (input_->width - ) / sigma_s_) + + * padding_xy;
const size_t small_height = static_cast<size_t> (static_cast<float> (input_->height - ) / sigma_s_) + + * padding_xy;
const size_t small_depth = static_cast<size_t> (base_delta / sigma_r_) + + * padding_z; Array3D data (small_width, small_height, small_depth);
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for (long int i = ; i < static_cast<long int> (small_width * small_height); ++i)
{
size_t small_x = static_cast<size_t> (i % small_width);
size_t small_y = static_cast<size_t> (i / small_width);
size_t start_x = static_cast<size_t>(
std::max ((static_cast<float> (small_x) - static_cast<float> (padding_xy) - 0.5f) * sigma_s_ + , .f));
size_t end_x = static_cast<size_t>(
std::max ((static_cast<float> (small_x) - static_cast<float> (padding_xy) + 0.5f) * sigma_s_ + , .f));
size_t start_y = static_cast<size_t>(
std::max ((static_cast<float> (small_y) - static_cast<float> (padding_xy) - 0.5f) * sigma_s_ + , .f));
size_t end_y = static_cast<size_t>(
std::max ((static_cast<float> (small_y) - static_cast<float> (padding_xy) + 0.5f) * sigma_s_ + , .f));
for (size_t x = start_x; x < end_x && x < input_->width; ++x)
{
for (size_t y = start_y; y < end_y && y < input_->height; ++y)
{
const float z = output (x,y).z - base_min;
const size_t small_z = static_cast<size_t> (static_cast<float> (z) / sigma_r_ + 0.5f) + padding_z;
Eigen::Vector2f& d = data (small_x, small_y, small_z);
d[] += output (x,y).z;
d[] += 1.0f;
}
}
} std::vector<long int> offset ();
offset[] = &(data (,,)) - &(data (,,));
offset[] = &(data (,,)) - &(data (,,));
offset[] = &(data (,,)) - &(data (,,)); Array3D buffer (small_width, small_height, small_depth); for (size_t dim = ; dim < ; ++dim)
{
for (size_t n_iter = ; n_iter < ; ++n_iter)
{
Array3D* current_buffer = (n_iter % == ? &buffer : &data);
Array3D* current_data =(n_iter % == ? &data : &buffer);
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for(long int i = ; i < static_cast<long int> ((small_width - )*(small_height - )); ++i)
{
size_t x = static_cast<size_t> (i % (small_width - ) + );
size_t y = static_cast<size_t> (i / (small_width - ) + );
const long int off = offset[dim];
Eigen::Vector2f* d_ptr = &(current_data->operator() (x,y,));
Eigen::Vector2f* b_ptr = &(current_buffer->operator() (x,y,)); for(size_t z = ; z < small_depth - ; ++z, ++d_ptr, ++b_ptr)
*d_ptr = (*(b_ptr - off) + *(b_ptr + off) + 2.0 * (*b_ptr)) / 4.0;
}
}
}
// Note: this works because there are an even number of iterations.
// If there were an odd number, we would need to end with a:
// std::swap (data, buffer); if (early_division_)
{
for (std::vector<Eigen::Vector2f, Eigen::aligned_allocator<Eigen::Vector2f> >::iterator d = data.begin (); d != data.end (); ++d)
*d /= ((*d)[] != ) ? (*d)[] : ; #ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for (long int i = ; i < static_cast<long int> (input_->size ()); ++i)
{
size_t x = static_cast<size_t> (i % input_->width);
size_t y = static_cast<size_t> (i / input_->width);
const float z = output (x,y).z - base_min;
const Eigen::Vector2f D = data.trilinear_interpolation (static_cast<float> (x) / sigma_s_ + padding_xy,
static_cast<float> (y) / sigma_s_ + padding_xy,
z / sigma_r_ + padding_z);
output(x,y).z = D[];
}
}
else
{
#ifdef _OPENMP
#pragma omp parallel for num_threads (threads_)
#endif
for (long i = ; i < static_cast<long int> (input_->size ()); ++i)
{
size_t x = static_cast<size_t> (i % input_->width);
size_t y = static_cast<size_t> (i / input_->width);
const float z = output (x,y).z - base_min;
const Eigen::Vector2f D = data.trilinear_interpolation (static_cast<float> (x) / sigma_s_ + padding_xy,
static_cast<float> (y) / sigma_s_ + padding_xy,
z / sigma_r_ + padding_z);
output (x,y).z = D[] / D[];
}
}
}
template <typename PointInT, typename PointOutT> void
pcl::NormalEstimationOMP<PointInT, PointOutT>::computeFeature (PointCloudOut &output)
{
// Allocate enough space to hold the results
// \note This resize is irrelevant for a radiusSearch ().
std::vector<int> nn_indices (k_);
std::vector<float> nn_dists (k_); output.is_dense = true;
// Save a few cycles by not checking every point for NaN/Inf values if the cloud is set to dense
if (input_->is_dense)
{
#ifdef _OPENMP
#pragma omp parallel for shared (output) private (nn_indices, nn_dists) num_threads(threads_)
#endif
// Iterating over the entire index vector
for (int idx = ; idx < static_cast<int> (indices_->size ()); ++idx)
{
Eigen::Vector4f n;
if (this->searchForNeighbors ((*indices_)[idx], search_parameter_, nn_indices, nn_dists) == ||
!computePointNormal (*surface_, nn_indices, n, output.points[idx].curvature))
{
output.points[idx].normal[] = output.points[idx].normal[] = output.points[idx].normal[] = output.points[idx].curvature = std::numeric_limits<float>::quiet_NaN (); output.is_dense = false;
continue;
} output.points[idx].normal_x = n[];
output.points[idx].normal_y = n[];
output.points[idx].normal_z = n[]; flipNormalTowardsViewpoint (input_->points[(*indices_)[idx]], vpx_, vpy_, vpz_,
output.points[idx].normal[], output.points[idx].normal[], output.points[idx].normal[]); }
}
else
{
#ifdef _OPENMP
#pragma omp parallel for shared (output) private (nn_indices, nn_dists) num_threads(threads_)
#endif
// Iterating over the entire index vector
for (int idx = ; idx < static_cast<int> (indices_->size ()); ++idx)
{
Eigen::Vector4f n;
if (!isFinite ((*input_)[(*indices_)[idx]]) ||
this->searchForNeighbors ((*indices_)[idx], search_parameter_, nn_indices, nn_dists) == ||
!computePointNormal (*surface_, nn_indices, n, output.points[idx].curvature))
{
output.points[idx].normal[] = output.points[idx].normal[] = output.points[idx].normal[] = output.points[idx].curvature = std::numeric_limits<float>::quiet_NaN (); output.is_dense = false;
continue;
} output.points[idx].normal_x = n[];
output.points[idx].normal_y = n[];
output.points[idx].normal_z = n[]; flipNormalTowardsViewpoint (input_->points[(*indices_)[idx]], vpx_, vpy_, vpz_,
output.points[idx].normal[], output.points[idx].normal[], output.points[idx].normal[]); }
}
}
openMP---第一篇的更多相关文章
- 从0开始搭建SQL Server AlwaysOn 第一篇(配置域控)
从0开始搭建SQL Server AlwaysOn 第一篇(配置域控) 第一篇http://www.cnblogs.com/lyhabc/p/4678330.html第二篇http://www.cnb ...
- Python爬虫小白入门(四)PhatomJS+Selenium第一篇
一.前言 在上一篇博文中,我们的爬虫面临着一个问题,在爬取Unsplash网站的时候,由于网站是下拉刷新,并没有分页.所以不能够通过页码获取页面的url来分别发送网络请求.我也尝试了其他方式,比如下拉 ...
- Three.js 第一篇:绘制一个静态的3D球体
第一篇就画一个球体吧 首先我们知道Three.js其实是一个3D的JS引擎,其中的强大之处就在于这个JS框架并不是依托于JQUERY来写的.那么,我们在写这一篇绘制3D球体的文章的时候,应该注意哪些地 ...
- 深入学习jQuery选择器系列第一篇——基础选择器和层级选择器
× 目录 [1]id选择器 [2]元素选择器 [3]类选择器[4]通配选择器[5]群组选择器[6]后代选择器[7]兄弟选择器 前面的话 选择器是jQuery的根基,在jQuery中,对事件处理.遍历D ...
- 【第一篇】ASP.NET MVC快速入门之数据库操作(MVC5+EF6)
目录 [第一篇]ASP.NET MVC快速入门之数据库操作(MVC5+EF6) [第二篇]ASP.NET MVC快速入门之数据注解(MVC5+EF6) [第三篇]ASP.NET MVC快速入门之安全策 ...
- Android基础学习第一篇—Project目录结构
写在前面的话: 1. 最近在自学Android,也是边看书边写一些Demo,由于知识点越来越多,脑子越来越记不清楚,所以打算写成读书笔记,供以后查看,也算是把自己学到所理解的东西写出来,献丑,如有不对 ...
- 深入理解ajax系列第一篇——XHR对象
× 目录 [1]创建对象 [2]发送请求 [3]接收响应[4]异步处理[5]实例演示 前面的话 ajax是asynchronous javascript and XML的简写,中文翻译是异步的java ...
- 深入理解javascript对象系列第一篇——初识对象
× 目录 [1]定义 [2]创建 [3]组成[4]引用[5]方法 前面的话 javascript中的难点是函数.对象和继承,前面已经介绍过函数系列.从本系列开始介绍对象部分,本文是该系列的第一篇——初 ...
- 深入理解this机制系列第一篇——this的4种绑定规则
× 目录 [1]默认绑定 [2]隐式绑定 [3]隐式丢失[4]显式绑定[5]new绑定[6]严格模式 前面的话 如果要问javascript中哪两个知识点容易混淆,作用域查询和this机制绝对名列前茅 ...
- 前端工程师技能之photoshop巧用系列第一篇——准备篇
× 目录 [1]作用 [2]初始化 [3]常用工具[4]快捷键 前面的话 photoshop是前端工程师无法回避的一个软件,这个软件本身很强大,但我们仅仅需要通过这个工具来完成基本的切图工作即可.本文 ...
随机推荐
- spring framework体系结构及模块jar依赖关系
本文对于Spring的JAR包使用和配置,结合网友材料以spring 4.3.6.RELEASE版本为例,介绍spring框架结构和各模块对应JAR包以及模块间JAR依赖关系. 注:不同版本JAR包依 ...
- Java反射【二、Class类的使用】
类本身也是对象,是java.lang.Class类的实例对象--There is a class named Class. Class类表示方式 Class类只有Java虚拟机才能初始化,有三种表示方 ...
- 第十章、time模块
目录 第十章.模块 第十章.模块 time模块 import time 时间戳 表示:是从1970年1月1日00:00:00开始按秒计算的偏移量. time_stamp = time.time() p ...
- Eclipse配置Maven的本地仓库和阿里云镜像 加速Maven更新
先确定自己电脑是否安装了Maven和安装位置,具体查询方法直接win+R键打开运行窗口,输入cmd打开dos窗口,再输入mvn -v即可查询安装的位置 拿到安装位置 D:\Applications\W ...
- NORDIC 出现NRF_ERROR_NO_MEM错误
Which SDK version are you using, is it SDK v12.x.x? Which function returns NRF_ERROR_NO_MEM? Is it s ...
- 在Linux中,当需要从磁盘读取块时,进程状态会发生什么变化?被封锁了吗?如果是这样,如何选择另一个流程来执行?
当某个进程需要从磁盘中获取数据时,它实际上会停止在CPU上运行以让其他进程运行,因为该操作可能需要很长时间才能完成-至少需要5ms的磁盘寻道时间,而5ms就是1000万从程序的角度来看,CPU周期是永 ...
- C++第三次作业:作用域
作用域的定义 作用域是一个标识符在程序正文中有效的区域. 1.函数原型作用域 在函数原型声明时形式参数的作用范围就是函数原型作用域. 它是C++程序中最小的作用域. 例: double area(do ...
- 下载好的vue项目如何在自己电脑环境上运行,步骤!!
本文链接:https://blog.csdn.net/qq_39309900/article/details/84837659首先第一步,需要安装node.js 下载地址:https://nodejs ...
- Java io 理解
任何程序都有io部分,io是对程序来说数据流的输入和输出.这里说的流,是指有字节组成的列,不断输入程序,或者从程序中输出,我们形象称为流.Java的io流有两种,一种叫字节流,最原始的:一种叫字符流. ...
- Web Api(1)
由于在学习Web Api没有了解过MVC,觉得有些吃力.很多基础的东西都会一并记录下来. Web API 的意思是使用HTTP协议并通过网络调用的API. API的意思软件外部接口. 在实际的开发中, ...