【VTK】基于VTK的扩展ACVD实现网格重新划分网格Remeshing

已于 2024-07-10 14:38:24 修改
阅读量170 收藏 1
点赞数 4
分类专栏： 图像图形处理付费专栏 文章标签： 算法 计算机视觉 VTK 图像处理
于 2024-07-10 14:37:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40041064/article/details/139415024
版权

很高兴在雪易的CSDN遇见你 

VTK技术爱好者 QQ：870202403      公众号：VTK忠粉

前言

本文分享基于VTK的扩展ACVD实现网格重新划分网格Remeshing，希望对各位小伙伴有所帮助！

感谢各位小伙伴的点赞+关注，小易会继续努力分享，一起进步！

你的点赞就是我的动力(＾Ｕ＾)ノ~ＹＯ

目录

前言

1. 重新划分网格Remeshing的效果

2. 基于VTK实现的ACVD

3. Remeshing源码分享

结论：

1. 重新划分网格Remeshing的效果

在3D图形处理时，通常需要进行网格的重新划分。医学图形处理时通常使用VTK作为图形处理和渲染显示的库。

分享过关于CGAL实现Remeshing的方法，详情见：

【CGAL系列】Remesh—1 Isotropic_remeshing_example_cgal remeshing-CSDN博客

这里，我们分享基于VTK如何进行网格重新划分Remeshing。 

2. 基于VTK实现的ACVD

网站链接：ACVD | Sébastien Valette (insa-lyon.fr)

源码：ACVD

 ACVD库基于VTK进行扩展，为三角形网格提供一种快速高效的网格简化/重采样方法。可以应用于非常复杂的网格（数百万个顶点）。这种方法基于变分框架内的输入网格单元的聚类。这种聚类方法类似于质心的分区Voronoi区域，其中每个区域具有相同的大小，因此表面的采样非常均匀，并且对生成的三角进行测量具有良好的纵横比。

这种方法对于重新划分网格程序也很有用。

基于斯坦福兔子的聚类方法

3. Remeshing源码分享

.h文件

#pragma once
#include <qobject.h>

#include <vtkPolyData.h>

class zxExampleRemeshing :
    public QObject
{

public:
    zxExampleRemeshing(QWidget* parent = nullptr);

    bool ValidateSurface(vtkPolyData* surface);
    vtkPolyData* Remesh(vtkPolyData* surface,
        int numVertices,
        double gradation,
        int subsampling,
        double edgeSplitting,
        int optimizationLevel,
        bool forceManifold,
        bool boundaryFixing);
    void Remeshing();
};

.cpp文件

#include "zxExampleRemeshing.h"

#include "vtkSTLReader.h"
#include "vtkSTLWriter.h"
#include "vtkTriangleFilter.h"
#include "vtkCellData.h"
#include "vtkPointData.h"
#include <vtkIdList.h>
#include <vtkIntArray.h>
#include <vtkPolyDataNormals.h>

#include <array>
#include <vector>

#include "vtkSurface.h"
#include "vtkIsotropicDiscreteRemeshing.h"
#include "vtkIsotropicMetricForClustering.h"
#include "vtkQuadricTools.h"

struct ClustersQuadrics final
{
    explicit ClustersQuadrics(size_t size)
        : Elements(size),
        Size(size)
    {
        for (auto& array : Elements)
            array.fill(0.0);
    }

    ~ClustersQuadrics() = default;

    ClustersQuadrics(const ClustersQuadrics&) = delete;
    ClustersQuadrics& operator=(const ClustersQuadrics&) = delete;

    std::vector<std::array<double, 9>> Elements;
    size_t Size;
};

zxExampleRemeshing::zxExampleRemeshing(QWidget* parent)
{
}

bool zxExampleRemeshing::ValidateSurface(vtkPolyData* surface)
{
    if (nullptr == surface) return false;

    if (surface->GetNumberOfPoints() < 1) return false;

    vtkTriangleFilter* tri = vtkTriangleFilter::New();
    tri->SetInputData(surface);
    tri->Update();

    surface->DeepCopy(tri->GetOutput());

    if (surface->GetNumberOfPolys() < 1) return false;

    return true;
}

