nmWTAI-Platform/Src/nmNum/nmSubWxs/nmWxPropertyInterpolationPreviewDlg.cpp

#include "nmWxPropertyInterpolationPreviewDlg.h"

#include <QApplication>
#include <QCoreApplication>
#include <QDesktopWidget>
#include <QHBoxLayout>
#include <QPushButton>
#include <QSizePolicy>
#include <QVBoxLayout>
#include <QVTKWidget.h>

#include <vtkActor.h>
#include <vtkActor2D.h>
#include <vtkBandedPolyDataContourFilter.h>
#include <vtkCamera.h>
#include <vtkCellArray.h>
#include <vtkDataArray.h>
#include <vtkDelaunay2D.h>
#include <vtkDoubleArray.h>
#include <vtkExtractPolyDataGeometry.h>
#include <vtkImplicitSelectionLoop.h>
#include <vtkInteractorStyleImage.h>
#include <vtkLabeledDataMapper.h>
#include <vtkLookupTable.h>
#include <vtkPointData.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkScalarBarActor.h>
#include <vtkSmartPointer.h>
#include <vtkStringArray.h>
#include <vtkTextActor.h>
#include <vtkTextProperty.h>
#include <vtkVertexGlyphFilter.h>

namespace
{
QString previewText(const char* sourceText)
{
    return QCoreApplication::translate("nmWxPropertyInterpolationPreviewDlg", sourceText);
}

vtkSmartPointer<vtkLookupTable> createPreviewLookupTable(double minimum,
                                                         double maximum)
{
    vtkSmartPointer<vtkLookupTable> lookupTable =
            vtkSmartPointer<vtkLookupTable>::New();
    lookupTable->SetNumberOfTableValues(256);
    lookupTable->SetRange(minimum, maximum);
    lookupTable->SetHueRange(0.60, 0.02);
    lookupTable->SetSaturationRange(0.50, 0.50);
    lookupTable->SetValueRange(0.96, 0.96);
    lookupTable->Build();
    return lookupTable;
}

void showPreviewFailure(vtkRenderer* renderer,
                        vtkRenderWindow* renderWindow,
                        const QString& message)
{
    if(renderer == NULL || renderWindow == NULL) {
        return;
    }

    vtkSmartPointer<vtkTextActor> messageActor =
            vtkSmartPointer<vtkTextActor>::New();
    const QString displayMessage = message.isEmpty() ?
            previewText("Preview Failed") : message;
    messageActor->SetInput(displayMessage.toUtf8().constData());
    messageActor->SetDisplayPosition(24, 24);
    messageActor->GetTextProperty()->SetColor(0.75, 0.15, 0.12);
    messageActor->GetTextProperty()->SetFontSize(16);
    renderer->AddActor2D(messageActor);
    renderWindow->Render();
}
}

nmWxPropertyInterpolationPreviewDlg::nmWxPropertyInterpolationPreviewDlg(
        const QString& dataSetName,
        const QString& scalarTitle,
        const QRectF& bounds,
        int columnCount,
        int rowCount,
        const QVector<double>& interpolationValues,
        const QVector<QPointF>& measurementPoints,
        const QVector<double>& measurementValues,
        const QVector<QPointF>& outlinePoints,
        const QVector<QPointF>& wellPoints,
        const QStringList& wellNames,
        bool showMeasurementPoints,
        bool showMeasurementLabels,
        QWidget* parent)
    : iDlgBase(parent),
      m_pVtkWidget(NULL)
{
    setWindowModality(Qt::NonModal);
    setModal(false);

    QVBoxLayout* mainLayout = new QVBoxLayout(this);
    mainLayout->setContentsMargins(8, 8, 8, 8);
    mainLayout->setSpacing(8);

    m_pVtkWidget = new QVTKWidget(this);
    m_pVtkWidget->setSizePolicy(QSizePolicy::Expanding,
                                QSizePolicy::Expanding);
    mainLayout->addWidget(m_pVtkWidget, 1);

    QHBoxLayout* buttonLayout = new QHBoxLayout;
    buttonLayout->addStretch();
    QPushButton* closeButton = new QPushButton(previewText("Close"), this);
    buttonLayout->addWidget(closeButton);
    mainLayout->addLayout(buttonLayout);
    connect(closeButton, SIGNAL(clicked()), this, SLOT(close()));

    updatePreview(dataSetName, scalarTitle, bounds, columnCount, rowCount,
                  interpolationValues, measurementPoints,
                  measurementValues, outlinePoints, wellPoints, wellNames,
                  showMeasurementPoints, showMeasurementLabels);
}

