使用VTK实现四视图渲染dcm序列化数据集 – 三郎君的日常
三郎君的日常

C++ / VTK / 医疗 · 2024年4月29日 0

使用VTK实现四视图渲染dcm序列化数据集

使用 VTK（Visualization Toolkit）库来可视化 DICOM 图像。

  1. 主要作用：
    • 加载 DICOM 图像序列。
    • 创建四个渲染器，其中三个用于显示不同方向的图像平面，第四个用于显示整个数据集的轮廓。
    • 在三个方向上创建交互式图像平面小部件，允许用户在图像上进行切片浏览。
    • 使用三个交互式小部件和一个鼠标交互器来控制渲染窗口的交互行为。
  2. 实现逻辑：
    • 首先，通过 vtkDICOMImageReader 类加载 DICOM 图像序列。
    • 然后，创建一个渲染窗口和四个渲染器，其中一个用于显示轮廓，另外三个用于显示不同方向的图像平面。
    • 通过 vtkImagePlaneWidget 类创建三个交互式图像平面小部件，用于在三个方向上显示切片。
    • 创建一个用于处理交互事件的自定义回调类 vtkResliceCursorCallback。该类用于确保在交互操作期间三个图像平面之间的同步更新。
    • 创建一个用于绘制切片线的 vtkResliceCursorWidget 和 vtkResliceCursorLineRepresentation。
    • 设置渲染器的背景颜色，并将轮廓和图像平面添加到相应的渲染器中。
    • 设置交互器和交互样式，启动交互事件循环以等待用户交互。

渲染逻辑主要涉及以下几个方面：

  1. 渲染器和渲染窗口的创建：
    • 通过 vtkRenderer 类创建四个渲染器对象，其中三个用于显示图像平面，一个用于显示轮廓。
    • 使用 vtkRenderWindow 类创建一个渲染窗口对象，并将四个渲染器添加到该窗口中。
  2. DICOM 图像加载和数据处理：
    • 使用 vtkDICOMImageReader 类加载 DICOM 图像序列。
    • 创建一个 vtkPolyDataMapper 对象，并将 DICOM 图像数据连接到该 Mapper 上。
  3. 交互式图像平面小部件的创建和配置：
    • 使用 vtkImagePlaneWidget 类创建三个交互式图像平面小部件，分别用于在 X、Y、Z 方向上显示图像切片。
    • 针对每个图像平面小部件，设置交互器、Picker、PlaneProperty、TexturePlaneProperty 等属性，并将其连接到 DICOM 图像数据上。
  4. 切片线和切片线表示的创建和配置：
    • 使用 vtkResliceCursorWidget 和 vtkResliceCursorLineRepresentation 类创建三个切片线小部件和表示对象。
    • 设置每个切片线的默认渲染器、切片线的属性以及关联的 DICOM 图像数据。
  5. 渲染器的设置和布局：
    • 为每个渲染器设置不同的背景颜色。
    • 将轮廓渲染器中的轮廓 Actor 添加到相应的渲染器中。
    • 配置四个渲染器的视口，以便在渲染窗口中正确布局它们。
  6. 交互器和交互样式的设置：
    • 使用 vtkRenderWindowInteractor 类创建一个交互器对象，并将其连接到渲染窗口中。
    • 创建一个 vtkCellPicker 对象，用于捕获用户交互操作。
    • 使用 vtkInteractorStyleImage 类来定义交互样式，使用户能够在图像上执行切片浏览操作。
  7. 事件循环的启动：
    • 启动交互器的事件循环，等待用户的交互操作。
    • 当用户与图像交互时，根据用户的操作更新图像平面的显示、切片线的位置以及整个渲染窗口的视图。
