VTK_Learning_图形基本操作进阶_多分辨率策略（模型细化的三种方法）

╰+攻爆jí腚メ 2023-07-11 15:07 1阅读 0赞

# 1.模型细化 #

> vtk中实现网格细化的累有vtkLinearSubdivisionFilter、vtkLoopsubdivisionFilter、vtkButterflySubdivisionFilter。这三个类都继承自vtkInterpolatingSubdivisionFilter。具体的类的继承关系图如下图所示：  
> ![20170204112020724][]
> 
> vtkInterpolatingSunvisionFilter内部提供了SetNumberOfSubvisions()函数来设置细化的次数，其中每次细化后模型的三角面片的个数将是细化前的四倍。因此，在对网格模型进行n次细化后，该模型的面片个数将是原始模型面片数目的4\*n倍。
> 
> ##    1.1 vtkLinearSubdivisionFilter ##
> 
>   
> 该类实现了一种线性细分算法，每次细分将每个三角形面片生成四个新的面片，该算法比较简单，速度快，但是细分后不能产生光滑的模型。
> 
> ##    1.2 vtkLoopSubdivisionFilter ##
> 
>   
> 该类实现的是Loop细分算法，每次细分会将一个三角面片生成4个三角面片，具体算法思想可以参考文献\[1\]；该方法可以生成光滑的连续曲面，应用比较广泛。
> 
> ##    1.3 vtkButterflySubdivisionFilter ##
> 
>   
> 该类实现了蝶形细分算法，具体的算法思想可以参考文献\[2\].  
>

# 2.网格模型细化实验  #