vtkPolyData* zxExampleRemeshing::Remesh(vtkPolyData* surface,
    int numVertices,
    double gradation,
    int subsampling,
    double edgeSplitting,
    int optimizationLevel,
    bool forceManifold,
    bool boundaryFixing)
{
    std::cout << "input data: " << surface << std::endl;
    //if (!ValidateSurface(surface)) return nullptr;
    std::cout << "input data validate: " << surface << std::endl;
    std::cout << "Start remeshing...";


    vtkCellArray* VerticesCells = surface->GetVerts();

    vtkSurface* mesh = vtkSurface::New();

    mesh->CreateFromPolyData(surface);
    mesh->GetCellData()->Initialize();
    mesh->GetPointData()->Initialize();
    mesh->DisplayMeshProperties();

    if (numVertices == 0)
    {
        numVertices = surface->GetNumberOfPoints();
    }

    if (edgeSplitting != 0.0)
        mesh->SplitLongEdges(edgeSplitting);

    std::cout << " **************************1111111111111*****************************************" << std::endl;
    vtkIsotropicDiscreteRemeshing* remesher = vtkIsotropicDiscreteRemeshing::New();

    remesher->GetMetric()->SetGradation(gradation);
    remesher->SetBoundaryFixing(boundaryFixing);
    remesher->SetConsoleOutput(1);
    remesher->SetForceManifold(forceManifold);
    remesher->SetInput(mesh);
    remesher->SetNumberOfClusters(numVertices);
    remesher->SetSubsamplingThreshold(subsampling);

    remesher->Remesh();

    std::cout << " **************************222222222222*****************************************" << std::endl;

    // Optimization: Minimize distance between input surface and remeshed surface
    if (optimizationLevel != 0)
    {
        ClustersQuadrics clustersQuadrics(numVertices);

        auto faceList = vtkSmartPointer<vtkIdList>::New();
        vtkSmartPointer<vtkIntArray> clustering = remesher->GetClustering();
        vtkSmartPointer<vtkSurface> remesherInput = remesher->GetInput();
        int clusteringType = remesher->GetClusteringType();
        int numItems = remesher->GetNumberOfItems();
        int numMisclassifiedItems = 0;

        for (int i = 0; i < numItems; ++i)
        {
            int cluster = clustering->GetValue(i);

            if (cluster >= 0 && cluster < numVertices)
            {
                if (clusteringType != 0)
                {
                    remesherInput->GetVertexNeighbourFaces(i, faceList);
                    int numIds = static_cast<int>(faceList->GetNumberOfIds());

                    for (int j = 0; j < numIds; ++j)
                        vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster].data(), remesherInput, faceList->GetId(j), false);
                }
                else
                {
                    vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster].data(), remesherInput, i, false);
                }
            }
            else
            {
                ++numMisclassifiedItems;
            }
        }

        std::cout << " **************************333333333333333*****************************************" << std::endl;

        if (numMisclassifiedItems != 0)
            std::cout << numMisclassifiedItems << " items with wrong cluster association" << std::endl;

        vtkSmartPointer<vtkSurface> remesherOutput = remesher->GetOutput();
        double point[3];

        for (int i = 0; i < numVertices; ++i)
        {
            remesherOutput->GetPoint(i, point);
            vtkQuadricTools::ComputeRepresentativePoint(clustersQuadrics.Elements[i].data(), point, optimizationLevel);
            remesherOutput->SetPointCoordinates(i, point);
        }

        std::cout << "After quadrics post-processing:" << std::endl;
        remesherOutput->DisplayMeshProperties();
    }

    std::cout << " **************************444444444444*****************************************" << std::endl;
    auto normals = vtkSmartPointer<vtkPolyDataNormals>::New();

    normals->SetInputData(remesher->GetOutput());
    normals->AutoOrientNormalsOn();
    normals->ComputeCellNormalsOff();
    normals->ComputePointNormalsOn();
    normals->ConsistencyOff();
    normals->FlipNormalsOff();
    normals->NonManifoldTraversalOff();
    normals->SplittingOff();

    normals->Update();

    auto remeshedSurface = vtkPolyData::New();
    remeshedSurface->DeepCopy(normals->GetOutput());

    std::cout << "Finished remeshing";

    return remeshedSurface;
}


