ITK VTK 读取显示mhd文件（c++）

找了好多博客，也没有找到读取显示mhd文件的教程，然后自己就瞎试试了几次，没想到成了。实现了滑动鼠标显示各层切片。

#include <vtkSmartPointer.h>
#include <vtkImageViewer2.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include "vtkRenderWindowInteractor.h"
#include "vtkAutoInit.h" 
#include"vtkInteractorStyleImage.h"
#include"vtkImageViewer2.h"
#include"vtkTextMapper.h"
#include"vtkRenderWindowInteractor.h"
#include"vtkObjectFactory.h"
#include"vtkSmartPointer.h"
#include"vtkImageFlip.h"
#include"vtkTextActor.h"
#include"vtkTextProperty.h"
#include"vtkRenderer.h"
#include "vtkJPEGReader.h"
#include"vtkRenderWindow.h"
#include"vtkCommonCoreModule.h"
#include"vtkPolyData.h"
#include "vtkDataSet.h"
#include "vtkimageData.h"
#include "vtkStructuredData.h" 
#include"vtkCell.h"
#include"vtkIdList.h"
#include"vtkLine.h"
#include"vtkPolyDataMapper.h"
#include"vtkActor.h"
#include"vtkProperty.h"
VTK_MODULE_INIT(vtkRenderingOpenGL2); // VTK was built with vtkRenderingOpenGL2
VTK_MODULE_INIT(vtkInteractionStyle);

#include<iostream>
#include <vector>
#include <windows.h>
#include <string>
#include <sstream>
#include <array>
#include<cmath>
using namespace std;


#include "itkVTKImageToImageFilter.h"
#include "itkImageToVTKImageFilter.h"
#include "itkImage.h"
#include "itkMetaImageIO.h"
#include"itkImageFileReader.h"
#include"itkImageFileWriter.h"


class  StatusMessage
{
public:
	static std::string Format(int slice, int maxSlice)
	{
		std::stringstream tmp;
		tmp << "Slice Number " << slice + 1 << "/" << maxSlice + 1;
		return tmp.str();
	}

};

class myvtkInteractorStyleImage : public vtkInteractorStyleImage
{
public:
	static myvtkInteractorStyleImage* New();
	vtkTypeMacro(myvtkInteractorStyleImage, vtkInteractorStyleImage);

protected:
	vtkImageViewer2* _ImageViewer;
	vtkTextMapper* _StatusMapper;
	int _Slice;
	int _MinSlice;
	int _MaxSlice;

public:
	void SetImageViewer(vtkImageViewer2* imageViewer) {
		_ImageViewer = imageViewer;
		_MinSlice = imageViewer->GetSliceMin();
		_MaxSlice = imageViewer->GetSliceMax();
		_Slice = _MinSlice;
		cout << "Slice: Min = " << _MinSlice << ", Max = " << _MaxSlice << endl;
	}

	void SetStatusMapper(vtkTextMapper* statusMapper)
	{
		_StatusMapper = statusMapper;
	}

protected:
	void MoveSliceForward()
	{
		if (_Slice < _MaxSlice)
		{
			_Slice += 1;
			cout << "MoveSliceForward::Slice = " << _Slice << endl;
			_ImageViewer->SetSlice(_Slice);
			std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
			_StatusMapper->SetInput(msg.c_str());
			_ImageViewer->Render();
		}
	}

	void MoveSliceBackward()
	{
		if (_Slice > _MinSlice)
		{
			_Slice -= 1;
			cout << "MoveSliceBackward::Slice = " << _Slice << endl;
			_ImageViewer->SetSlice(_Slice);
			std::string msg = StatusMessage::Format(_Slice, _MaxSlice);
			_StatusMapper->SetInput(msg.c_str());
			_ImageViewer->Render();
		}
	}

	virtual void OnKeyDown()
	{
		std::string key = this->GetInteractor()->GetKeySym();
		if (key.compare("Up") == 0)
			MoveSliceForward();
		else if (key.compare("Down") == 0)
		{
			MoveSliceBackward();
		}

		vtkInteractorStyleImage::OnKeyDown();
	}