#include "vtkSmartPointer.h"
#include "vtkActor.h"
#include "vtkCamera.h"
#include "vtkCellPicker.h"
#include "vtkCommand.h"
#include "vtkImageActor.h"
#include "vtkImageReslice.h"
#include "vtkInteractorStyleImage.h"
#include "vtkImageMapToColors.h"
#include "vtkImagePlaneWidget.h"
#include "vtkImageReader.h"
#include "vtkInteractorEventRecorder.h"
#include "vtkLookupTable.h"
#include "vtkOutlineFilter.h"
#include "vtkDICOMImageReader.h"
#include "vtkPolyDataMapper.h"
#include "vtkProperty.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRenderer.h"
#include "vtkImageData.h"
#include "vtkPointData.h"
#include "vtkPlaneSource.h"
#include "vtkPlane.h"
#include "vtkResliceCursorActor.h"
#include "vtkResliceCursorPolyDataAlgorithm.h"
#include "vtkResliceCursor.h"
#include "vtkResliceCursorWidget.h"
#include "vtkResliceCursorLineRepresentation.h"
#include "vtkBiDimensionalWidget.h"
#include"vtkAutoInit.h"
#include"vtkAxesActor.h"
#include"vtkTransform.h"
#include"vtkTextActor.h"
#include"vtkProperty2D.h"

VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);

class vtkResliceCursorCallback : public vtkCommand
{
public:
    static vtkResliceCursorCallback* New()
    {
        return new vtkResliceCursorCallback;
    }
    void Execute(vtkObject* caller, unsigned long, void* callData) override
    {
        vtkImagePlaneWidget* ipw = dynamic_cast<vtkImagePlaneWidget*>(caller);
        if (ipw)
        {
            double* wl = static_cast<double*>(callData);

            if (ipw == this->IPW[0])
            {
                this->IPW[1]->SetWindowLevel(wl[0], wl[1], 1);
                this->IPW[2]->SetWindowLevel(wl[0], wl[1], 1);
            }
            else if (ipw == this->IPW[1])
            {
                this->IPW[0]->SetWindowLevel(wl[0], wl[1], 1);
                this->IPW[2]->SetWindowLevel(wl[0], wl[1], 1);
            }
            else if (ipw == this->IPW[2])
            {
                this->IPW[0]->SetWindowLevel(wl[0], wl[1], 1);
                this->IPW[1]->SetWindowLevel(wl[0], wl[1], 1);
            }
        }
        vtkResliceCursorWidget* rcw = dynamic_cast<vtkResliceCursorWidget*>(caller);
        if (rcw)
        {
            vtkResliceCursorLineRepresentation* rep = dynamic_cast<vtkResliceCursorLineRepresentation*>(rcw->GetRepresentation());
            vtkResliceCursor* rc = rep->GetResliceCursorActor()->GetCursorAlgorithm()->GetResliceCursor();
            for (int i = 0; i < 3; i++)
            {
                vtkPlaneSource* ps = static_cast<vtkPlaneSource*>(this->IPW[i]->GetPolyDataAlgorithm());
                ps->SetNormal(rc->GetPlane(i)->GetNormal());
                ps->SetCenter(rc->GetPlane(i)->GetOrigin());
                this->IPW[i]->UpdatePlacement();
            }
        }
        this->RCW[0]->Render();
    }
    vtkResliceCursorCallback() {}
    vtkImagePlaneWidget* IPW[3];
    vtkResliceCursorWidget* RCW[3];
};

