6.VTK二维三维图像显示以及二维三维图像切面交互提取（回调函数、观察者-命令模式）

梦里花乡

已于 2023-12-14 14:44:10 修改

阅读量914

点赞数 3

分类专栏： VTK项目代码学习文章标签： c++

于 2023-10-09 13:43:20 首次发布

本文链接：https://blog.csdn.net/weixin_52194015/article/details/133699947

版权

VTK项目代码学习专栏收录该内容

18 篇文章 11 订阅

订阅专栏

这个专栏是用于记录我在学习VTK过程中的一些心得体会。参考的资料主要有以下三个：

1. 张晓东罗火灵《VTK图形图像开发进阶》
2. https://examples.vtk.org/site/
3. 沈子恒《VTK 三维数据渲染进阶》

遇到的一个大问题就是由于版本更新，这些资料中很多代码无法正常运行，需要进行一定的修改，所以这个专栏会记录下来我修改后的程序代码，以便于我之后温习。也希望能给和我有同样困扰的小伙伴们一些帮助。

我使用的版本：VTK9 + VS2022

1.vtkImageViewer2类显示图像

vtkImageViewer2中封装了VTK图像显示的管线，包括vtkActor，vtkRender，vtkRenderWindow，vtkInteractorStypeImage等对象，可以方便的完成图像显示和交互。该类提供的主要交互操作有：图像放缩，窗宽窗位调节，并提供切片选择，切片方向设置接口，尤其适合三维图像的显示。这里以一幅三位医学图像的显示为例，来展示vtkImageViewer2类如何显示图像。

#include <vtkAutoInit.h>        
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);

#include <vtkSmartPointer.h>
#include <vtkMetaImageReader.h>
#include <vtkImageViewer2.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>

int main(int argc, char* argv[])
{
	vtkSmartPointer<vtkMetaImageReader> reader =
		vtkSmartPointer<vtkMetaImageReader>::New();
	reader->SetFileName("brain.mhd");
	reader->Update();

	vtkSmartPointer<vtkImageViewer2> viewer =
		vtkSmartPointer<vtkImageViewer2>::New();
	viewer->SetInputConnection(reader->GetOutputPort());

	//设置基本属性
	viewer->SetSize(640, 480);
	viewer->SetColorLevel(500);
	viewer->SetColorWindow(2000);
	viewer->SetSlice(40);
	viewer->SetSliceOrientationToXY();
	viewer->Render();
	viewer->GetRenderer()->SetBackground(1, 1, 1);
	viewer->GetRenderWindow()->SetWindowName("ImageViewer2D");

	vtkSmartPointer<vtkRenderWindowInteractor> rwi =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	//设置交互属性
	viewer->SetupInteractor(rwi);

	rwi->Start();

	return 0;
}

这里要提醒大家的是，如果在读取.mhd文件时出现错误：vtkMetaImageReader:MetatImage cannot read data from file. 如下图所示：

首先我们要检查我们的图像的路径是否正确，路径处除了.mhd文件，一定要有对应的.raw文件。如果这些地方都没问题，可以用记事本或者其他编译器打开.mhd文件，

重点在最后一行的ElementDataFile，该行的内容是.raw文件的索引，该行内容必须和同文件夹下的.raw文件名字相同！！！

运行结果

2.vtkImageActor类显示图像

vtkImageActor是一个三维图像渲染Actor，通过纹理映射将图像映射到一个多边形上进行显示。使用vtkImageActor较vtkImageViewer2要复杂一些，需要建立完整的渲染管线：包括vtkImageActor，vtkRender，vtkRenderWindow，vtkRenderWindowInteractor管线。另外，作为图像二维浏览器，不需要在三维空间中进行旋转操作，因此还需要为vtkRenderWindow定义一个vtkInteractorStyleImage对象。

#include <vtkAutoInit.h>        
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);

#include <vtkSmartPointer.h>
#include <vtkBMPReader.h>
#include <vtkImageActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleImage.h>

