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

1.模型细化

vtk中实现网格细化的累有vtkLinearSubdivisionFilter、vtkLoopsubdivisionFilter、vtkButterflySubdivisionFilter。这三个类都继承自vtkInterpolatingSubdivisionFilter。具体的类的继承关系图如下图所示：

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;
}

输出结果：

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

鼻子部位的细节图：

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

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