VTK example：显示unstructuredGrid，添加向量场颜色，及箭头

如下示例代码，使用GPT3.5生成。可以显示geometry及箭头，不能显示场颜色。

#include <vtkSmartPointer.h>
#include <vtkUnstructuredGrid.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
#include <vtkDoubleArray.h>
#include <vtkArrowSource.h>
#include <vtkGlyph3D.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkNamedColors.h>
#include <vtkGeometryFilter.h>
#include <vtkColorTransferFunction.h>
#include <vtkPointData.h>
#include <vtkScalarBarActor.h>

int main()
{
    // Create an unstructured grid
    vtkSmartPointer<vtkUnstructuredGrid> unstructuredGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();

    // Create points for the grid
    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
    points->InsertNextPoint(0.0, 0.0, 0.0);
    points->InsertNextPoint(1.0, 0.0, 0.0);
    points->InsertNextPoint(1.0, 1.0, 0.0);
    points->InsertNextPoint(0.0, 1.0, 0.0);
    unstructuredGrid->SetPoints(points);

    // Create a triangle
    vtkSmartPointer<vtkTriangle> triangle = vtkSmartPointer<vtkTriangle>::New();
    triangle->GetPointIds()->SetId(0, 0);
    triangle->GetPointIds()->SetId(1, 1);
    triangle->GetPointIds()->SetId(2, 2);
    unstructuredGrid->InsertNextCell(triangle->GetCellType(), triangle->GetPointIds());

    // Create a separate array for the vector field
    vtkSmartPointer<vtkDoubleArray> vectorField = vtkSmartPointer<vtkDoubleArray>::New();
    vectorField->SetName("VectorField");
    vectorField->SetNumberOfComponents(3); // 3 components for x, y, z
    double vector[3] = {1.0, 0.0, 0.0}; // Example vector value
    vectorField->InsertNextTuple(vector);
    unstructuredGrid->GetCellData()->SetVectors(vectorField);

    // Compute the magnitude of the vector field
    vtkSmartPointer<vtkDoubleArray> magnitudeArray = vtkSmartPointer<vtkDoubleArray>::New();
    magnitudeArray->SetNumberOfComponents(1);
    magnitudeArray->SetName("Magnitude");
    for (vtkIdType i = 0; i < vectorField->GetNumberOfTuples(); ++i)
    {
        double* vector = vectorField->GetTuple3(i);
        double magnitude = std::sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]);
        magnitudeArray->InsertNextValue(magnitude);
    }
    unstructuredGrid->GetPointData()->AddArray(magnitudeArray);

    // Convert vtkUnstructuredGrid to vtkPolyData
    vtkSmartPointer<vtkGeometryFilter> geometryFilter = vtkSmartPointer<vtkGeometryFilter>::New();
    geometryFilter->SetInputData(unstructuredGrid);
    geometryFilter->Update();

    // Create arrows for visualizing the vector field
    vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New();
    arrowSource->SetShaftResolution(10);
    arrowSource->SetTipResolution(10);

    // Scale the arrows based on the magnitude of the vector
    vtkSmartPointer<vtkGlyph3D> glyph3D = vtkSmartPointer<vtkGlyph3D>::New();
    glyph3D->SetInputConnection(geometryFilter->GetOutputPort());
    glyph3D->SetSourceConnection(arrowSource->GetOutputPort());
    glyph3D->SetScaleModeToScaleByVector();
    glyph3D->SetScaleFactor(0.05); // Adjust the scaling factor to your liking

    // Create a color transfer function for the scalar values
    vtkSmartPointer<vtkColorTransferFunction> colorTransferFunction = vtkSmartPointer<vtkColorTransferFunction>::New();
    colorTransferFunction->SetColorSpaceToRGB();
    colorTransferFunction->AddRGBPoint(magnitudeArray->GetRange()[0], 0.0, 0.0, 1.0); // Blue for lower values
    colorTransferFunction->AddRGBPoint(magnitudeArray->GetRange()[1], 1.0, 0.0, 0.0); // Red for higher values

    vtkSmartPointer<vtkPolyDataMapper> vectorMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    vectorMapper->SetInputConnection(glyph3D->GetOutputPort());
    vectorMapper->ScalarVisibilityOn();
    vectorMapper->SetScalarModeToUsePointData();
    vectorMapper->SelectColorArray("VectorField");
    vectorMapper->SetColorModeToMapScalars();
    vectorMapper->SetLookupTable(colorTransferFunction);

    // Create an actor for the vector arrows
    vtkSmartPointer<vtkActor> vectorActor = vtkSmartPointer<vtkActor>::New();
    vectorActor->SetMapper(vectorMapper);

    // Create a mapper for the unstructured grid
    vtkSmartPointer<vtkPolyDataMapper> gridMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
    gridMapper->SetInputConnection(geometryFilter->GetOutputPort());
    gridMapper->SetScalarVisibility(true);
    gridMapper->UseLookupTableScalarRangeOn();
    gridMapper->SelectColorArray("Magnitude");
    // gridMapper->ScalarVisibilityOff();

    // Create an actor for the unstructured grid
    vtkSmartPointer<vtkActor> gridActor = vtkSmartPointer<vtkActor>::New();
    gridActor->SetMapper(gridMapper);

    // Create a renderer, render window, and interactor
    vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
    vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
    renderWindow->AddRenderer(renderer);
    vtkSmartPointer<vtkRenderWindowInteractor> interactor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
    interactor->SetRenderWindow(renderWindow);

    // Set the background color to white
    vtkSmartPointer<vtkNamedColors> colors = vtkSmartPointer<vtkNamedColors>::New();
    renderer->SetBackground(colors->GetColor3d("White").GetData());

    // Add the actors to the renderer
    renderer->AddActor(vectorActor);
    renderer->AddActor(gridActor);

    // Create a scalar bar for the color transfer function
    vtkSmartPointer<vtkScalarBarActor> scalarBar = vtkSmartPointer<vtkScalarBarActor>::New();
    scalarBar->SetLookupTable(colorTransferFunction);
    scalarBar->SetTitle("Magnitude");
    scalarBar->SetOrientationToHorizontal();
    scalarBar->SetPosition(0.1, 0.1);
    scalarBar->SetWidth(0.8);
    scalarBar->SetHeight(0.15);
    scalarBar->SetNumberOfLabels(5);
    scalarBar->SetLabelFormat("%-#6.2g");
    scalarBar->GetTitleTextProperty()->SetFontSize(14);
    scalarBar->GetLabelTextProperty()->SetFontSize(12);
    renderer->AddActor2D(scalarBar);

    // Set camera position and focal point
    renderer->GetActiveCamera()->SetPosition(0.0, -3.0, 0.0);
    renderer->GetActiveCamera()->SetFocalPoint(0.5, 0.5, 0.0);

    // Render the scene and start the interactor
    renderWindow->Render();
    interactor->Start();

    return 0;
}