void zxExampleRemeshing::Remeshing()
{
	vtkNew< vtkSTLReader > reader;
	reader->SetFileName("D:\\Data\\Remeshing\\implant.stl");
	reader->Update();

    vtkPolyData* polyData = vtkPolyData::New();
    polyData->DeepCopy(reader->GetOutput());
    std::cout << "Points: " << polyData->GetNumberOfPoints() << std::endl;

	

    /*vtkPolyData* remeshPD = Remesh(polyData, numVertices,
        gradation,
        subsampling,
        0.0,
        1.0,
        false,
        boundingFixing);*/
    vtkSurface* mesh = vtkSurface::New();

    mesh->CreateFromPolyData(polyData);
    mesh->GetCellData()->Initialize();
    mesh->GetPointData()->Initialize();
    mesh->DisplayMeshProperties();


    int density = 50;
    int numVertices = std::max(100, static_cast<int>(polyData->GetNumberOfPoints() * density * 0.01));

    QString remeshingType = "Adaptive"; // Adaptive or Regular
    double gradation = remeshingType == QStringLiteral("Adaptive") ? 1.0 : 0.0;

    const QString quality = "Medium (fast)";
    int subsampling;

    if (QStringLiteral("High (slow)") == quality)
    {
        subsampling = 50;
    }
    else if (QStringLiteral("Maximum (very slow)") == quality)
    {
        subsampling = 500;
    }
    else // The default is "Medium (fast)".
    {
        subsampling = 10;
    }

    bool boundingFixing = true;
    double edgeSplitting = 0.;
    double optimizationLevel = 1.0;

    if (numVertices == 0)
    {
        numVertices = polyData->GetNumberOfPoints();
    }

    if (edgeSplitting != 0.0)
        mesh->SplitLongEdges(edgeSplitting);

    std::cout << " **************************1111111111111*****************************************" << std::endl;
    vtkIsotropicDiscreteRemeshing* remesher = vtkIsotropicDiscreteRemeshing::New();

    remesher->GetMetric()->SetGradation(gradation);
    remesher->SetBoundaryFixing(boundingFixing);
    remesher->SetConsoleOutput(1);
    remesher->SetForceManifold(false);
    remesher->SetInput(mesh);
    remesher->SetNumberOfClusters(numVertices);
    remesher->SetSubsamplingThreshold(subsampling);

    remesher->Remesh();

    std::cout << " **************************222222222222*****************************************" << std::endl;

    // Optimization: Minimize distance between input surface and remeshed surface
    if (optimizationLevel != 0)
    {
        ClustersQuadrics clustersQuadrics(numVertices);

        auto faceList = vtkSmartPointer<vtkIdList>::New();
        vtkSmartPointer<vtkIntArray> clustering = remesher->GetClustering();
        vtkSmartPointer<vtkSurface> remesherInput = remesher->GetInput();
        int clusteringType = remesher->GetClusteringType();
        int numItems = remesher->GetNumberOfItems();
        int numMisclassifiedItems = 0;

        for (int i = 0; i < numItems; ++i)
        {
            int cluster = clustering->GetValue(i);

            if (cluster >= 0 && cluster < numVertices)
            {
                if (clusteringType != 0)
                {
                    remesherInput->GetVertexNeighbourFaces(i, faceList);
                    int numIds = static_cast<int>(faceList->GetNumberOfIds());

                    for (int j = 0; j < numIds; ++j)
                        vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster].data(), remesherInput, faceList->GetId(j), false);
                }
                else
                {
                    vtkQuadricTools::AddTriangleQuadric(clustersQuadrics.Elements[cluster].data(), remesherInput, i, false);
                }
            }
            else
            {
                ++numMisclassifiedItems;
            }
        }

        std::cout << " **************************333333333333333*****************************************" << std::endl;

        if (numMisclassifiedItems != 0)
            std::cout << numMisclassifiedItems << " items with wrong cluster association" << std::endl;

        vtkSmartPointer<vtkSurface> remesherOutput = remesher->GetOutput();
        double point[3];

        for (int i = 0; i < numVertices; ++i)
        {
            remesherOutput->GetPoint(i, point);
            vtkQuadricTools::ComputeRepresentativePoint(clustersQuadrics.Elements[i].data(), point, optimizationLevel);
            remesherOutput->SetPointCoordinates(i, point);
        }

        std::cout << "After quadrics post-processing:" << std::endl;
        remesherOutput->DisplayMeshProperties();
    }

    std::cout << " **************************444444444444*****************************************" << std::endl;
    auto normals = vtkSmartPointer<vtkPolyDataNormals>::New();

    normals->SetInputData(remesher->GetOutput());
    normals->AutoOrientNormalsOn();
    normals->ComputeCellNormalsOff();
    normals->ComputePointNormalsOn();
    normals->ConsistencyOff();
    normals->FlipNormalsOff();
    normals->NonManifoldTraversalOff();
    normals->SplittingOff();

    normals->Update();

    auto remeshedSurface = vtkPolyData::New();
    remeshedSurface->DeepCopy(normals->GetOutput());

    std::cout << "Finished remeshing";

    std::cout << "remeshPD: " << remeshedSurface <<std::endl;

    vtkNew< vtkSTLWriter > writer;
    writer->SetFileName("D:/Data/Remeshing/implantRemeshCode2.stl");
    writer->SetInputData(remeshedSurface);
    writer->Update();
}