	virtual void OnMouseWheelForward()
	{
		MoveSliceForward();
	}

	virtual void OnMouseWheelBackward()
	{
		if (_Slice > _MinSlice)
			MoveSliceBackward();
	}
};

vtkStandardNewMacro(myvtkInteractorStyleImage);

int main(int argc, char* argv[])

{

	typedef signed short PixelType;
	const unsigned int Dimension = 3;
	typedef itk::Image< PixelType, Dimension > ImageType;

	typedef itk::ImageFileReader<ImageType> ImageReaderType;
	ImageReaderType::Pointer reader = ImageReaderType::New();

	typedef itk::MetaImageIO             ImageIOType;
	ImageIOType::Pointer metaIO = ImageIOType::New();
	reader->SetImageIO(metaIO);
	reader->SetFileName("H:\\jpg\\Case23.mhd");
	try
	{
		reader->Update();
	}
	catch (itk::ExceptionObject &excp)
	{
		std::cerr << "Exception thrown while writing the image" << std::endl;
		std::cerr << excp << std::endl;
		system("pause");
		return EXIT_FAILURE;
	}


	typedef itk::ImageToVTKImageFilter<ImageType> ITKTOVTKFilterType;
	ITKTOVTKFilterType::Pointer VTKFilter = ITKTOVTKFilterType::New();
	VTKFilter->SetInput(reader->GetOutput());
	VTKFilter->UpdateLargestPossibleRegion();
	VTKFilter->Update();

	vtkSmartPointer<vtkImageFlip> flip = vtkSmartPointer<vtkImageFlip>::New();
	flip->SetInputData(VTKFilter->GetOutput());
	flip->SetFilteredAxes(1);
	flip->Update();

	vtkSmartPointer<vtkImageData> vtkimage = flip->GetOutput();

	vtkSmartPointer<vtkImageViewer2> imageViewer = vtkSmartPointer<vtkImageViewer2>::New();
	imageViewer->SetInputData(vtkimage);
	vtkSmartPointer<vtkTextProperty> sliceTextProp = vtkSmartPointer<vtkTextProperty>::New();
	sliceTextProp->SetFontFamilyToCourier();
	sliceTextProp->SetFontSize(20);
	sliceTextProp->SetVerticalJustificationToBottom();
	sliceTextProp->SetJustificationToLeft();
	vtkSmartPointer<vtkTextMapper> sliceTextMapper = vtkSmartPointer<vtkTextMapper>::New();
	std::string msg = StatusMessage::Format(imageViewer->GetSliceMin(), imageViewer->GetSliceMax());
	sliceTextMapper->SetInput(msg.c_str());
	sliceTextMapper->SetTextProperty(sliceTextProp);
	vtkSmartPointer<vtkActor2D> sliceTextActor = vtkSmartPointer<vtkTextActor>::New();
	sliceTextActor->SetMapper(sliceTextMapper);
	sliceTextActor->SetPosition(15, 10);
	vtkSmartPointer<vtkTextProperty> usageTextProp = vtkSmartPointer<vtkTextProperty>::New();
	usageTextProp->SetFontFamilyToCourier();
	usageTextProp->SetFontSize(14);
	usageTextProp->SetVerticalJustificationToTop();
	usageTextProp->SetJustificationToLeft();


	vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
	vtkSmartPointer<myvtkInteractorStyleImage> myInteractorStyle = vtkSmartPointer<myvtkInteractorStyleImage>::New();
	myInteractorStyle->SetImageViewer(imageViewer);
	myInteractorStyle->SetStatusMapper(sliceTextMapper);
	imageViewer->SetupInteractor(renderWindowInteractor);
	renderWindowInteractor->SetInteractorStyle(myInteractorStyle);
	imageViewer->GetRenderer()->AddActor2D(sliceTextActor);

	imageViewer->GetRenderWindow();
	imageViewer->Render();
	imageViewer->GetRenderer()->ResetCamera();
	renderWindowInteractor->Start();

	return 0;
	

}