int main()
{
    vtkSmartPointer<vtkDICOMImageReader> reader = vtkSmartPointer<vtkDICOMImageReader>::New();
    reader->SetDirectoryName("C:/Users/DeepA/Desktop/CTA_Cardio");
    reader->Update();
   
    vtkSmartPointer<vtkPolyDataMapper> outlineMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    outlineMapper->SetInputConnection(reader->GetOutputPort());

    vtkSmartPointer<vtkActor> outlineActor = vtkSmartPointer<vtkActor>::New();
    outlineActor->SetMapper(outlineMapper);

    vtkSmartPointer<vtkRenderer> ren[4];
    vtkSmartPointer<vtkRenderWindow> renWin = vtkSmartPointer<vtkRenderWindow>::New();
    renWin->SetMultiSamples(0);

    for (int i = 0; i < 4; i++)
    {
        ren[i] = vtkSmartPointer<vtkRenderer>::New();
        renWin->AddRenderer(ren[i]);
    }

    vtkSmartPointer<vtkRenderWindowInteractor> iren = vtkSmartPointer<vtkRenderWindowInteractor>::New();
    iren->SetRenderWindow(renWin);

    vtkSmartPointer<vtkCellPicker> picker = vtkSmartPointer<vtkCellPicker>::New();
    picker->SetTolerance(0.005);

    vtkSmartPointer<vtkProperty> ipwProp = vtkSmartPointer<vtkProperty>::New();

    vtkSmartPointer<vtkImagePlaneWidget> planeWidget[3];
    int imageDims[3];
    reader->GetOutput()->GetDimensions(imageDims);

    for (int i = 0; i < 3; i++)
    {
        planeWidget[i] = vtkSmartPointer<vtkImagePlaneWidget>::New();
        planeWidget[i]->SetInteractor(iren);
        planeWidget[i]->SetPicker(picker);
        planeWidget[i]->RestrictPlaneToVolumeOn();
        double color[3] = { 0, 0, 0 };
        color[i] = 1;
        planeWidget[i]->GetPlaneProperty()->SetColor(color);
        planeWidget[i]->SetTexturePlaneProperty(ipwProp);
        planeWidget[i]->TextureInterpolateOff();
        planeWidget[i]->SetResliceInterpolateToLinear();
        planeWidget[i]->SetInputConnection(reader->GetOutputPort());
        planeWidget[i]->SetPlaneOrientation(i);
        planeWidget[i]->SetSliceIndex(imageDims[i] / 2);
        planeWidget[i]->DisplayTextOn();
        planeWidget[i]->SetDefaultRenderer(ren[3]);
        planeWidget[i]->SetWindowLevel(1358, -27);
        planeWidget[i]->On();
        planeWidget[i]->InteractionOn();
    }

    planeWidget[1]->SetLookupTable(planeWidget[0]->GetLookupTable());
    planeWidget[2]->SetLookupTable(planeWidget[0]->GetLookupTable());

    vtkSmartPointer<vtkResliceCursorCallback> cbk = vtkSmartPointer<vtkResliceCursorCallback>::New();
    vtkSmartPointer< vtkResliceCursor > resliceCursor = vtkSmartPointer< vtkResliceCursor >::New();
    resliceCursor->SetCenter(reader->GetOutput()->GetCenter());
    resliceCursor->SetThickMode(0);
    resliceCursor->SetThickness(10, 10, 10);
    resliceCursor->SetImage(reader->GetOutput());

    vtkSmartPointer< vtkResliceCursorWidget > resliceCursorWidget[3];
    vtkSmartPointer< vtkResliceCursorLineRepresentation > resliceCursorRep[3];

    double viewUp[3][3] = { { 0, 0, -1 }, { 0, 0, 1 }, { 0, 1, 0 } };
    for (int i = 0; i < 3; i++)
    {
        resliceCursorWidget[i] = vtkSmartPointer< vtkResliceCursorWidget >::New();
        resliceCursorWidget[i]->SetInteractor(iren);

        resliceCursorRep[i] = vtkSmartPointer< vtkResliceCursorLineRepresentation >::New();
        resliceCursorWidget[i]->SetRepresentation(resliceCursorRep[i]);
        resliceCursorRep[i]->GetResliceCursorActor()->GetCursorAlgorithm()->SetResliceCursor(resliceCursor);
        resliceCursorRep[i]->GetResliceCursorActor()->GetCursorAlgorithm()->SetReslicePlaneNormal(i);

        const double minVal = reader->GetOutput()->GetScalarRange()[0];
        if (vtkImageReslice* reslice = vtkImageReslice::SafeDownCast(resliceCursorRep[i]->GetReslice()))
        {
            reslice->SetBackgroundColor(minVal, minVal, minVal, minVal);
        }

        resliceCursorWidget[i]->SetDefaultRenderer(ren[i]);
        resliceCursorWidget[i]->SetEnabled(1);

        ren[i]->GetActiveCamera()->SetFocalPoint(0, 0, 0);
        double camPos[3] = { 0, 0, 0 };
        camPos[i] = 1;
        ren[i]->GetActiveCamera()->SetPosition(camPos);
        ren[i]->GetActiveCamera()->ParallelProjectionOn();
        ren[i]->GetActiveCamera()->SetViewUp(viewUp[i][0], viewUp[i][1], viewUp[i][2]);
        ren[i]->ResetCamera();
        cbk->IPW[i] = planeWidget[i];
        cbk->RCW[i] = resliceCursorWidget[i];
        resliceCursorWidget[i]->AddObserver(vtkResliceCursorWidget::ResliceAxesChangedEvent, cbk);
        double range[2];
        reader->GetOutput()->GetScalarRange(range);
        resliceCursorRep[i]->SetWindowLevel(range[1] - range[0], (range[0] + range[1]) / 2.0);
        planeWidget[i]->SetWindowLevel(range[1] - range[0], (range[0] + range[1]) / 2.0);
        resliceCursorRep[i]->SetLookupTable(resliceCursorRep[0]->GetLookupTable());
        planeWidget[i]->GetColorMap()->SetLookupTable(resliceCursorRep[0]->GetLookupTable());
    }
  
    ren[0]->SetBackground(0.3, 0.1, 0.1);
    ren[1]->SetBackground(0.1, 0.3, 0.1);
    ren[2]->SetBackground(0.1, 0.1, 0.3);
    ren[3]->AddActor(outlineActor);
    ren[3]->SetBackground(0.1, 0.1, 0.1);
    renWin->SetSize(900, 900);

    ren[0]->SetViewport(0, 0, 0.5, 0.5);
    ren[1]->SetViewport(0.5, 0, 1, 0.5);
    ren[2]->SetViewport(0, 0.5, 0.5, 1);
    ren[3]->SetViewport(0.5, 0.5, 1, 1);
    renWin->Render();
      
    ren[3]->GetActiveCamera()->Elevation(110);
    ren[3]->GetActiveCamera()->SetViewUp(0, 0, -1);
    ren[3]->GetActiveCamera()->Azimuth(45);
    ren[3]->GetActiveCamera()->Dolly(1.15);
    ren[3]->ResetCameraClippingRange();

    vtkSmartPointer< vtkInteractorStyleImage > style = vtkSmartPointer< vtkInteractorStyleImage >::New();

    iren->SetInteractorStyle(style);
    iren->Initialize();
    iren->Start();
    return EXIT_SUCCESS;
}