结论：

感谢各位小伙伴的点赞+关注，小易会继续努力分享，一起进步！

雪易
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
VTK- Decimate网格抽取
qq_40041064的博客
12-07 1076
3-matic中的Remesh功能在保留实体几何形状的同时对其进行Remesh。VTK中能保留几何形状又能改变网格点集的Filter有Decimate相关的Filter。本博文研究VTK中关于Decimate网格抽取相关的Filter。
VTK显示网格
hit1524468的专栏
04-05 1929
#ifndef VTKHSWGRIDWIDGET_H #define VTKHSWGRIDWIDGET_H /* * ModelName: vtkHSWGridWidget * Description: 实现网格 * Author: hsw * Date: 2020-03-22 * */ #include <vtkLineSource.h> #include &lt...
VTK 数据类型：规则网格
ProgramNovice的博客
05-11 428
VTK 数据类型：规则网格
VTK网格细分-vtkAdaptiveSubdivisionFilter
qq_40041064的博客
12-02 1323
主要分享VTK中关于细分网格的相关Filter，VTK中关于网格细分的Filter包括vtkSubdivisionFilter和vtkAdaptiveSubdivisionFilter。
VTK生成网格平面
TiredWind的博客
07-20 2858
直接使用vtkPlaneSource, vtkRegularPolygonSource等现成的类好像无法画出此类网格平面，这样就只能自己构造polydata了。 #include <vtkPoints.h> #include <vtkCellArray.h> #include <vtkPolyData.h> #include <vtkPolyDataMapper.h> #include <vtkActor.h> #include &l...
基于VTK实现旋转功能
09-20
基于VTK实现旋转功能，实现效果见博客：https://blog.csdn.net/qq_40041064/article/details/130636319 已按VTK中Widget和Representation进行封装，简单易用！
VTK.rar_vtk_基于VTK
09-22
总的来说，基于VTK的医学图像处理子系统设计和实现涵盖了数据读取、预处理、可视化、分析和用户交互等多个环节，通过VTK提供的丰富API，可以构建出功能强大、性能优异的图像处理工具。在实际开发过程中，开发者需要...
基于VTK的有限元网格可视化研究及软件设计(含源文件)
08-30
本课题以 Microsoft Visual 2010为编译平台，基于 VTK ( Visualization Toolkit )及其接口技术，实现了有限元分析中多种单元网格模型的可视化。这些网格单元类型包括：离散点集、线单元模型、三角形单元模型、四面体...
分别用C语言和C++语言写的用于三角网格划分的算法 划分效果和速度都不错
06-18
分别用C语言和C++语言写的用于三角网格划分的算法。划分效果和速度都不错-Were used C language and C++ language written for the triangular meshing algorithms. Into the effectiveness and speed are good
代码_喷管_网格划分；拉瓦尔喷管；pthon
09-10
在Python中，可以利用如`OpenFOAM`的前处理工具`snappyHexMesh`的Python接口或者专门的网格生成库如`VTK`、`Trimesh`等进行网格划分。对于复杂形状的喷管边界，可能需要进行多重网格加密，特别是在喉部和扩张段，...
VTK：生成网格(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-27 695
VTK：生成网格(附完整源码)
vtk 显示属性设置网格 点 面
WUYIDUER的博客
12-21 1170
actor->GetProperty()->SetRepresentationToPoints() actor->GetProperty()->SetRepresentationToWireframe() actor->GetProperty()->SetRepresentationToSurface()
VTK：显式结构化网格用法实战
希望我的博客，能帮上你解决学习中工作中所遇到的问题
02-01 719
VTK：显式结构化网格用法实战程序输出程序完整源代码 程序输出 程序完整源代码 #include <vtkActor.h> #include <vtkCamera.h> #include <vtkCellArray.h> #include <vtkDataSetMapper.h> #include <vtkExplicitStructuredGrid.h> #include <vtkExplicitStructuredGridToUnstr
VTK：图像基本操作进阶——网格模型的特征边与封闭性检测
m0_45306991的博客
05-10 968
1.封闭性检测 由于受源数据、重建方法的限制，得到的网格模型并不是封闭的。有时候为了显示或者处理某些需求，需要网格必须是封闭的。封闭性网格应该比较好理解，比如一个球面网格。 上节提到边界边的概念；如果一条边只被一个多边形包含，那么这条边就是边界边。是否存在边界边是检测一个网格模型是否封闭的重要特征。 vtkFeatureEdges是一个非常重要的类，该类能够提取多边形网格模型中四种类型的边。 边界边：只被一个多边形或者一条边包围的边。 非流性边：被三个火三个以上多边形包围的边。 特征边：需要设置一个特
[知识点]-[最短路]
m0_52398496的博客
07-31 537
【代码】[知识点]-[最短路]
【算法】递归实现二分查找（优化）以及非递归实现二分查找
2302_78914800的博客
07-31 216
1.首先确定该数组中间的下标 mid = (left + right) / 2;2.递归完整个数组，依然没有找到，即 left > right 就阶结束递归。2.然后让需要查找的数 findVal 和 arr[mid] 比较。
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统
m0_68536532的博客
08-03 183
2023 RoboCom CAIP本科组决赛-RC-u3 兰州拉面派餐系统具体实现(不使用优先队列+使用优先队列)
算法日记day 28（贪心之分发饼干|摆动序列|最大子数组和|买卖股票最佳时机）
最新发布
m0_74980681的博客
08-03 325
在判断是否摆动时，需要判断当前节点与左右邻节点的差值是否为一正一负，满足条件才是属于摆动，其中存在一种特殊情况，如：（1,2,2,4,5）属于单调摆动，这种情况总共只有2个摆动，即为边界的两次摆动，因此采用双指针摆动时不能实时更新两个指针的位置，应为一个指针负责判断差值，当差值存在时才能更新另一个指针的位置。可以采用双指针的方法，先将两数组从小到大排序，判断饼干数组中的值是否大于等于胃口数组的值，如果是结果加1，然后饼干数组向前遍历，继续判断，直到饼干数组全部遍历完毕，输出结果数组。，这个孩子会得到满足。
vtkIntersectionPolyDataFilter 重新划分网格沿交点线分割两个输出 vtkPolyData,d代码如何实现
04-25
在使用 vtkIntersectionPolyDataFilter 进行网格交点分割时，可以通过以下代码来实现重新划分网格沿交点线分割两个输出 vtkPolyData： ``` // 创建vtkIntersectionPolyDataFilter对象 vtkSmartPointer<vtkIntersectionPolyDataFilter> intersectionFilter = vtkSmartPointer<vtkIntersectionPolyDataFilter>::New(); // 设置输入vtkPolyData数据 intersectionFilter->SetInputData(polyData); // 设置交点分割线数据 intersectionFilter->SetSplitFirstOutput(true); intersectionFilter->SetSplitSecondOutput(true); intersectionFilter->Update(); // 获取交点分割后的两个输出vtkPolyData数据 vtkPolyData* output1 = intersectionFilter->GetOutput(0); vtkPolyData* output2 = intersectionFilter->GetOutput(1); ``` 通过上述代码，我们创建了一个 vtkIntersectionPolyDataFilter 对象，并将我们需要进行交点分割的 vtkPolyData 数据设置为其输入数据。然后设置交点分割线数据，并进行交点分割操作，最终可以通过 GetOutput() 函数获取交点分割后的两个 vtkPolyData 输出数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雪易

给我来点鼓励吧

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

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

打赏作者

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

抵扣说明：

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

余额充值