#include <vtkAutoInit.h>
    VTK_MODULE_INIT(vtkRenderingOpenGL);
    VTK_MODULE_INIT(vtkRenderingFreeType);
    VTK_MODULE_INIT(vtkInteractionStyle);
     
    #include <vtkSmartPointer.h>
    #include <vtkPolyDataReader.h>
    #include <vtkPolyData.h>
    #include <vtkLinearSubdivisionFilter.h>
    #include <vtkLoopSubdivisionFilter.h>
    #include <vtkButterflySubdivisionFilter.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkActor.h>
    #include <vtkRenderer.h>
    #include <vtkRenderWindow.h>
    #include <vtkCamera.h>
    #include <vtkRenderWindowInteractor.h>
     
    int main()
    {
    	//读数据
    	vtkSmartPointer<vtkPolyDataReader> reader =
    		vtkSmartPointer<vtkPolyDataReader>::New();
    	reader->SetFileName("fran_cut.vtk");
    	reader->Update();
     
    	vtkSmartPointer<vtkPolyData> orig = reader->GetOutput();
    	std::cout << "original" << "-----------------------" << std::endl;
    	std::cout << "模型点数为： " << orig->GetNumberOfPoints() << std::endl;
    	std::cout << "模型面数为： " << orig->GetNumberOfPolys() << std::endl;
    	//线性网格细分滤波器
    	vtkSmartPointer<vtkLinearSubdivisionFilter> linear =
    		vtkSmartPointer<vtkLinearSubdivisionFilter>::New();
    	linear->SetInputData(orig);
    	linear->SetNumberOfSubdivisions(4);
    	linear->Update();
     
    	vtkSmartPointer<vtkPolyData> linearInfo = linear->GetOutput();
    	std::cout << "linear" << "-----------------------" << std::endl;
    	std::cout << "模型点数为： " << linearInfo->GetNumberOfPoints() << std::endl;
    	std::cout << "模型面数为： " << linearInfo->GetNumberOfPolys() << std::endl;
     
    	//Loop网格细分滤波器
    	vtkSmartPointer<vtkLoopSubdivisionFilter> loop =
    		vtkSmartPointer<vtkLoopSubdivisionFilter>::New();
    	loop->SetInputData(orig);
    	loop->SetNumberOfSubdivisions(4);
    	loop->Update();
     
    	vtkSmartPointer<vtkPolyData> loopInfo = loop->GetOutput();
    	std::cout << "loop" << "-----------------------" << std::endl;
    	std::cout << "模型点数为： " << loopInfo->GetNumberOfPoints() << std::endl;
    	std::cout << "模型面数为： " << loopInfo->GetNumberOfPolys() << std::endl;
     
    	//butterfly网格细分滤波器
    	vtkSmartPointer<vtkButterflySubdivisionFilter> butterfly =
    		vtkSmartPointer<vtkButterflySubdivisionFilter>::New();
    	butterfly->SetInputData(orig);
    	butterfly->SetNumberOfSubdivisions(4);
    	butterfly->Update();
     
    	vtkSmartPointer<vtkPolyData> butterflyInfo = butterfly->GetOutput();
    	std::cout << "butterfly" << "-----------------------" << std::endl;
    	std::cout << "模型点数为： " << butterflyInfo->GetNumberOfPoints() << std::endl;
    	std::cout << "模型面数为： " << butterflyInfo->GetNumberOfPolys() << std::endl;
    	
    	vtkSmartPointer<vtkPolyDataMapper> origMapper =
    		vtkSmartPointer<vtkPolyDataMapper>::New();
    	origMapper->SetInputData(orig);
    	vtkSmartPointer<vtkActor> origActor =
    		vtkSmartPointer<vtkActor>::New();
    	origActor->SetMapper(origMapper);
     
    	vtkSmartPointer<vtkPolyDataMapper> linearMapper =
    		vtkSmartPointer<vtkPolyDataMapper>::New();
    	linearMapper->SetInputData(linear->GetOutput());
    	vtkSmartPointer<vtkActor> linearActor =
    		vtkSmartPointer<vtkActor>::New();
    	linearActor->SetMapper(linearMapper);
     
    	vtkSmartPointer<vtkPolyDataMapper> loopMapper =
    		vtkSmartPointer<vtkPolyDataMapper>::New();
    	loopMapper->SetInputData(loop->GetOutput());
    	vtkSmartPointer<vtkActor> loopActor =
    		vtkSmartPointer<vtkActor>::New();
    	loopActor->SetMapper(loopMapper);
     
    	vtkSmartPointer<vtkPolyDataMapper> butterflyMapper =
    		vtkSmartPointer<vtkPolyDataMapper>::New();
    	butterflyMapper->SetInputData(butterfly->GetOutput());
    	vtkSmartPointer<vtkActor> butterflyActor =
    		vtkSmartPointer<vtkActor>::New();
    	butterflyActor->SetMapper(butterflyMapper);
    	//
    	double ltView[4] = { 0, 0, 0.5, 0.5 };
    	double rtView[4] = { 0.5, 0, 1, 0.5 };
    	double lbView[4] = { 0, 0.5, 0.5, 1 };
    	double rbView[4] = { 0.5, 0.5, 1, 1 };
     
    	vtkSmartPointer<vtkRenderer> origRender =
    		vtkSmartPointer<vtkRenderer>::New();
    	origRender->SetViewport(ltView);
    	origRender->AddActor(origActor);
    	origRender->SetBackground(1, 0, 0);
     
    	vtkSmartPointer<vtkRenderer> linearRender =
    		vtkSmartPointer<vtkRenderer>::New();
    	linearRender->SetViewport(rtView);
    	linearRender->AddActor(linearActor);
    	linearRender->SetBackground(0, 1, 0);
     
    	vtkSmartPointer<vtkRenderer> loopRender =
    		vtkSmartPointer<vtkRenderer>::New();
    	loopRender->SetViewport(lbView);
    	loopRender->AddActor(loopActor);
    	loopRender->SetBackground(0, 0, 1);
     
    	vtkSmartPointer<vtkRenderer> butterflyRender =
    		vtkSmartPointer<vtkRenderer>::New();
    	butterflyRender->SetViewport(rbView);
    	butterflyRender->AddActor(butterflyActor);
    	butterflyRender->SetBackground(0, 0, 0);
    	//
    	vtkSmartPointer<vtkRenderWindow> rw =
    		vtkSmartPointer<vtkRenderWindow>::New();
    	rw->AddRenderer(origRender);
    	rw->AddRenderer(linearRender);
    	rw->AddRenderer(loopRender);
    	rw->AddRenderer(butterflyRender);
    	rw->SetSize(640, 640);
    	rw->SetWindowName("PolyData Subdivision");
     
    	origRender->GetActiveCamera()->SetPosition(0, -1, 0);
    	origRender->GetActiveCamera()->SetFocalPoint(0, 0, 0);
    	origRender->GetActiveCamera()->SetViewUp(0, 0, 1);
    	origRender->GetActiveCamera()->Azimuth(30);
    	origRender->GetActiveCamera()->Elevation(30);
    	origRender->ResetCamera();//刷新照相机  
    	linearRender->SetActiveCamera(origRender->GetActiveCamera());
    	loopRender->SetActiveCamera(origRender->GetActiveCamera());
    	butterflyRender->SetActiveCamera(origRender->GetActiveCamera());
    	
    	vtkSmartPointer<vtkRenderWindowInteractor> rwi =
    		vtkSmartPointer<vtkRenderWindowInteractor>::New();
    	rwi->SetRenderWindow(rw);
    	rwi->Start();
    	rw->Render();
     
    	return 0;
    }

输出结果：

![20170204124206813][]

红色视窗为原始三角网格模型，绿色视窗采用了线性细分算法；蓝色视窗采用Loop细分算法；黑色视窗采用了Butterfly细分算法。

鼻子部位的细节图：

![20170204124212652][]

从上面结果上看，我们可以看出：线性细分效果似乎没有起到多大作用？？！Loop细分结果得到了很光滑的曲面，Butterfly细分在细节部分处理的并不很理想。

注意事项：  
所有模型细化算子仅对三角网格数据有效，因此在处理多边形数据时，需要通过VTKTriangleFilter将多边形网格转换为三角网格才能处理。

[20170204112020724]: https://img-blog.csdn.net/20170204112020724
[20170204124206813]: https://img-blog.csdn.net/20170204124206813
[20170204124212652]: https://img-blog.csdn.net/20170204124212652