最近做了一个使用VTK+CGAL+QT+VS将线扫相机采集的深度图和亮度图进行3D纹理显示的功能。先挖坑后续来填(想看的评论点赞,我会尽快更新)。
CGAL主要用于计算Delaunay2D的三角面片信息,相比VTK自带的方法快很多。
最终显示效果类似上图,高度通过伪彩显示,同时包含亮度图信息。
#include "vtkAutoInit.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
#include <pcl/point_types.h>
#include <pcl/point_cloud.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/io/pcd_io.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Projection_traits_xy_3.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Triangulation_vertex_base_with_info_2.h>
#include <vector>
#include <chrono>
#include <CGAL/lloyd_optimize_mesh_2.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkLookupTable.h>
#include <vtkScalarBarActor.h>
#include <vtkPlaneSource.h>
#include <vtkCubeAxesActor.h>
// PCL类型
typedef pcl::PointXYZ PCLPoint;
typedef pcl::PointCloud<PCLPoint> PCLCloud;
// CGAL类型
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Projection_traits_xy_3<K> Gt;
typedef CGAL::Triangulation_vertex_base_with_info_2<size_t, Gt> Vb;
typedef CGAL::Triangulation_data_structure_2<Vb> Tds;
typedef CGAL::Delaunay_triangulation_2<Gt, Tds> Delaunay;
typedef K::Point_3 CGALPoint;
// 1. 创建Z值标量数组
vtkSmartPointer<vtkFloatArray> CreateZScalars(vtkPolyData* mesh) {
vtkSmartPointer<vtkFloatArray> scalars = vtkSmartPointer<vtkFloatArray>::New();
scalars->SetName("Z_Value");
vtkPoints* points = mesh->GetPoints();
for (vtkIdType i = 0; i < points->GetNumberOfPoints(); i++) {
double p[3];
points->GetPoint(i, p);
scalars->InsertNextValue(p[2]);
}
return scalars;
}
// 2. 创建颜色映射表
vtkSmartPointer<vtkLookupTable> CreateColorMap(double zMin, double zMax) {
vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
lut->SetTableRange(zMin, zMax);
lut->SetHueRange(0.667, 0.0); // 蓝→红渐变
lut->Build();
return lut;
}
void AddPlaneWithSpheres(vtkRenderer* renderer, double start[2], double end[2],int rang) {
// 1. 定义平面四个顶点(Z坐标分别为-5和5)
double planePoints[4][3] = {
{start[0], start[1], rang},
{start[0], start[1], -rang},
{end[0], end[1], - rang},
{end[0], end[1], rang}
};
// 2. 创建平面(使用三个点定义四边形)
vtkNew<vtkPlaneSource> plane;
plane->SetOrigin(planePoints[0]); // 左下
plane->SetPoint1(planePoints[1]); // 右下
plane->SetPoint2(planePoints[3]); // 左上
plane->Update();
// 3. 设置平面可视化属性
vtkNew<vtkPolyDataMapper> planeMapper;
planeMapper->SetInputConnection(plane->GetOutputPort());
vtkNew<vtkActor> planeActor;
planeActor->SetMapper(planeMapper);
planeActor->GetProperty()->SetColor(0.53, 0.81, 0.98); // 淡蓝色
planeActor->GetProperty()->SetOpacity(0.8); // 半透明
planeActor->GetProperty()->EdgeVisibilityOn(); // 显示边线
planeActor->GetProperty()->SetEdgeColor(0, 0, 0); // 黑色边线
// 4. 创建四个角点球体
vtkNew<vtkAppendPolyData> spheres;
for (int i = 0; i < 4; ++i) {
vtkNew<vtkSphereSource> sphere;
sphere->SetCenter(planePoints[i]);
sphere->SetRadius(0.3); // 球体半径
sphere->SetPhiResolution(20);
sphere->SetThetaResolution(20);
spheres->AddInputConnection(sphere->GetOutputPort());
}
// 5. 设置球体可视化属性
vtkNew<vtkPolyDataMapper> sphereMapper;
sphereMapper->SetInputConnection(spheres->GetOutputPort());
vtkNew<vtkActor> sphereActor;
sphereActor->SetMapper(sphereMapper);
sphereActor->GetProperty()->SetColor(0, 0, 1); // 红色球体
// 6. 添加到渲染器
renderer->AddActor(planeActor);
renderer->AddActor(sphereActor);
}
// 4. 主显示函数
void showVtkPolyData(vtkSmartPointer<vtkPolyData> mesh) {
// 初始化标量和颜色表
auto scalars = CreateZScalars(mesh);
mesh->GetPointData()->SetScalars(scalars);
double bounds[6];
mesh->GetBounds(bounds);
auto lut = CreateColorMap(bounds[4], bounds[5]);
// 创建渲染管线
vtkNew<vtkRenderer> renderer;
vtkNew<vtkRenderWindow> renderWindow;
renderWindow->AddRenderer(renderer);
// 添加主网格
vtkNew<vtkPolyDataMapper> mapper;
mapper->SetInputData(mesh);
mapper->SetLookupTable(lut);
mapper->SetScalarRange(bounds[4], bounds[5]);
vtkNew<vtkActor> actor;
actor->SetMapper(mapper);
renderer->AddActor(actor);
// 创建包围盒Actor(假设已存在boxActor)
vtkNew<vtkCubeAxesActor> cubeAxes;
cubeAxes->SetBounds(actor->GetBounds()); // 绑定包围盒范围
cubeAxes->SetCamera(renderer->GetActiveCamera()); // 关联相机
// 设置刻度样式
cubeAxes->SetXTitle("X (m)"); // X轴标签
cubeAxes->SetYTitle("Y (m)"); // Y轴标签
cubeAxes->SetZTitle("Z (m)"); // Z轴标签
cubeAxes->SetXAxisTickVisibility(4); // 显示X轴刻度
cubeAxes->SetYAxisTickVisibility(4); // 显示Y轴刻度
cubeAxes->SetZAxisTickVisibility(4); // 显示Z轴刻度
// 设置每个轴的主刻度数量(数值越大越稀疏)
// 禁用次要刻度显示
cubeAxes->XAxisMinorTickVisibilityOff();
cubeAxes->YAxisMinorTickVisibilityOff();
cubeAxes->ZAxisMinorTickVisibilityOff();
//cubeAxes->SetDrawXGridlines(1); // 显示X轴网格
//cubeAxes->SetDrawYGridlines(1); // 显示Y轴网格
//cubeAxes->SetDrawZGridlines(1); // 显示Z轴网格
// 添加到渲染器
renderer->AddActor(cubeAxes);
// 添加平面和球体(示例坐标)
double lineStart[3] = { 0, 0 };
double lineEnd[3] = { 10, 10};
AddPlaneWithSpheres(renderer, lineStart, lineEnd,5);
// 启动交互
vtkNew<vtkRenderWindowInteractor> interactor;
interactor->SetRenderWindow(renderWindow);
renderWindow->SetSize(800, 600);
renderWindow->Render();
interactor->Start();
}
// 转换PCL点云到CGAL格式
void convertToCGAL(const PCLCloud::Ptr pcl_cloud,
std::vector<std::pair<CGALPoint, size_t>>& cgal_points) {
cgal_points.reserve(pcl_cloud->size());
for (size_t i = 0; i < pcl_cloud->size(); ++i) {
const auto& pt = pcl_cloud->points[i];
cgal_points.emplace_back(CGALPoint(pt.x, pt.y, pt.z), i);
}
}
// 线程函数:处理带重叠区域的数据块
void processChunk(
const std::vector<std::pair<CGALPoint, size_t>>& cgal_points,
Delaunay& dt,
int start_idx,
int end_idx,
int overlap)
{
// 扩展范围以包含重叠区域
int chunk_start = std::max(0, start_idx);
int chunk_end = std::min((int)cgal_points.size(), end_idx + overlap);
// 插入点集
dt.insert(cgal_points.begin() + chunk_start, cgal_points.begin() + chunk_end);
}
// Delaunay 三角剖分(多线程 + 重叠区域)
void cgalTriangulateWithOverlap(
const std::vector<std::pair<CGALPoint, size_t>>& cgal_points,
vtkSmartPointer<vtkCellArray >& triangles, int max_length =5,
int thread_num = 8,
int overlap_size = 300) // 重叠区域大小(根据点密度调整)
{
std::vector<Delaunay> delaunays(thread_num);
std::vector<std::thread> threads;
int total_points = cgal_points.size();
int sideLength = std::sqrt(total_points);
int chunk_size = sideLength / thread_num * sideLength;
overlap_size = sideLength * 2;
// 启动线程处理带重叠的数据块
for (int i = 0; i < thread_num; i++) {
int start_idx = i * chunk_size;
int end_idx = (i == thread_num - 1) ? total_points : start_idx + chunk_size;
threads.emplace_back(
processChunk,
std::ref(cgal_points),
std::ref(delaunays[i]),
start_idx,
end_idx,
overlap_size
);
}
// 等待线程完成
for (auto& t : threads) t.join();
// 合并结果
//triangles->SetNumberOfCells(100000);
for (auto& dt : delaunays) {
for (auto face = dt.finite_faces_begin(); face != dt.finite_faces_end(); ++face) {
CGALPoint p0 = face->vertex(0)->point();
CGALPoint p1 = face->vertex(1)->point();
CGALPoint p2 = face->vertex(2)->point();
// 计算边长(示例)
double edge1 = CGAL::sqrt(CGAL::squared_distance(p0, p1));
double edge2 = CGAL::sqrt(CGAL::squared_distance(p1, p2));
double edge3 = CGAL::sqrt(CGAL::squared_distance(p2, p0));
// 过滤条件判断
if (edge1 > max_length || edge2 > max_length || edge3 > max_length)
continue;
vtkIdType ids[3] = {
static_cast<vtkIdType>((int)face->vertex(0)->info()),
static_cast<vtkIdType>((int)face->vertex(1)->info()),
static_cast<vtkIdType>((int)face->vertex(2)->info())
};
auto point = face->vertex(0)->point();
triangles->InsertNextCell(3, ids);
}
}
}
int main(int argc, char** argv) {
// 1. 加载PCL点云
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPoints> vtk_points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> vtk_cells = vtkSmartPointer<vtkCellArray>::New();
PCLCloud::Ptr cloud(new PCLCloud);
vtk_points->SetDataTypeToFloat();
int size = 1000;
vtk_points->SetNumberOfPoints(size* size);
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
PCLPoint tem;
tem.x = i;
tem.y = j;
tem.z = sin(i * 0.1) * cos(j * 0.1) * 5; // 添加波动效果
cloud->points.emplace_back(tem);
vtk_points->InsertPoint(i* size +j, tem.x, tem.y, tem.z);
}
}
// 2. 转换为CGAL格式
std::vector<std::pair<CGALPoint, size_t>> cgal_points;
convertToCGAL(cloud, cgal_points);
auto start = std::chrono::high_resolution_clock::now();
cgalTriangulateWithOverlap(cgal_points, vtk_cells);
polyData->SetPoints(vtk_points);
polyData->SetPolys(vtk_cells);
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout<< " 耗时: " << duration.count() << "ms" << std::endl;
// 4. 可视化结果
showVtkPolyData(polyData);
return 0;
}
}