VTK+CGAL+QT+VS(3D纹理显示)

最近做了一个使用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;
}
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Long-Giraffe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值