vtkImageData: 圖像彩色映射

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <vtkAutoInit.h>
VTK_MODULE_INIT(vtkRenderingOpenGL2)
VTK_MODULE_INIT(vtkInteractionStyle)
#include <vtkSmartPointer.h>
#include <vtkImageActor.h>
#include <vtkRenderer.h>
#include <vtkJPEGReader.h>
#include <vector>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
private slots:
    void openFileSlot();
private:
    std::vector<vtkSmartPointer<vtkRenderer>> grayRenders;
    std::vector<vtkSmartPointer<vtkRenderer>> colorChanelRenders;
    std::vector<vtkSmartPointer<vtkRenderer>> colorMapRenders;
    std::vector<vtkSmartPointer<vtkRenderer>> colorCompRenders;

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QDebug>
#include <QFileDialog>
#include <vtkRenderWindow.h>
#include <vtkPNGReader.h>
#include <vtkImageCanvasSource2D.h>
#include <vtkImageBlend.h>
#include <vtkImageData.h>
#include <vtkImageViewer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleImage.h>
#include <vtkImageStencil.h>
#include <vtkImageStencilData.h>
#include <vtkImageLuminance.h>
#include <vtkImageChangeInformation.h>
#include <vtkImageIterator.h>
#include <vtkImageExtractComponents.h>
#include <vtkLookupTable.h>
#include <vtkImageMapToColors.h>
#include <vtkImageAppendComponents.h>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    // grey color
    grayRenders.clear();
    for(int i = 0; i < 2; ++i)
    {
        vtkSmartPointer<vtkRenderer> render = vtkSmartPointer<vtkRenderer>::New();
        render->SetViewport(0.5 * i, 0, 0.5 * (i + 1), 0.25);
        render->SetBackground(1, 0, 0);
        grayRenders.push_back(render);
    }

    // color changle
    colorChanelRenders.clear();
    for(int i = 0; i < 4; ++i)
    {
        vtkSmartPointer<vtkRenderer> render = vtkSmartPointer<vtkRenderer>::New();
        render->SetViewport(0.25 * i, 0.25, 0.25 * (i + 1), 0.5);
        render->SetBackground(0, 1, 0);
        colorChanelRenders.push_back(render);
    }

    // color map
    colorMapRenders.clear();
    for(int i = 0; i < 2; ++i)
    {
        vtkSmartPointer<vtkRenderer> render = vtkSmartPointer<vtkRenderer>::New();
        render->SetViewport(0.5 * i, 0.5, 0.5 * (i + 1), 0.75);
        render->SetBackground(0, 0, 1);
        colorMapRenders.push_back(render);
    }

    // color Comp
    colorCompRenders.clear();
    for(int i = 0; i < 4; ++i)
    {
        vtkSmartPointer<vtkRenderer> render = vtkSmartPointer<vtkRenderer>::New();
        render->SetViewport(0.25 * i, 0.75, 0.25 * (i + 1), 1.0);
        render->SetBackground(1, 1, 0);
        colorCompRenders.push_back(render);
    }

    connect(ui->pushButton, SIGNAL(clicked(bool)), this, SLOT(openFileSlot()));
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::openFileSlot()
{
#if 1
    QString selectFilePath = QFileDialog::getOpenFileName(this, QString("選擇圖像文件"), QString(""), QString("圖像(*.jpg)"));
#else
    QString selectFilePath = QFileDialog::getOpenFileName(this, QString("選擇圖像文件"), QString(""), QString("圖像(*.png)"));
#endif
    if(selectFilePath.isEmpty())
    {
        ui->textBrowser->append("選擇圖像路徑爲空!");
        return ;
    }

    // 原始圖像
#if 1
    vtkSmartPointer<vtkJPEGReader> pJpegReader =  vtkSmartPointer<vtkJPEGReader>::New();
#else
    vtkSmartPointer<vtkPNGReader> pJpegReader =  vtkSmartPointer<vtkPNGReader>::New();
#endif
    pJpegReader->SetFileName(selectFilePath.toStdString().c_str());
    pJpegReader->Update();

    ui->textBrowser->append(QString("載入圖像:") + selectFilePath + QString(" 成功 !"));


    // 彩色圖 => 灰度圖
    {
        vtkSmartPointer<vtkImageLuminance> pImageLuminance = vtkSmartPointer<vtkImageLuminance>::New();
        pImageLuminance->SetInputConnection(pJpegReader->GetOutputPort());
        pImageLuminance->Update();

        vtkSmartPointer<vtkImageActor> pImageOrgActor = vtkSmartPointer<vtkImageActor>::New();
        pImageOrgActor->SetInputData(pJpegReader->GetOutput());

        vtkSmartPointer<vtkImageActor> pImageLumActor = vtkSmartPointer<vtkImageActor>::New();
        pImageLumActor->SetInputData(pImageLuminance->GetOutput());

        grayRenders[0]->AddActor(pImageOrgActor);
        grayRenders[1]->AddActor(pImageLumActor);

        for(int i = 0; i < grayRenders.size(); ++i)
        {
            grayRenders[i]->ResetCamera();
            ui->qvtkWidget->GetRenderWindow()->AddRenderer(grayRenders[i]);
        }
    }

    // 彩色圖像分量
    {
        vtkSmartPointer<vtkImageExtractComponents> pImageRedExtract = vtkSmartPointer<vtkImageExtractComponents>::New();
        pImageRedExtract->SetInputData(pJpegReader->GetOutput());
        pImageRedExtract->SetComponents(0);
        pImageRedExtract->Update();

        vtkSmartPointer<vtkImageExtractComponents> pImageGreenExtract = vtkSmartPointer<vtkImageExtractComponents>::New();
        pImageGreenExtract->SetInputData(pJpegReader->GetOutput());
        pImageGreenExtract->SetComponents(1);
        pImageGreenExtract->Update();

        vtkSmartPointer<vtkImageExtractComponents> pImageBlueExtract = vtkSmartPointer<vtkImageExtractComponents>::New();
        pImageBlueExtract->SetInputData(pJpegReader->GetOutput());
        pImageBlueExtract->SetComponents(2);
        pImageBlueExtract->Update();

        vtkSmartPointer<vtkImageActor> pImageOrgActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> redImageActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> greenImageActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> blueImageActor = vtkSmartPointer<vtkImageActor>::New();
        pImageOrgActor->SetInputData(pJpegReader->GetOutput());
        redImageActor->SetInputData(pImageRedExtract->GetOutput());
        greenImageActor->SetInputData(pImageGreenExtract->GetOutput());
        blueImageActor->SetInputData(pImageBlueExtract->GetOutput());

        colorChanelRenders[0]->AddActor(pImageOrgActor);
        colorChanelRenders[1]->AddActor(redImageActor);
        colorChanelRenders[2]->AddActor(greenImageActor);
        colorChanelRenders[3]->AddActor(blueImageActor);

        for(int i = 0; i < colorChanelRenders.size(); ++i)
        {
            colorChanelRenders[i]->ResetCamera();
            ui->qvtkWidget->GetRenderWindow()->AddRenderer(colorChanelRenders[i]);
        }
    }

    // 彩色圖像映射
    {
        vtkSmartPointer<vtkImageLuminance> pImageLuminance = vtkSmartPointer<vtkImageLuminance>::New();
        pImageLuminance->SetInputConnection(pJpegReader->GetOutputPort());
        pImageLuminance->Update();

        vtkSmartPointer<vtkImageActor> pImageOrgActor = vtkSmartPointer<vtkImageActor>::New();
        pImageOrgActor->SetInputData(pImageLuminance->GetOutput());

        vtkSmartPointer<vtkLookupTable> pLookUpTable = vtkSmartPointer<vtkLookupTable>::New();
        pLookUpTable->SetRange(0, 255.0);
        pLookUpTable->SetHueRange(0.1, 0.5);
        pLookUpTable->SetValueRange(0.6, 1.0);
        pLookUpTable->Build();

        vtkSmartPointer<vtkImageMapToColors> pImageMap = vtkSmartPointer<vtkImageMapToColors>::New();
        pImageMap->SetInputData(pImageLuminance->GetOutput());
        pImageMap->SetLookupTable(pLookUpTable);
        pImageMap->Update();

        vtkSmartPointer<vtkImageActor> pImageMapActor = vtkSmartPointer<vtkImageActor>::New();
        pImageMapActor->SetInputData(pImageMap->GetOutput());

        colorMapRenders[0]->AddActor(pImageOrgActor);
        colorMapRenders[1]->AddActor(pImageMapActor);

        for(int i = 0; i < colorMapRenders.size(); ++i)
        {
            colorMapRenders[i]->ResetCamera();
            ui->qvtkWidget->GetRenderWindow()->AddRenderer(colorMapRenders[i]);
        }
    }

    // 彩色圖像合成
    {
        vtkSmartPointer<vtkImageCanvasSource2D> redCanvas = vtkSmartPointer<vtkImageCanvasSource2D>::New();
        redCanvas->SetScalarTypeToUnsignedChar();
        redCanvas->SetNumberOfScalarComponents(1);
        redCanvas->SetExtent(0, 100, 0, 100, 0, 0);
        redCanvas->SetDrawColor(0, 0, 0, 0);
        redCanvas->FillBox(0,100,0,100);
        redCanvas->SetDrawColor(255, 0, 0, 0);
        redCanvas->FillBox(20,40,20,40);
        redCanvas->Update();

        vtkSmartPointer<vtkImageCanvasSource2D> greenCanvas = vtkSmartPointer<vtkImageCanvasSource2D>::New();
        greenCanvas->SetScalarTypeToUnsignedChar();
        greenCanvas->SetNumberOfScalarComponents(1);
        greenCanvas->SetExtent(0, 100, 0, 100, 0, 0);
        greenCanvas->SetDrawColor(0, 0, 0, 0);
        greenCanvas->FillBox(0,100,0,100);
        greenCanvas->SetDrawColor(255, 0, 0, 0);
        greenCanvas->FillBox(30,50,30,50);
        greenCanvas->Update();

        vtkSmartPointer<vtkImageCanvasSource2D> blueCanvas = vtkSmartPointer<vtkImageCanvasSource2D>::New();
        blueCanvas->SetScalarTypeToUnsignedChar();
        blueCanvas->SetNumberOfScalarComponents(1);
        blueCanvas->SetExtent(0, 100, 0, 100, 0, 0);
        blueCanvas->SetDrawColor(0, 0, 0, 0);
        blueCanvas->FillBox(0,100,0,100);
        blueCanvas->SetDrawColor(255, 0, 0, 0);
        blueCanvas->FillBox(40,60,40,60);
        blueCanvas->Update();

        vtkSmartPointer<vtkImageAppendComponents> appendFilter = vtkSmartPointer<vtkImageAppendComponents>::New();
        appendFilter->SetInputConnection(0, redCanvas->GetOutputPort());
        appendFilter->AddInputConnection(0, greenCanvas->GetOutputPort());
        appendFilter->AddInputConnection(0, blueCanvas->GetOutputPort());
        appendFilter->Update();

        vtkSmartPointer<vtkImageActor> redImageActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> greenImageActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> blueImageActor = vtkSmartPointer<vtkImageActor>::New();
        vtkSmartPointer<vtkImageActor> pImageCompActor = vtkSmartPointer<vtkImageActor>::New();
        redImageActor->SetInputData(redCanvas->GetOutput());
        greenImageActor->SetInputData(greenCanvas->GetOutput());
        blueImageActor->SetInputData(blueCanvas->GetOutput());
        pImageCompActor->SetInputData(appendFilter->GetOutput());

        colorCompRenders[0]->AddActor(redImageActor);
        colorCompRenders[1]->AddActor(greenImageActor);
        colorCompRenders[2]->AddActor(blueImageActor);
        colorCompRenders[3]->AddActor(pImageCompActor);

        for(int i = 0; i < colorCompRenders.size(); ++i)
        {
            colorCompRenders[i]->ResetCamera();
            ui->qvtkWidget->GetRenderWindow()->AddRenderer(colorCompRenders[i]);
        }
    }

    // 不能在MainWidow的構造函數中
    vtkSmartPointer<vtkInteractorStyleImage> style = vtkSmartPointer<vtkInteractorStyleImage>::New();
    ui->qvtkWidget->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);

    ui->qvtkWidget->GetRenderWindow()->Render();
}

 QT UI 文件

<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
 <class>MainWindow</class>
 <widget class="QMainWindow" name="MainWindow">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>400</width>
    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>MainWindow</string>
  </property>
  <widget class="QWidget" name="centralWidget">
   <layout class="QHBoxLayout" name="horizontalLayout" stretch="2,5">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QPushButton" name="pushButton">
        <property name="text">
         <string>選擇圖像</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QTextBrowser" name="textBrowser"/>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QVTKWidget" name="qvtkWidget"/>
    </item>
   </layout>
  </widget>
  <widget class="QMenuBar" name="menuBar">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>22</height>
    </rect>
   </property>
  </widget>
  <widget class="QToolBar" name="mainToolBar">
   <attribute name="toolBarArea">
    <enum>TopToolBarArea</enum>
   </attribute>
   <attribute name="toolBarBreak">
    <bool>false</bool>
   </attribute>
  </widget>
  <widget class="QStatusBar" name="statusBar"/>
 </widget>
 <layoutdefault spacing="6" margin="11"/>
 <customwidgets>
  <customwidget>
   <class>QVTKWidget</class>
   <extends>QWidget</extends>
   <header>QVTKWidget.h</header>
  </customwidget>
 </customwidgets>
 <resources/>
 <connections/>
</ui>