QSize nmWxPropertyInterpolationPreviewDlg::sizeHint() const
{
    QDesktopWidget* desktop = QApplication::desktop();
    if(desktop == NULL) {
        return iDlgBase::sizeHint();
    }

    // 预览窗口随当前屏幕可用区域调整，避免固定像素尺寸在不同分辨率下失衡.
    const QRect availableRect = desktop->availableGeometry(this);
    return QSize(availableRect.width() * 1 / 2,
                 availableRect.height() * 4 / 5);
}

void nmWxPropertyInterpolationPreviewDlg::updatePreview(
        const QString& dataSetName,
        const QString& scalarTitle,
        const QRectF& bounds,
        int columnCount,
        int rowCount,
        const QVector<double>& interpolationValues,
        const QVector<QPointF>& measurementPoints,
        const QVector<double>& measurementValues,
        const QVector<QPointF>& outlinePoints,
        const QVector<QPointF>& wellPoints,
        const QStringList& wellNames,
        bool showMeasurementPoints,
        bool showMeasurementLabels)
{
    setWindowTitle(previewText("Interpolation Preview") + " - " + dataSetName);
    initializeRenderer(scalarTitle, bounds, columnCount, rowCount,
                        interpolationValues, measurementPoints,
                        measurementValues, outlinePoints, wellPoints, wellNames,
                        showMeasurementPoints, showMeasurementLabels);
}

void nmWxPropertyInterpolationPreviewDlg::showMessage(
        const QString& dataSetName,
        const QString& message)
{
    if(m_pVtkWidget == NULL) {
        return;
    }

    QString windowTitle = previewText("Interpolation Preview");
    if(!dataSetName.isEmpty()) {
        windowTitle += " - " + dataSetName;
    }
    setWindowTitle(windowTitle);

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

    vtkSmartPointer<vtkRenderWindow> renderWindow =
            vtkSmartPointer<vtkRenderWindow>::New();
    renderWindow->SetMultiSamples(0);
    renderWindow->AddRenderer(renderer);
    m_pVtkWidget->SetRenderWindow(renderWindow);
    showPreviewFailure(renderer, renderWindow, message);
}

