练习：VTK 四视图显示（三视图+三正交切片）

版本：vtk9.2.0+vs2022

主要功能如下：根据三正交切片的位置联动显示其他窗口切片，在三正交切片调整窗宽窗位后其他三视图同步窗宽窗位，并显示切片序号

#include <vtkActor.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkObjectFactory.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
// headers needed for this example
#include <vtkActor2D.h>
#include <vtkDICOMImageReader.h>
#include <vtkImageViewer2.h>
#include <vtkInteractorStyleImage.h>
#include <vtkTextMapper.h>
#include <vtkTextProperty.h>
#include<vtkSmartPointer.h>
#include <vtkLookupTable.h> 
#include <vtkImageMapToColors.h>  
#include <vtkImageActor.h>
#include<vtkScalarBarWidget.h>
#include<vtkScalarBarActor.h>
#include <vtkAxesActor.h>
#include <vtkImageData.h>
#include <vtkImagePlaneWidget.h>
#include <vtkCellPicker.h>
#include <vtkProperty.h>
#include <vtkCamera.h>
#include <vtkActor.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkObjectFactory.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
// headers needed for this example
#include <vtkOrientationMarkerWidget.h>
#include <vtkDICOMImageReader.h>
#include <vtkImageReader2.h>
#include <vtkImageViewer2.h>
#include <vtkInteractorStyleImage.h>
#include <vtkTextMapper.h>
#include<vtkImageFlip.h>
#include<vtkImageMapper3D.h>
#include<vtkTextActor.h>
// needed to easily convert int to std::string
#include <sstream>
#include<vtkImageMapToWindowLevelColors.h>
#include "vtkAutoInit.h" 
VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2)
#include<vtkCommand.h>
#include <vtkImagePlaneWidget.h>
#include<vtkImageMapToWindowLevelColors.h>
class vtkMyCall : public vtkCommand  //更新三视图中的x,y,z标签显示并使三视图的窗宽窗位同三正交切片保持一致
{
public:
    static vtkMyCall* New()
    {
        return new vtkMyCall;
    }
    void Execute(vtkObject* caller, unsigned long vtkNotUsed(event), void* callData)
    {

        vtkImagePlaneWidget* self = reinterpret_cast<vtkImagePlaneWidget*>(caller);
        pos[0] = WidgetX->GetSliceIndex();//获取三正交切片序号
        pos[1] = WidgetY->GetSliceIndex();
        pos[2] = WidgetZ->GetSliceIndex();
        std::string strx = "x:" + std::to_string(pos[0]);
        std::string stry = "y:" + std::to_string(pos[1]);
        std::string strz = "z:" + std::to_string(pos[2]);
        textActorx->SetInput(strx.c_str());      //显示序号文本在三视图窗口上
        textActory->SetInput(stry.c_str());
        textActorz->SetInput(strz.c_str());



    }
    vtkMyCall() :WidgetX(0), WidgetY(0), WidgetZ(0) {}
    vtkImagePlaneWidget* WidgetX;
    vtkImagePlaneWidget* WidgetY;
    vtkImagePlaneWidget* WidgetZ;
    int* pos;