int main()
{
	vtkSmartPointer<vtkBMPReader> reader =
		vtkSmartPointer<vtkBMPReader>::New();
	reader->SetFileName("D:/lena.bmp");
	reader->Update();

	vtkSmartPointer<vtkImageActor> actor =
		vtkSmartPointer<vtkImageActor>::New();
	actor->SetInputData(reader->GetOutput());

	vtkSmartPointer<vtkRenderer> render =
		vtkSmartPointer<vtkRenderer>::New();
	render->AddActor(actor);
	render->ResetCamera();
	render->SetBackground(1, 1, 1);

	vtkSmartPointer<vtkRenderWindow> window =
		vtkSmartPointer<vtkRenderWindow>::New();
	window->AddRenderer(render);
	window->SetSize(640, 480);
	window->SetWindowName("ImageViewer3D");
	window->Render();

	vtkSmartPointer<vtkRenderWindowInteractor> rwi =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	vtkSmartPointer<vtkInteractorStyleImage> style =
		vtkSmartPointer<vtkInteractorStyleImage>::New();
	rwi->SetInteractorStyle(style);
	rwi->SetRenderWindow(window);
	rwi->Initialize();

	rwi->Start();
	return 0;
}

3.图像融合

前面介绍的两个例子都是在一个窗口中显示一个图像。但是在常见的图像处理软件中，经常会遇到在一个窗口中显示多个图像，这就会用到图像融合技术。图像融合利用图像的alpha通道和不透明度来实现。VTK中vtkImageBlend实现图像的融合。

vtkImageBlend可以接收多个图像输入，输出为融合图像。输出图像的像素间隔、原点、范围（extent）以及像素组分个数与第一个图像一致。该类提供了两种融合模式，默认的融合方式是标准模式。第二种是混合模式（Compound）。该模式下输出结果经过alpha/opacity不透明度的和做过归一化。另外还可以设置一个阈值，当alpha*opacity小于等于该阈值时会忽略该像素。

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);

#include <vtkSmartPointer.h>
#include <vtkJPEGReader.h>
//#include <vtkImageCast.h>
#include <vtkImageData.h>
#include <vtkImageCanvasSource2D.h>
#include <vtkImageBlend.h>
#include <vtkImageActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleImage.h>

int main()
{
	//数据管线
	vtkSmartPointer<vtkJPEGReader> reader =
		vtkSmartPointer<vtkJPEGReader>::New();
	reader->SetFileName("D:/lena-gray.jpg");
	reader->Update();

	vtkSmartPointer<vtkImageCanvasSource2D> source =
		vtkSmartPointer<vtkImageCanvasSource2D>::New();
	source->SetNumberOfScalarComponents(1);
	source->SetScalarTypeToUnsignedChar();
	source->SetExtent(0, 512, 0, 512, 0, 0);
	source->SetDrawColor(0, 0, 0);
	source->FillBox(0, 512, 0, 512);
	source->SetDrawColor(255, 255, 255);
	source->FillBox(100, 400, 100, 400);
	source->Update();

	vtkSmartPointer<vtkImageBlend> blend =
		vtkSmartPointer<vtkImageBlend>::New();
	blend->AddInputData(reader->GetOutput());
	blend->AddInputData(source->GetOutput());
	blend->SetOpacity(0, 0.4);
	blend->SetOpacity(1, 0.6);
	blend->Update();

	//渲染引擎
	vtkSmartPointer<vtkImageActor> actor1 =
		vtkSmartPointer<vtkImageActor>::New();
	actor1->SetInputData(reader->GetOutput());

	vtkSmartPointer<vtkImageActor> actor2 =
		vtkSmartPointer<vtkImageActor>::New();
	actor2->SetInputData(source->GetOutput());

	vtkSmartPointer<vtkImageActor> blend_actor =
		vtkSmartPointer<vtkImageActor>::New();
	blend_actor->SetInputData(blend->GetOutput());
	//定义视窗大小(xmin.ymin,xmax,ymax)
	//按window的尺寸进行比例分割
	double leftViewport[4] = { 0,0,0.33,1 };
	double midViewport[4] = { 0.33,0,0.66,1 };
	double rightViewport[4] = { 0.66,0,1,1 };
	//render
	vtkSmartPointer<vtkRenderer> render1 =
		vtkSmartPointer<vtkRenderer>::New();
	render1->SetViewport(leftViewport);
	render1->AddActor(actor1);
	render1->ResetCamera();
	render1->SetBackground(1, 0, 0);

	vtkSmartPointer<vtkRenderer> render2 =
		vtkSmartPointer<vtkRenderer>::New();
	render2->SetViewport(midViewport);
	render2->AddActor(actor2);
	render2->ResetCamera();
	render2->SetBackground(0, 1, 0);

	vtkSmartPointer<vtkRenderer> render3 =
		vtkSmartPointer<vtkRenderer>::New();
	render3->SetViewport(rightViewport);
	render3->AddActor(blend_actor);
	render3->ResetCamera();
	render3->SetBackground(0, 0, 1);
	//window
	vtkSmartPointer<vtkRenderWindow> renderwindow =
		vtkSmartPointer<vtkRenderWindow>::New();
	renderwindow->AddRenderer(render1);
	renderwindow->AddRenderer(render2);
	renderwindow->AddRenderer(render3);
	renderwindow->SetSize(640, 320);
	renderwindow->SetWindowName("Image-Fusion");
	renderwindow->Render();
	//interactor
	vtkSmartPointer<vtkRenderWindowInteractor> rwi =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	vtkSmartPointer<vtkInteractorStyleImage> style =
		vtkSmartPointer<vtkInteractorStyleImage>::New();
	rwi->SetInteractorStyle(style);
	rwi->SetRenderWindow(renderwindow);
	rwi->Initialize();
	rwi->Start();

	return 0;
}

