# 代码实现：

## 2、点云体素采样（indices）

grid_simplify_indices

``````#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/grid_simplify_point_set.h>
#include <CGAL/property_map.h>
#include <vector>
#include <fstream>

typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;

int main(int argc, char** argv)
{
std::vector<Point> points;
std::vector<Vector> normals;
std::ifstream stream(argv[1]);

Point p;
Vector v;
while (stream >> p >> v)
{
points.push_back(p);
normals.push_back(v);
}

//点的数量
std::cout << points.size() << std::endl;
std::vector<std::size_t>indices(points.size());//创建索引

for (std::size_t i=0;i<points.size();i++)
{
indices[i] = i;
}
std::vector<std::size_t>::iterator end;//定义迭代器
end = CGAL::grid_simplify_point_set(indices,0.05,CGAL::parameters::point_map(CGAL::make_property_map(points)));
std::size_t k = end - indices.begin();
std::cerr << "Keep" << k <<"points" << std::endl;

{
std::vector<Point>tmp_points(k);
std::vector<Vector> tmp_normals(k);

for (std::size_t i = 0; i < k; i++)
{
tmp_points[i] = points[indices[i]];
tmp_normals[i] = normals[indices[i]];

}
points.swap(tmp_points);
normals.swap(tmp_normals);
}
std::cout << "体素滤波后点的个数" << points.size() << std::endl;

system("pause");
return 0;
}

``````

## 3、输入、输出（可以参考官方文档）

``````#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/property_map.h>
#include <CGAL/IO/write_xyz_points.h>
#include <utility> // defines std::pair
#include <vector>
#include <fstream>
#include <iostream>

# include <CGAL/Point_set_3.h>

// types
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::Point_3 Point;
typedef Kernel::Vector_3 Vector;
typedef CGAL::Point_set_3<Point> Point_set;
typedef std::pair<Point, Vector> Pwn;
int main(int argc, char* argv[])
{

//方法一
const std::string fname = (argc > 1) ? argv[1] : CGAL::data_file_path("test.xyz");
std::vector<Pwn> points;
std::back_inserter(points),
CGAL::parameters::point_map(CGAL::First_of_pair_property_map<Pwn>())
.normal_map(CGAL::Second_of_pair_property_map<Pwn>())))
{
std::cerr << "Error: cannot read file " << fname << std::endl;
return EXIT_FAILURE;
}
if (!CGAL::IO::write_XYZ("test_copy.xyz", points,
CGAL::parameters::point_map(CGAL::First_of_pair_property_map<Pwn>())
.normal_map(CGAL::Second_of_pair_property_map<Pwn>())
.stream_precision(17)))
return EXIT_FAILURE;

//方法二
Point_set cloud;
CGAL::IO::write_XYZ("test_copy",cloud, CGAL::parameters::stream_precision(17));

return EXIT_SUCCESS;

}
``````

## 4 、点云平均距离求解

``````#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/compute_average_spacing.h>
#include <CGAL/IO/write_points.h>
#include <vector>
#include <fstream>
#include <boost/tuple/tuple.hpp>
// Types
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point;
// Data type := index, followed by the point, followed by three integers that
// define the Red Green Blue color of the point.
typedef boost::tuple<int, Point, int, int, int> IndexedPointWithColorTuple;
typedef CGAL::Parallel_if_available_tag Concurrency_tag;

int main(int argc, char* argv[])
{
const std::string fname = (argc > 1) ? argv[1] : CGAL::data_file_path("test.xyz");

std::vector<IndexedPointWithColorTuple> points;
CGAL::parameters::point_map(CGAL::Nth_of_tuple_property_map<1, IndexedPointWithColorTuple>())))
{
std::cerr << "Error: cannot read file " << fname << std::endl;
return EXIT_FAILURE;
}

for (unsigned int i = 0; i < points.size(); i++)
{
points[i].get<0>() = i; // set index value of tuple to i
points[i].get<2>() = 0; // set RGB color to black
points[i].get<3>() = 0;
points[i].get<4>() = 0;
}
//都可以保存
CGAL::IO::write_XYZ("copy_xyz.xyz", points, CGAL::parameters::point_map(CGAL::Nth_of_tuple_property_map<1, IndexedPointWithColorTuple>()));
//CGAL::IO::write_OFF("copy_off.off",points, CGAL::parameters::point_map(CGAL::Nth_of_tuple_property_map<1, IndexedPointWithColorTuple>()));
// CGAL::IO::write_points("copy.xyz", points, CGAL::parameters::point_map(CGAL::Nth_of_tuple_property_map<1, IndexedPointWithColorTuple>()));

//计算平均距离
const unsigned int nb_neighbors = 6; // 1 ring
FT average_spacing = CGAL::compute_average_spacing<Concurrency_tag>(
points, nb_neighbors,
CGAL::parameters::point_map(CGAL::Nth_of_tuple_property_map<1, IndexedPointWithColorTuple>()));
std::cout << "Average spacing: " << average_spacing << std::endl;
return EXIT_SUCCESS;
}

``````

//上述代码太繁琐，可以直接简化，如下

``````    Point_set cloud;
CGAL::IO::write_XYZ("copy_xyz.xyz", cloud);
//计算平均距离
const unsigned int nb_neighbors = 6; // 1 ring
FT average_spacing = CGAL::compute_average_spacing<Concurrency_tag>(cloud, nb_neighbors, CGAL::parameters::point_map(cloud.point_map()));
std::cout << "Average spacing: " << average_spacing << std::endl;
return EXIT_SUCCESS;
``````

## 5.1 估计全局k邻域与R邻域

``````#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/IO/write_points.h>
#include <CGAL/estimate_scale.h>
#include <CGAL/jet_smooth_point_set.h>
#include <CGAL/grid_simplify_point_set.h>
#include <CGAL/Timer.h>
#include <CGAL/Memory_sizer.h>
#include <vector>
#include <fstream>
// Concurrency
typedef CGAL::Parallel_if_available_tag Concurrency_tag;
// Types
typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
typedef Kernel::FT FT;
typedef Kernel::Point_3 Point_3;
int main(int argc, char** argv)
{
const std::string fname = (argc > 1) ? argv[1] : CGAL::data_file_path("test.xyz");
std::vector<Point_3> points;
{
std::cerr << "Error: can't read input file" << std::endl;
return EXIT_FAILURE;
}
// estimate k scale
std::size_t k_scale = CGAL::estimate_global_k_neighbor_scale(points);
// Example: use estimated k as scale for jet smoothing
CGAL::jet_smooth_point_set<Concurrency_tag>(points, static_cast<unsigned int>(k_scale));

CGAL::IO::write_points("knn.xyz",points);

// estimate range scale
FT range_scale = CGAL::estimate_global_range_scale(points);
// Example: use estimated range for grid simplification
points.erase(CGAL::grid_simplify_point_set(points, range_scale), points.end());

CGAL::IO::write_points("rnn.xyz", points);
// print some informations on runtime
std::size_t memory = CGAL::Memory_sizer().virtual_size();
std::cout << "Scales computed in " << time << " second(s) using "
<< (memory >> 20) << " MiB of memory:" << std::endl;
std::cout << " * Global K scale: " << k_scale << std::endl;
std::cout << " * Global range scale: " << range_scale << std::endl;
return EXIT_SUCCESS;
}

``````