    vtkSmartPointer<vtkTextActor> textActorx;
    vtkSmartPointer<vtkTextActor> textActory;
    vtkSmartPointer<vtkTextActor> textActorz;

};
#include <vtkImagePlaneWidget.h>
#include<vtkImageMapToWindowLevelColors.h>
class vtkMyCallback : public vtkCommand //在三正交切片中同步三个切片的窗宽窗位
{
public:
    static vtkMyCallback* New()
    {
        return new vtkMyCallback;
    }
    void Execute(vtkObject* caller, unsigned long vtkNotUsed(event), void* callData)
    {

        vtkImagePlaneWidget* self = reinterpret_cast<vtkImagePlaneWidget*>(caller);
        if (!self) return;
        double* wl = static_cast<double*>(callData);
        if (self == this->WidgetX)
        {
            this->WidgetY->SetWindowLevel(wl[0], wl[1]);
            this->WidgetZ->SetWindowLevel(wl[0], wl[1]);

        }
        else if (self == this->WidgetY)
        {
            this->WidgetX->SetWindowLevel(wl[0], wl[1]);
            this->WidgetZ->SetWindowLevel(wl[0], wl[1]);
        }
        else if (self == this->WidgetZ)
        {
            this->WidgetX->SetWindowLevel(wl[0], wl[1]);
            this->WidgetY->SetWindowLevel(wl[0], wl[1]);
        }
        windowLevelx->SetWindow(wl[0]);
        windowLevelx->SetLevel(wl[1]);
        windowLevely->SetWindow(wl[0]);
        windowLevely->SetLevel(wl[1]);
        windowLevelz->SetWindow(wl[0]);
        windowLevelz->SetLevel(wl[1]);
        windowLevelx->Update();
        windowLevely->Update();
        windowLevelz->Update();
    }
    vtkMyCallback() :WidgetX(0), WidgetY(0), WidgetZ(0) {}
    vtkImagePlaneWidget* WidgetX;
    vtkImagePlaneWidget* WidgetY;
    vtkImagePlaneWidget* WidgetZ;
    vtkImageMapToWindowLevelColors* windowLevelx;
    vtkImageMapToWindowLevelColors* windowLevely;
    vtkImageMapToWindowLevelColors* windowLevelz;


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

{

        vtkNew<vtkNamedColors> colors;
        vtkSmartPointer <vtkDICOMImageReader> reader1 = vtkSmartPointer <vtkDICOMImageReader>::New();
        // Verify input arguments
        vtkSmartPointer<vtkImageFlip> reader;
        vtkSmartPointer <vtkImagePlaneWidget> imagePlaneX;
        vtkSmartPointer <vtkImagePlaneWidget> imagePlaneY;
        vtkSmartPointer <vtkImagePlaneWidget> imagePlaneZ;
        vtkSmartPointer <vtkOrientationMarkerWidget> orientationWidget;
        reader1->SetDirectoryName("D:\\Final_HW\\MainWidget\\CorCTA  0.75  B25f  Diastole 65%-unzip");//dicom序列文件夹位置
        reader1->Update();
        //std::string folder = path;
        // Read all the DICOM files in the specified directory.
        reader = vtkSmartPointer<vtkImageFlip>::New();;
        reader->SetInputData(reader1->GetOutput());
        reader->Update();

        // Get the dimensions of the image.
        int dimensions[3] = { 0,0,0 };
        reader->GetOutput()->GetDimensions(dimensions);
        //三正交切片的初始化
        //Init the vtkImagePlaneWidget for the x、y、z orientation.
        imagePlaneX = vtkSmartPointer<vtkImagePlaneWidget>::New();
        imagePlaneY = vtkSmartPointer<vtkImagePlaneWidget>::New();
        imagePlaneZ = vtkSmartPointer<vtkImagePlaneWidget>::New();
        orientationWidget = vtkSmartPointer<vtkOrientationMarkerWidget>::New();
        //Init the picker for the vtkImagePlaneWidget.
        vtkNew<vtkCellPicker> picker;

        //Set the property of the imagePlane.
        imagePlaneX->SetInputConnection(reader->GetOutputPort());
        //this->imagePlaneX->SetInputData(reader->GetOutput());
        imagePlaneX->SetPicker(picker);
        imagePlaneX->RestrictPlaneToVolumeOn();
        imagePlaneX->GetMarginProperty()->SetOpacity(0);
        imagePlaneX->SetMarginSizeX(0);
        imagePlaneX->SetMarginSizeY(0);
        imagePlaneX->DisplayTextOn();
        imagePlaneX->SetResliceInterpolateToLinear();
        imagePlaneX->SetPlaneOrientationToXAxes();
        imagePlaneX->SetWindowLevel(800, 400, 0);//设置窗宽窗位
        imagePlaneX->SetSliceIndex(dimensions[0] / 2);//初始化切片位置
        imagePlaneX->SetLeftButtonAction(1);
        imagePlaneX->SetMiddleButtonAction(0);
        imagePlaneX->GetTexturePlaneProperty()->SetOpacity(1);

        imagePlaneY->SetInputConnection(reader->GetOutputPort());
        //this->imagePlaneY->SetInputData(reader->GetOutput());
        imagePlaneY->SetPicker(picker);
        imagePlaneY->RestrictPlaneToVolumeOn();
        imagePlaneY->GetMarginProperty()->SetOpacity(0);
        imagePlaneY->SetMarginSizeX(0);
        imagePlaneY->SetMarginSizeY(0);
        imagePlaneY->DisplayTextOn();
        imagePlaneY->SetResliceInterpolateToLinear();
        imagePlaneY->SetPlaneOrientationToYAxes();
        imagePlaneY->SetWindowLevel(800, 400, 0);
        imagePlaneY->SetSliceIndex(dimensions[1] / 2);//初始化切片位置
        imagePlaneY->SetLeftButtonAction(1);
        imagePlaneY->SetMiddleButtonAction(0);
        imagePlaneY->GetTexturePlaneProperty()->SetOpacity(1);

        imagePlaneZ->SetInputConnection(reader->GetOutputPort());
        //this->imagePlaneZ->SetInputData(reader->GetOutput());
        imagePlaneZ->SetPicker(picker);
        imagePlaneZ->RestrictPlaneToVolumeOn();
        imagePlaneZ->GetMarginProperty()->SetOpacity(0);
        imagePlaneZ->SetMarginSizeX(0);
        imagePlaneZ->SetMarginSizeY(0);
        imagePlaneZ->DisplayTextOn();
        imagePlaneZ->SetResliceInterpolateToLinear();
        imagePlaneZ->SetPlaneOrientationToZAxes();
        imagePlaneZ->SetWindowLevel(800, 400, 0);
        imagePlaneZ->SetSliceIndex(dimensions[2] / 2);//初始化切片位置
        imagePlaneZ->SetLeftButtonAction(1);
        imagePlaneZ->SetMiddleButtonAction(0);
        imagePlaneZ->GetTexturePlaneProperty()->SetOpacity(1);

        // initialize rendering and interaction
        vtkNew<vtkRenderer> renderer;
        vtkNew<vtkRenderWindow> renderWindow;
        renderWindow->AddRenderer(renderer);
        renderWindow->SetSize(800, 800);
        renderWindow->SetWindowName("3D");

        vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
        renderWindowInteractor->SetRenderWindow(renderWindow);

        vtkNew<vtkInteractorStyleTrackballCamera> style;
        renderWindowInteractor->SetInteractorStyle(style);
        
        // vtkOrientationMarkerWidget
        vtkNew<vtkAxesActor> iconActor;//xyz轴标

        orientationWidget->SetOutlineColor(0.9300, 0.5700, 0.1300);//设置rgb颜色
        orientationWidget->SetOrientationMarker(iconActor);
        orientationWidget->SetInteractor(renderWindowInteractor);
        orientationWidget->SetViewport(0.0, 0.0, 0.1, 0.1);
        orientationWidget->SetEnabled(1);
        orientationWidget->InteractiveOn();
        imagePlaneX->SetDefaultRenderer(renderer);//三正交切片，其他三视图分别设置四个renderer 以显示在四个位置
        imagePlaneY->SetDefaultRenderer(renderer);
        imagePlaneZ->SetDefaultRenderer(renderer);
        vtkNew<vtkRenderer> rendererx;
        vtkNew<vtkRenderer> renderery;
        vtkNew<vtkRenderer> rendererz;
        vtkSmartPointer<vtkImageActor> ImageActorX = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> ImageActorY = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> ImageActorZ = vtkSmartPointer<vtkImageActor>::New();
        vtkImageMapToWindowLevelColors* windowLevelx = vtkImageMapToWindowLevelColors::New();
        vtkImageMapToWindowLevelColors* windowLevely = vtkImageMapToWindowLevelColors::New();
        vtkImageMapToWindowLevelColors* windowLevelz = vtkImageMapToWindowLevelColors::New();
        vtkSmartPointer<vtkTextActor> textActorx = vtkSmartPointer<vtkTextActor>::New();
        vtkSmartPointer<vtkTextActor> textActory = vtkSmartPointer<vtkTextActor>::New();
        vtkSmartPointer<vtkTextActor> textActorz = vtkSmartPointer<vtkTextActor>::New();
        std::string strx = "x:" + std::to_string(imagePlaneX->GetSliceIndex());
        std::string stry = "y:" + std::to_string(imagePlaneY->GetSliceIndex());
        std::string strz = "z:" + std::to_string(imagePlaneZ->GetSliceIndex());
        textActorx->SetInput(strx.c_str());
        textActorx->GetTextProperty()->SetFontSize(24);
        textActorx->GetTextProperty()->SetColor(1, 1, 1);
        rendererx->AddActor(textActorx);
        textActory->SetInput(stry.c_str());
        textActory->GetTextProperty()->SetFontSize(24);
        textActory->GetTextProperty()->SetColor(1, 1, 1);
        renderery->AddActor(textActory);
        textActorz->SetInput(strx.c_str());
        textActorz->GetTextProperty()->SetFontSize(24);
        textActorz->GetTextProperty()->SetColor(1, 1, 1);
        rendererz->AddActor(textActorz);

        windowLevelx->SetInputConnection(imagePlaneX->GetReslice()->GetOutputPort());
        windowLevelx->SetLevel(100);//初始化窗位
        windowLevelx->SetWindow(200);//窗宽
        windowLevely->SetInputConnection(imagePlaneY->GetReslice()->GetOutputPort());
        windowLevely->SetLevel(100);
        windowLevely->SetWindow(200);
        windowLevelz->SetInputConnection(imagePlaneZ->GetReslice()->GetOutputPort());
        windowLevelz->SetLevel(100);
        windowLevelz->SetWindow(200);
        ImageActorX->GetMapper()->SetInputConnection(windowLevelx->GetOutputPort());
        ImageActorY->GetMapper()->SetInputConnection(windowLevely->GetOutputPort());
        ImageActorZ->GetMapper()->SetInputConnection(windowLevelz->GetOutputPort());

        rendererx->AddActor(ImageActorX);
        renderery->AddActor(ImageActorY);
        rendererz->AddActor(ImageActorZ);
        renderWindow->AddRenderer(renderer);
        rendererx->SetBackground(0.1, 0.2, 0.4);//背景RGB颜色、、
        renderery->SetBackground(0.2, 0.4, 0.1);
        rendererz->SetBackground(0.4, 0.2, 0.1);
        //rendererx->SetViewPort();
        rendererx->SetViewport(0, 0, 0.5, 0.5);//四个 renderer显示在四个角
        renderery->SetViewport(0.5, 0, 1, 0.5);
        rendererz->SetViewport(0.5, 0.5, 1, 1);
        renderer->SetViewport(0, 0.5, 0.5, 1);

        renderWindow->AddRenderer(rendererx);
        renderWindow->AddRenderer(renderery);
        renderWindow->AddRenderer(rendererz);
        //Render
        int pos[3];
        pos[0] = imagePlaneX->GetSliceIndex();//获取三正交切片的切片序号
        pos[1] = imagePlaneY->GetSliceIndex();
        pos[2] = imagePlaneZ->GetSliceIndex();

        vtkSmartPointer< vtkMyCall > mycall = vtkSmartPointer< vtkMyCall>::New();
        mycall->pos = pos;
        mycall->WidgetX = imagePlaneX;
        mycall->WidgetY = imagePlaneY;
        mycall->WidgetZ = imagePlaneZ;
        mycall->textActorx = textActorx;
        mycall->textActory = textActory;
        mycall->textActorz = textActorz;
        renderWindowInteractor->AddObserver(vtkCommand::MouseMoveEvent, mycall);
        renderWindow->Render();
        imagePlaneX->SetInteractor(renderWindowInteractor);
        imagePlaneY->SetInteractor(renderWindowInteractor);
        imagePlaneZ->SetInteractor(renderWindowInteractor);
        vtkSmartPointer< vtkMyCallback > cbk = vtkSmartPointer< vtkMyCallback>::New();
        cbk->windowLevelx = windowLevelx;
        cbk->windowLevely = windowLevely;
        cbk->windowLevelz = windowLevelz;
        cbk->WidgetX = imagePlaneX;
        cbk->WidgetY = imagePlaneY;
        cbk->WidgetZ = imagePlaneZ;
        // rendererx->AddObserver(vtkCommand::MouseMoveEvent, cbk);
        // renderery->AddObserver(vtkCommand::MouseMoveEvent, cbk);
        // rendererz->AddObserver(vtkCommand::MouseMoveEvent, cbk);
        imagePlaneX->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
        imagePlaneY->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
        imagePlaneZ->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
        renderWindowInteractor->Initialize();
        imagePlaneX->On();
        imagePlaneY->On();
        imagePlaneZ->On();
        renderer->ResetCamera();

        // Begin mouse interaction
        renderWindowInteractor->Start();
    

}

效果如下：

拖动切片，改变窗宽窗位：