交互逻辑主要包括以下几个方面：

  1. DICOM 图像加载和初始显示：
    • 通过 vtkDICOMImageReader 加载 DICOM 图像序列，并使用 vtkImagePlaneWidget 在三个方向上显示初始的切片图像。
  2. 切片浏览：
    • 用户可以通过交互操作，在 X、Y、Z 三个方向上浏览切片图像，通过移动图像平面小部件来改变切片位置。
  3. 窗宽窗位调整：
    • 用户可以通过交互操作，调整图像的窗宽和窗位。在回调函数中，当一个图像平面小部件的窗宽窗位发生变化时，其他平面小部件的窗宽窗位也会随之改变。
  4. 切片线位置同步：
    • 通过 vtkResliceCursorCallback 类中的回调函数，实现了切片线位置的同步。当一个切片线的位置发生变化时，其他切片线的位置也会相应地改变，以保持切片线的位置同步。
  5. 渲染器视图调整：
    • 在初始化阶段，通过设置不同渲染器的视口来实现多视图布局。在四个渲染器中，三个用于显示图像切片，一个用于显示图像的轮廓。
  6. 交互器设置：
    • 使用 vtkRenderWindowInteractor 类创建一个交互器对象，并使用 vtkInteractorStyleImage 类来定义交互样式。这使用户可以在图像上执行切片浏览操作。
  7. 事件处理：
    • 当用户与图像进行交互操作时，例如移动、缩放、旋转等，交互器会捕获相应的事件，并触发相应的操作。例如，当用户移动图像平面小部件时，会触发相应的切片浏览操作。
  8. 事件循环：
    • 启动交互器的事件循环，使程序能够持续响应用户的交互操作，直到用户退出。

您可能还喜欢...

发表评论