运行结果

4.切面

切面是三维图像比较常用的概念。常用的切面有：

（1）矢状面（Sagital Plane）：平行于YZ平面的切面。

（2）冠状面（Coronal Plane）：平行于XZ平面的切面。

（3）横断面（Transverse/Axial Plane）：平行于XY平面的切面。

除了以上三种特殊的切面，切面也可以是通过三维图像内部一点且平行于任意方向的平面。VTK中vtkImageReslice类可实现图像切面的提取。

先通过vtkMetaImageReader读取一幅医疗三维图像，获取图像范围、原点和像素间距。

vtkSmartPointer<vtkMetaImageReader> reader =
	vtkSmartPointer<vtkMetaImageReader>::New();
reader->SetFileName("brain.mhd");
reader->Update();

int extent[6];
double spacing[3];
double origin[3];

reader->GetOutput()->GetExtent(extent);
reader->GetOutput()->GetSpacing(spacing);
reader->GetOutput()->GetOrigin(origin);

定义切面变换矩阵axialElements，该矩阵的前三列分别表示X,Y,Z方向矢量，第四列为切面坐标系原点。

static double axialElements[16] = {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1
	};

常用变换矩阵：

static double coronalElements[16] = {
		1, 0, 0, 0,
		0, 0, 1, 0,
		0, -1, 0, 0,
		0, 0, 0, 1
	};   //冠状切面

static double sagitalElements[16] = {
		0, 0, -1, 0,
		1, 0, 0, 0,
		0, -1, 0, 0,
		0, 0, 0, 1
	};   //矢状切面

static double obliqueElements[16] = {
		1, 0, 0, 0,
		0, 0.866025, -0.5, 0,
		0, 0.5, 0.866025, 0,
		0, 0, 0, 1
	};  //斜切切面

完整程序代码：

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);

#include <vtkSmartPointer.h>
#include <vtkImageData.h>
#include <vtkMetaImageReader.h>
#include <vtkMatrix4x4.h> //
#include <vtkImageReslice.h>
#include <vtkLookupTable.h>
#include <vtkImageMapToColors.h>
#include <vtkImageActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleImage.h>