void nmWxPropertyInterpolationPreviewDlg::initializeRenderer(
        const QString& scalarTitle,
        const QRectF& bounds,
        int columnCount,
        int rowCount,
        const QVector<double>& interpolationValues,
        const QVector<QPointF>& measurementPoints,
        const QVector<double>& measurementValues,
        const QVector<QPointF>& outlinePoints,
        const QVector<QPointF>& wellPoints,
        const QStringList& wellNames,
        bool showMeasurementPoints,
        bool showMeasurementLabels)
{
    if(m_pVtkWidget == NULL) {
        return;
    }

    // 显式创建渲染窗口，避免使用尚未初始化的QVTKWidget默认窗口.
    vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
    renderer->SetBackground(1.0, 1.0, 1.0);

    vtkSmartPointer<vtkRenderWindow> renderWindow =
            vtkSmartPointer<vtkRenderWindow>::New();
    renderWindow->SetMultiSamples(0);
    renderWindow->AddRenderer(renderer);
    m_pVtkWidget->SetRenderWindow(renderWindow);

    if(columnCount < 2 || rowCount < 2 ||
            bounds.width() <= 0.0 || bounds.height() <= 0.0 ||
            interpolationValues.size() != columnCount * rowCount) {
        showPreviewFailure(renderer, renderWindow, previewText("Preview Failed"));
        return;
    }

    // 规则采样点使用Kriging结果，测点作为额外顶点直接使用已知值.
    vtkSmartPointer<vtkPoints> surfacePoints =
            vtkSmartPointer<vtkPoints>::New();
    vtkSmartPointer<vtkDoubleArray> scalarArray =
            vtkSmartPointer<vtkDoubleArray>::New();
    scalarArray->SetName("InterpolatedValue");
    scalarArray->SetNumberOfComponents(1);

    const double spacingX = bounds.width() / (columnCount - 1);
    const double spacingY = bounds.height() / (rowCount - 1);
    for(int row = 0; row < rowCount; ++row) {
        const double y = bounds.top() + spacingY * row;
        for(int column = 0; column < columnCount; ++column) {
            const int valueIndex = row * columnCount + column;
            const double x = bounds.left() + spacingX * column;
            surfacePoints->InsertNextPoint(x, y, 0.0);
            scalarArray->InsertNextValue(interpolationValues[valueIndex]);
        }
    }

    if(measurementPoints.size() == measurementValues.size()) {
        const double coordinateTolerance = qMax(
                    qMax(bounds.width(), bounds.height()) * 1.0e-10,
                    1.0e-12);
        const int regularPointCount = surfacePoints->GetNumberOfPoints();
        for(int i = 0; i < measurementPoints.size(); ++i) {
            vtkIdType matchingPointId = -1;
            for(int pointIndex = 0; pointIndex < regularPointCount; ++pointIndex) {
                double regularPoint[3] = { 0.0, 0.0, 0.0 };
                surfacePoints->GetPoint(pointIndex, regularPoint);
                if(qAbs(regularPoint[0] - measurementPoints[i].x()) <= coordinateTolerance &&
                        qAbs(regularPoint[1] - measurementPoints[i].y()) <= coordinateTolerance) {
                    matchingPointId = pointIndex;
                    break;
                }
            }

            if(matchingPointId >= 0) {
                scalarArray->SetValue(matchingPointId, measurementValues[i]);
            }
            else {
                surfacePoints->InsertNextPoint(measurementPoints[i].x(),
                                               measurementPoints[i].y(), 0.0);
                scalarArray->InsertNextValue(measurementValues[i]);
            }
        }
    }

    vtkSmartPointer<vtkPolyData> surfaceData =
            vtkSmartPointer<vtkPolyData>::New();
    surfaceData->SetPoints(surfacePoints);
    surfaceData->GetPointData()->SetScalars(scalarArray);

    vtkSmartPointer<vtkDelaunay2D> triangulationFilter =
            vtkSmartPointer<vtkDelaunay2D>::New();
    triangulationFilter->SetInputData(surfaceData);
    triangulationFilter->SetProjectionPlaneMode(VTK_DELAUNAY_XY_PLANE);
    triangulationFilter->SetTolerance(0.0);
    triangulationFilter->BoundingTriangulationOff();
    triangulationFilter->Update();

    // 默认使用完整三角网格；仅在裁剪结果有效且保留标量时切换.
    vtkPolyData* visibleSurface = triangulationFilter->GetOutput();
    vtkSmartPointer<vtkExtractPolyDataGeometry> extractFilter;
    vtkSmartPointer<vtkImplicitSelectionLoop> selectionLoop;
    vtkSmartPointer<vtkPoints> selectionPoints;
    if(outlinePoints.size() >= 3) {
        selectionPoints = vtkSmartPointer<vtkPoints>::New();
        for(int i = 0; i < outlinePoints.size(); ++i) {
            selectionPoints->InsertNextPoint(outlinePoints[i].x(),
                                             outlinePoints[i].y(), 0.0);
        }

        selectionLoop = vtkSmartPointer<vtkImplicitSelectionLoop>::New();
        selectionLoop->SetLoop(selectionPoints);
        selectionLoop->AutomaticNormalGenerationOff();
        selectionLoop->SetNormal(0.0, 0.0, 1.0);

        extractFilter = vtkSmartPointer<vtkExtractPolyDataGeometry>::New();
        extractFilter->SetInputConnection(triangulationFilter->GetOutputPort());
        extractFilter->SetImplicitFunction(selectionLoop);
        extractFilter->ExtractInsideOn();
        extractFilter->ExtractBoundaryCellsOn();
        extractFilter->Update();
        vtkPolyData* extractedSurface = extractFilter->GetOutput();
        if(extractedSurface != NULL &&
                extractedSurface->GetNumberOfPoints() > 0 &&
                extractedSurface->GetPointData() != NULL &&
                extractedSurface->GetPointData()->GetScalars() != NULL) {
            visibleSurface = extractedSurface;
        }
    }

    if(visibleSurface == NULL || visibleSurface->GetNumberOfPoints() == 0 ||
            visibleSurface->GetPointData() == NULL ||
            visibleSurface->GetPointData()->GetScalars() == NULL) {
        showPreviewFailure(renderer, renderWindow, previewText("Preview Failed"));
        return;
    }

    vtkDataArray* interpolatedScalars =
            visibleSurface->GetPointData()->GetScalars();
    visibleSurface->GetPointData()->SetScalars(interpolatedScalars);

    // 颜色条使用测点值范围，避免规则采样未命中测点时最大、最小值向内收缩.
    double displayMinimum = 0.0;
    double displayMaximum = 0.0;
    if(!measurementValues.isEmpty()) {
        displayMinimum = measurementValues[0];
        displayMaximum = measurementValues[0];
        for(int i = 1; i < measurementValues.size(); ++i) {
            displayMinimum = qMin(displayMinimum, measurementValues[i]);
            displayMaximum = qMax(displayMaximum, measurementValues[i]);
        }
    }
    else {
        double displayRange[2] = { 0.0, 0.0 };
        visibleSurface->GetPointData()->GetScalars()->GetRange(displayRange);
        displayMinimum = displayRange[0];
        displayMaximum = displayRange[1];
    }
    if(qAbs(displayMaximum - displayMinimum) < 1.0e-12) {
        const double padding = qMax(qAbs(displayMinimum) * 0.01, 1.0e-6);
        displayMinimum -= padding;
        displayMaximum += padding;
    }

    vtkSmartPointer<vtkLookupTable> lookupTable =
            createPreviewLookupTable(displayMinimum, displayMaximum);

    // 将连续点标量划分为8级色带，Mapper按CellData进行分级着色.
    const int colorBandCount = 8;
    vtkSmartPointer<vtkBandedPolyDataContourFilter> bandFilter =
            vtkSmartPointer<vtkBandedPolyDataContourFilter>::New();
    bandFilter->SetInputData(visibleSurface);
    bandFilter->GenerateValues(colorBandCount + 1,
                               displayMinimum, displayMaximum);
    bandFilter->SetScalarModeToValue();
    bandFilter->GenerateContourEdgesOff();

    vtkSmartPointer<vtkPolyDataMapper> surfaceMapper =
            vtkSmartPointer<vtkPolyDataMapper>::New();
    surfaceMapper->SetInputConnection(bandFilter->GetOutputPort());
    surfaceMapper->SetScalarModeToUseCellData();
    surfaceMapper->SetLookupTable(lookupTable);
    surfaceMapper->SetScalarRange(displayMinimum, displayMaximum);
    surfaceMapper->ScalarVisibilityOn();

    vtkSmartPointer<vtkActor> surfaceActor = vtkSmartPointer<vtkActor>::New();
    surfaceActor->SetMapper(surfaceMapper);
    surfaceActor->GetProperty()->EdgeVisibilityOff();

    renderer->AddActor(surfaceActor);

    // 叠加储层边界，并通过轻微Z偏移避免与色带表面重合.
    if(outlinePoints.size() >= 3) {
        vtkSmartPointer<vtkPoints> outlineVtkPoints =
                vtkSmartPointer<vtkPoints>::New();
        for(int i = 0; i < outlinePoints.size(); ++i) {
            outlineVtkPoints->InsertNextPoint(outlinePoints[i].x(),
                                              outlinePoints[i].y(), 0.01);
        }

        vtkSmartPointer<vtkCellArray> outlineLines =
                vtkSmartPointer<vtkCellArray>::New();
        outlineLines->InsertNextCell(outlinePoints.size() + 1);
        for(int i = 0; i < outlinePoints.size(); ++i) {
            outlineLines->InsertCellPoint(i);
        }
        outlineLines->InsertCellPoint(0);

        vtkSmartPointer<vtkPolyData> outlineData =
                vtkSmartPointer<vtkPolyData>::New();
        outlineData->SetPoints(outlineVtkPoints);
        outlineData->SetLines(outlineLines);

        vtkSmartPointer<vtkPolyDataMapper> outlineMapper =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        outlineMapper->SetInputData(outlineData);
        outlineMapper->ScalarVisibilityOff();

        vtkSmartPointer<vtkActor> outlineActor = vtkSmartPointer<vtkActor>::New();
        outlineActor->SetMapper(outlineMapper);
        outlineActor->GetProperty()->SetColor(0.55, 0.38, 0.22);
        outlineActor->GetProperty()->SetLineWidth(1.2);
        renderer->AddActor(outlineActor);
    }

    // 测点和数值标签复用同一组坐标和值，叠加显示在插值面上.
    if((showMeasurementPoints || showMeasurementLabels) &&
            !measurementPoints.isEmpty() &&
            measurementPoints.size() == measurementValues.size()) {
        vtkSmartPointer<vtkPoints> measurementVtkPoints =
                vtkSmartPointer<vtkPoints>::New();
        vtkSmartPointer<vtkDoubleArray> measurementScalars =
                vtkSmartPointer<vtkDoubleArray>::New();
        measurementScalars->SetName("MeasurementValue");
        measurementScalars->SetNumberOfComponents(1);

        for(int i = 0; i < measurementPoints.size(); ++i) {
            measurementVtkPoints->InsertNextPoint(measurementPoints[i].x(),
                                                  measurementPoints[i].y(), 0.02);
            measurementScalars->InsertNextValue(measurementValues[i]);
        }

        vtkSmartPointer<vtkPolyData> measurementData =
                vtkSmartPointer<vtkPolyData>::New();
        measurementData->SetPoints(measurementVtkPoints);
        measurementData->GetPointData()->SetScalars(measurementScalars);

        if(showMeasurementPoints) {
            vtkSmartPointer<vtkVertexGlyphFilter> glyphFilter =
                    vtkSmartPointer<vtkVertexGlyphFilter>::New();
            glyphFilter->SetInputData(measurementData);

            // 深色外层形成清晰描边，避免测点颜色与附近插值色带融为一体.
            vtkSmartPointer<vtkPolyDataMapper> borderMapper =
                    vtkSmartPointer<vtkPolyDataMapper>::New();
            borderMapper->SetInputConnection(glyphFilter->GetOutputPort());
            borderMapper->ScalarVisibilityOff();

            vtkSmartPointer<vtkActor> borderActor =
                    vtkSmartPointer<vtkActor>::New();
            borderActor->SetMapper(borderMapper);
            borderActor->GetProperty()->SetColor(0.10, 0.10, 0.10);
            borderActor->GetProperty()->SetPointSize(9.0);
            renderer->AddActor(borderActor);

            vtkSmartPointer<vtkPolyDataMapper> measurementMapper =
                    vtkSmartPointer<vtkPolyDataMapper>::New();
            measurementMapper->SetInputConnection(glyphFilter->GetOutputPort());
            measurementMapper->SetLookupTable(lookupTable);
            measurementMapper->SetScalarRange(displayMinimum, displayMaximum);
            measurementMapper->SetScalarModeToUsePointData();

            vtkSmartPointer<vtkActor> measurementActor =
                    vtkSmartPointer<vtkActor>::New();
            measurementActor->SetMapper(measurementMapper);
            measurementActor->GetProperty()->SetPointSize(5.0);
            measurementActor->SetPosition(0.0, 0.0, 0.001);
            renderer->AddActor(measurementActor);
        }

        if(showMeasurementLabels) {
            // 标签使用独立坐标上移，测点方框仍保持在原始测量位置.
            const double labelOffset =
                    qMax(bounds.width(), bounds.height()) * 0.018;
            vtkSmartPointer<vtkPoints> measurementLabelPoints =
                    vtkSmartPointer<vtkPoints>::New();
            for(int i = 0; i < measurementPoints.size(); ++i) {
                measurementLabelPoints->InsertNextPoint(
                            measurementPoints[i].x(),
                            measurementPoints[i].y() + labelOffset, 0.03);
            }

            vtkSmartPointer<vtkPolyData> measurementLabelData =
                    vtkSmartPointer<vtkPolyData>::New();
            measurementLabelData->SetPoints(measurementLabelPoints);
            measurementLabelData->GetPointData()->SetScalars(
                        measurementScalars);

            vtkSmartPointer<vtkLabeledDataMapper> labelMapper =
                    vtkSmartPointer<vtkLabeledDataMapper>::New();
            labelMapper->SetInputData(measurementLabelData);
            labelMapper->SetLabelModeToLabelScalars();
            labelMapper->SetLabelFormat("%.6g");
            labelMapper->GetLabelTextProperty()->SetColor(0.12, 0.12, 0.12);
            labelMapper->GetLabelTextProperty()->SetFontSize(12);
            labelMapper->GetLabelTextProperty()->BoldOff();
            labelMapper->GetLabelTextProperty()->ItalicOff();
            labelMapper->GetLabelTextProperty()->ShadowOff();
            labelMapper->GetLabelTextProperty()->SetJustificationToCentered();
            labelMapper->GetLabelTextProperty()->SetVerticalJustificationToBottom();

            vtkSmartPointer<vtkActor2D> labelActor =
                    vtkSmartPointer<vtkActor2D>::New();
            labelActor->SetMapper(labelMapper);
            renderer->AddActor2D(labelActor);
        }
    }

    // Map中显示的井使用独立红色标记和名称叠加，不参与插值表面计算.
    if(!wellPoints.isEmpty() && wellPoints.size() == wellNames.size()) {
        vtkSmartPointer<vtkPoints> wellVtkPoints =
                vtkSmartPointer<vtkPoints>::New();
        vtkSmartPointer<vtkStringArray> wellNameArray =
                vtkSmartPointer<vtkStringArray>::New();
        wellNameArray->SetName("WellName");
        for(int i = 0; i < wellPoints.size(); ++i) {
            wellVtkPoints->InsertNextPoint(wellPoints[i].x(),
                                           wellPoints[i].y(), 0.04);
            wellNameArray->InsertNextValue(wellNames[i].toUtf8().constData());
        }

        vtkSmartPointer<vtkPolyData> wellData =
                vtkSmartPointer<vtkPolyData>::New();
        wellData->SetPoints(wellVtkPoints);
        wellData->GetPointData()->AddArray(wellNameArray);

        vtkSmartPointer<vtkVertexGlyphFilter> wellGlyphFilter =
                vtkSmartPointer<vtkVertexGlyphFilter>::New();
        wellGlyphFilter->SetInputData(wellData);

        vtkSmartPointer<vtkPolyDataMapper> wellBorderMapper =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        wellBorderMapper->SetInputConnection(wellGlyphFilter->GetOutputPort());
        wellBorderMapper->ScalarVisibilityOff();
        vtkSmartPointer<vtkActor> wellBorderActor =
                vtkSmartPointer<vtkActor>::New();
        wellBorderActor->SetMapper(wellBorderMapper);
        wellBorderActor->GetProperty()->SetColor(0.12, 0.12, 0.12);
        wellBorderActor->GetProperty()->SetPointSize(9.0);
        renderer->AddActor(wellBorderActor);

        vtkSmartPointer<vtkPolyDataMapper> wellMapper =
                vtkSmartPointer<vtkPolyDataMapper>::New();
        wellMapper->SetInputConnection(wellGlyphFilter->GetOutputPort());
        wellMapper->ScalarVisibilityOff();
        vtkSmartPointer<vtkActor> wellActor = vtkSmartPointer<vtkActor>::New();
        wellActor->SetMapper(wellMapper);
        wellActor->GetProperty()->SetColor(0.90, 0.12, 0.10);
        wellActor->GetProperty()->SetPointSize(5.0);
        wellActor->SetPosition(0.0, 0.0, 0.001);
        renderer->AddActor(wellActor);

        // 井名同样使用独立坐标，避免文字覆盖井位标记.
        const double wellLabelOffset =
                qMax(bounds.width(), bounds.height()) * 0.022;
        vtkSmartPointer<vtkPoints> wellLabelPoints =
                vtkSmartPointer<vtkPoints>::New();
        for(int i = 0; i < wellPoints.size(); ++i) {
            wellLabelPoints->InsertNextPoint(
                        wellPoints[i].x(),
                        wellPoints[i].y() + wellLabelOffset, 0.05);
        }

        vtkSmartPointer<vtkPolyData> wellLabelData =
                vtkSmartPointer<vtkPolyData>::New();
        wellLabelData->SetPoints(wellLabelPoints);
        wellLabelData->GetPointData()->AddArray(wellNameArray);

        vtkSmartPointer<vtkLabeledDataMapper> wellLabelMapper =
                vtkSmartPointer<vtkLabeledDataMapper>::New();
        wellLabelMapper->SetInputData(wellLabelData);
        wellLabelMapper->SetLabelModeToLabelFieldData();
        wellLabelMapper->SetFieldDataName("WellName");
        wellLabelMapper->SetLabelFormat("%s");
        wellLabelMapper->GetLabelTextProperty()->SetColor(0.10, 0.10, 0.10);
        wellLabelMapper->GetLabelTextProperty()->SetFontSize(13);
        wellLabelMapper->GetLabelTextProperty()->BoldOff();
        wellLabelMapper->GetLabelTextProperty()->ItalicOff();
        wellLabelMapper->GetLabelTextProperty()->ShadowOff();
        wellLabelMapper->GetLabelTextProperty()->SetJustificationToCentered();
        wellLabelMapper->GetLabelTextProperty()->SetVerticalJustificationToBottom();

        vtkSmartPointer<vtkActor2D> wellLabelActor =
                vtkSmartPointer<vtkActor2D>::New();
        wellLabelActor->SetMapper(wellLabelMapper);
        renderer->AddActor2D(wellLabelActor);
    }

    vtkSmartPointer<vtkScalarBarActor> scalarBar =
            vtkSmartPointer<vtkScalarBarActor>::New();
    scalarBar->SetLookupTable(lookupTable);
    scalarBar->SetTitle(scalarTitle.toUtf8().constData());
    scalarBar->SetNumberOfLabels(6);
    scalarBar->SetPosition(0.88, 0.12);
    scalarBar->SetWidth(0.08);
    scalarBar->SetHeight(0.76);
    scalarBar->UnconstrainedFontSizeOn();
    scalarBar->GetLabelTextProperty()->SetColor(0.15, 0.15, 0.15);
    scalarBar->GetLabelTextProperty()->SetFontSize(11);
    scalarBar->GetLabelTextProperty()->BoldOff();
    scalarBar->GetLabelTextProperty()->ItalicOff();
    scalarBar->GetLabelTextProperty()->ShadowOff();
    scalarBar->GetTitleTextProperty()->SetColor(0.15, 0.15, 0.15);
    scalarBar->GetTitleTextProperty()->SetFontSize(13);
    scalarBar->GetTitleTextProperty()->BoldOff();
    scalarBar->GetTitleTextProperty()->ItalicOff();
    scalarBar->GetTitleTextProperty()->ShadowOff();
    renderer->AddActor2D(scalarBar);

    // 使用正交相机按模型边界居中显示，保持平面比例并避免透视变形.
    vtkCamera* camera = renderer->GetActiveCamera();
    const double centerX = bounds.left() + bounds.width() * 0.5;
    const double centerY = bounds.top() + bounds.height() * 0.5;
    camera->SetPosition(centerX, centerY, 1.0);
    camera->SetFocalPoint(centerX, centerY, 0.0);
    camera->SetViewUp(0.0, 1.0, 0.0);
    camera->ParallelProjectionOn();
    double cameraBounds[6] = {
        bounds.left(), bounds.right(), bounds.top(), bounds.bottom(), -0.1, 0.1
    };
    renderer->ResetCamera(cameraBounds);
    camera->SetParallelScale(qMax(bounds.height(), bounds.width()) * 0.52);

    vtkSmartPointer<vtkInteractorStyleImage> interactorStyle =
            vtkSmartPointer<vtkInteractorStyleImage>::New();
    renderWindow->GetInteractor()->SetInteractorStyle(interactorStyle);
    renderWindow->Render();
}