int main(int argc, char* argv[])
{
	vtkSmartPointer<vtkMetaImageReader> reader =
		vtkSmartPointer<vtkMetaImageReader>::New();
	reader->SetFileName("brain.mhd");
	reader->Update();

	int extent[6];
	double spacing[3];
	double origin[3];

	reader->GetOutput()->GetExtent(extent);
	reader->GetOutput()->GetSpacing(spacing);
	reader->GetOutput()->GetOrigin(origin);

	double center[3];
	center[0] = origin[0] + spacing[0] * 0.5 * (extent[0] + extent[1]);
	center[1] = origin[1] + spacing[1] * 0.5 * (extent[2] + extent[3]);
	center[2] = origin[2] + spacing[2] * 0.5 * (extent[4] + extent[5]);
	//*****************************************************************//
	static double axialElements[16] = {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1
	};

	vtkSmartPointer<vtkMatrix4x4> resliceAxes =
		vtkSmartPointer<vtkMatrix4x4>::New();
	resliceAxes->DeepCopy(axialElements);
	resliceAxes->SetElement(0, 3, center[0]);
	resliceAxes->SetElement(1, 3, center[1]);
	resliceAxes->SetElement(2, 3, center[2]);

	vtkSmartPointer<vtkImageReslice> reslice =
		vtkSmartPointer<vtkImageReslice>::New();
	reslice->SetInputConnection(reader->GetOutputPort());
	reslice->SetOutputDimensionality(2);
	reslice->SetResliceAxes(resliceAxes);
	reslice->SetInterpolationModeToLinear();
	reslice->Update();

	//*****************************************************************//
	vtkSmartPointer<vtkLookupTable> colorTable =
		vtkSmartPointer<vtkLookupTable>::New();
	colorTable->SetRange(0, 1000);
	colorTable->SetValueRange(0.0, 1.0);
	colorTable->SetSaturationRange(0.0, 0.0);
	colorTable->SetRampToLinear();
	colorTable->Build();
	vtkSmartPointer<vtkImageMapToColors> colorMap =
		vtkSmartPointer<vtkImageMapToColors>::New();
	colorMap->SetLookupTable(colorTable);
	colorMap->SetInputConnection(reslice->GetOutputPort());
	colorMap->Update();

	//*****************************************************************//
	vtkSmartPointer<vtkImageActor> imgActor =
		vtkSmartPointer<vtkImageActor>::New();
	imgActor->SetInputData(colorMap->GetOutput());

	vtkSmartPointer<vtkRenderer> renderer =
		vtkSmartPointer<vtkRenderer>::New();
	renderer->AddActor(imgActor);
	renderer->SetBackground(1.0, 1.0, 1.0);

	vtkSmartPointer<vtkRenderWindow> renderWindow =
		vtkSmartPointer<vtkRenderWindow>::New();
	renderWindow->AddRenderer(renderer);
	renderWindow->Render();
	renderWindow->SetSize(640, 480);
	renderWindow->SetWindowName("Extract3Dslice");

	vtkSmartPointer<vtkRenderWindowInteractor> rwi =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	vtkSmartPointer<vtkInteractorStyleImage> imagestyle =
		vtkSmartPointer<vtkInteractorStyleImage>::New();
	rwi->SetInteractorStyle(imagestyle);
	rwi->SetRenderWindow(renderWindow);
	rwi->Initialize();
	rwi->Start();

	return 0;
}

运行程序可以得到大脑图像的一个切面。

5.三维图像切片交互提取（回调函数、观察者-命令模式）

学习上一部分三维图像切面的提取后，我们可以实现一个稍微复杂的程序——通过滑动鼠标来切换三维图像切片，这也是医学图像处理软件中一个很基本的功能。实现该功能难点是怎样在VTK中控制鼠标来实时提取图像切片。我们采用观察者/命令(Observer/Command)模式机制来实现。

VTK中鼠标消息是在交互类型对象（interactorstyle）中响应，因此通过为交互类型对象（interactorstyle）添加观察者（observer）来监听相应的消息，当消息触发时，由命令模式执行相应的回调函数。

#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);

#include <vtkSmartPointer.h>
#include <vtkMetaImageReader.h>
#include <vtkDicomImageReader.h>
#include <vtkMatrix4x4.h>
#include <vtkLookupTable.h>
#include <vtkImageMapToColors.h>
#include <vtkImageActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleImage.h>

#include <vtkCommand.h> //建立“观察者/命令”模式监听鼠标消息 完成交互
#include <vtkImageReslice.h>
#include <vtkImageData.h>

class vtkImageInteractionCallback : public vtkCommand
{
public:
	static vtkImageInteractionCallback* New() //回调函数初始化函数
	{
		return new vtkImageInteractionCallback;
	}
	vtkImageInteractionCallback()
	{
		this->Slicing = 0;
		this->ImageReslice = 0;
		this->Interactor = 0;
	}
	void SetImageReslice(vtkImageReslice* reslice)
	{
		this->ImageReslice = reslice;
	}
	vtkImageReslice* GetImageReslice()
	{
		return this->ImageReslice;
	}
	void SetImageResliceColorMap(vtkImageMapToColors* colorMap)
	{
		this->colorMap = colorMap;
	}
	vtkImageMapToColors* GetImageResliceColorMap()
	{
		return this->colorMap;
	}
	void SetInteractor(vtkRenderWindowInteractor* interactor)
	{
		this->Interactor = interactor;
	}
	vtkRenderWindowInteractor* GetInteractor()
	{
		return  this->Interactor;
	}
	virtual void Execute(vtkObject*, unsigned long event, void*)
	{
		vtkRenderWindowInteractor* interactor = GetInteractor();
		int lastPos[2];
		interactor->GetLastEventPosition(lastPos);
		int currPos[2];
		interactor->GetEventPosition(currPos);

		if (event == vtkCommand::LeftButtonPressEvent)
		{
			this->Slicing = 1; //标志位 
		}
		else if (event == vtkCommand::LeftButtonReleaseEvent)
		{
			this->Slicing = 0; //标志位 
		}
		else if (event == vtkCommand::MouseMoveEvent)
		{
			if (this->Slicing)//检验鼠标左键已经按下 正在执行操作
			{	
				std::cout << "LeftButton has been pressed: " << std::endl;
				vtkImageReslice* reslice = this->ImageReslice;
				//记下鼠标Y向变化的幅值大小
				int deltaY = lastPos[1] - currPos[1];
				std::cout << "鼠标Y向变化的幅值大小: " <<deltaY<< std::endl;
				//记下鼠标X向变化的幅值大小
				int deltaX = lastPos[0] - currPos[0];
				std::cout << "鼠标X向变化的幅值大小: " << deltaX << std::endl;

				reslice->Update();
				double sliceSpacing = reslice->GetOutput()->GetSpacing()[2];
				vtkMatrix4x4* matrix = reslice->GetResliceAxes();
				//重新定位切片需要经过的中心点
				double point[4];
				double center[4];
				point[0] = 0;
				point[1] = 0;
				point[2] = sliceSpacing * deltaY;
				point[3] = 1.0;
				matrix->MultiplyPoint(point, center);
				//***********理解MultiplyPoint   center4*1  =  matrix4*4  乘以  point4*1
				for (int i = 0; i < 4; i++)
				{
					for (int j = 0; j < 4; j++)
					{
						std::cout << matrix->GetElement(i, j) << "\t";
					}
					std::cout << "\n";
				}
				std::cout << "\n";
				std::cout << point[0] << "\t" << point[1] << "\t" << point[2] << "\t" << point[3] << "\n";
				std::cout << center[0] << "\t" << center[1] << "\t" << center[2] << "\t" << center[3] << "\n";

				//******************
				matrix->SetElement(0, 3, center[0]);
				matrix->SetElement(1, 3, center[1]);
				matrix->SetElement(2, 3, center[2]);
				static double colorWindowLevel = 500;
				static double colorWindowWith = 2000;
				colorWindowLevel += deltaX;

				colorMap->GetLookupTable()->SetRange(colorWindowLevel - colorWindowWith / 2, colorWindowLevel + colorWindowWith / 2);

				reslice->Update();
				colorMap->Update();
				interactor->Render();
			}
			else
			{
				vtkInteractorStyle* style = vtkInteractorStyle::SafeDownCast(
					interactor->GetInteractorStyle());
				if (style)
				{
					style->OnMouseMove();
				}
			}
		}
	}
private:
	int Slicing;
	vtkImageReslice* ImageReslice;
	vtkImageMapToColors* colorMap;
	vtkRenderWindowInteractor* Interactor;
};
//**********************************************************************************//
int main()
{
	vtkSmartPointer<vtkMetaImageReader> reader =
		vtkSmartPointer<vtkMetaImageReader>::New();
	reader->SetFileName("brain.mhd");
	reader->Update();

	int extent[6];
	double spacing[3];
	double origin[3];

	reader->GetOutput()->GetExtent(extent);
	reader->GetOutput()->GetSpacing(spacing);
	reader->GetOutput()->GetOrigin(origin);

	double center[3];
	center[0] = origin[0] + spacing[0] * 0.5 * (extent[0] + extent[1]);
	center[1] = origin[1] + spacing[1] * 0.5 * (extent[2] + extent[3]);
	center[2] = origin[2] + spacing[2] * 0.5 * (extent[4] + extent[5]);

	static double axialElements[16] = {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1
	};

	vtkSmartPointer<vtkMatrix4x4> resliceAxes =
		vtkSmartPointer<vtkMatrix4x4>::New();
	resliceAxes->DeepCopy(axialElements);

	resliceAxes->SetElement(0, 3, center[0]);
	resliceAxes->SetElement(1, 3, center[1]);
	resliceAxes->SetElement(2, 3, center[2]);

	vtkSmartPointer<vtkImageReslice> reslice =
		vtkSmartPointer<vtkImageReslice>::New();
	reslice->SetInputConnection(reader->GetOutputPort());
	reslice->SetOutputDimensionality(2);
	reslice->SetResliceAxes(resliceAxes);
	reslice->SetInterpolationModeToLinear();
	reslice->Update();

	vtkSmartPointer<vtkLookupTable> colorTable =
		vtkSmartPointer<vtkLookupTable>::New();
	colorTable->SetRange(0, 1000);
	colorTable->SetValueRange(0.0, 1.0);
	colorTable->SetSaturationRange(0.0, 0.0);
	colorTable->SetRampToLinear();
	colorTable->Build();

	vtkSmartPointer<vtkImageMapToColors> colorMap =
		vtkSmartPointer<vtkImageMapToColors>::New();
	colorMap->SetLookupTable(colorTable);
	colorMap->SetInputConnection(reslice->GetOutputPort());
	colorMap->Update();

	vtkSmartPointer<vtkImageActor> imgActor =
		vtkSmartPointer<vtkImageActor>::New();
	imgActor->SetInputData(colorMap->GetOutput());
	imgActor->Update();

	vtkSmartPointer<vtkRenderer> renderer =
		vtkSmartPointer<vtkRenderer>::New();
	renderer->AddActor(imgActor);
	renderer->SetBackground(.4, .5, .6);

	vtkSmartPointer<vtkRenderWindow> renderWindow =
		vtkSmartPointer<vtkRenderWindow>::New();
	renderWindow->SetSize(500, 500);
	renderWindow->AddRenderer(renderer);

	vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	vtkSmartPointer<vtkInteractorStyleImage> imagestyle =
		vtkSmartPointer<vtkInteractorStyleImage>::New();

	renderWindowInteractor->SetInteractorStyle(imagestyle);
	renderWindowInteractor->SetRenderWindow(renderWindow);
	renderWindowInteractor->Initialize();
	//****************建立 观察者-命令 模式****************//
	vtkSmartPointer<vtkImageInteractionCallback> callback =
		vtkSmartPointer<vtkImageInteractionCallback>::New();
	callback->SetImageReslice(reslice);
	callback->SetInteractor(renderWindowInteractor);
	callback->SetImageResliceColorMap(colorMap);

	imagestyle->AddObserver(vtkCommand::MouseMoveEvent, callback);
	imagestyle->AddObserver(vtkCommand::LeftButtonPressEvent, callback);
	imagestyle->AddObserver(vtkCommand::LeftButtonReleaseEvent, callback);

	renderWindowInteractor->Start();

	return 0;
}

运行结果

三维图像切片交互提取（回调函数、观察者-命令模式）

这里要特别注意！东灵那本书上的代码用的VTK版本比较旧，如果直接用那个古早代码，只能显示一张图像，无法实现交互功能。新版vtk需要在vtkImageInteractionCallback类的定义里增加vtkImageMapToColors的更新的相关函数才可以正常切换切片。

void SetImageResliceColorMap(vtkImageMapToColors* colorMap)
{
	this->colorMap = colorMap;
}
vtkImageMapToColors* GetImageResliceColorMap()
{
	return this->colorMap;

callback->SetImageReslice(reslice);
callback->SetInteractor(renderWindowInteractor);
callback->SetImageResliceColorMap(colorMap);

梦里花乡

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录