Skip to content


# XYPlot

VTKEx/Cxx/Annotation/XYPlot

### Description

This example demonstrates the use of vtkXYPlotActor to display three probe lines using three different techniques. In this example, we are loading data using the vtkPLOT3DReader. We are using the vtkProbeFilter to extract the underlying point data along three probe lines.

Note

The image was generated with this volume data: combxyz.bin and combq.bin.

Question

If you have a simple question about this example contact us at VTKExProject If your question is more complex and may require extended discussion, please use the VTK Discourse Forum

### Code

XYPlot.cxx

    // This example demonstrates the use of vtkXYPlotActor to display three
    // probe lines using three different techniques.  In this example, we
    // are loading data using the vtkPLOT3DReader.  We are using the
    // vtkProbeFilter to extract the underlying point data along three
    // probe lines.

    #include <vtkSmartPointer.h>
    #include <vtkXYPlotActor.h>

    #include <vtkAppendPolyData.h>
    #include <vtkLineSource.h>
    #include <vtkMultiBlockPLOT3DReader.h>
    #include <vtkMultiBlockDataSet.h>
    #include <vtkProbeFilter.h>
    #include <vtkStructuredGrid.h>
    #include <vtkStructuredGridOutlineFilter.h>
    #include <vtkTransform.h>
    #include <vtkTransformPolyDataFilter.h>
    #include <vtkTubeFilter.h>

    #include <vtkPolyDataMapper.h>
    #include <vtkActor.h>
    #include <vtkCamera.h>
    #include <vtkProperty2D.h>
    #include <vtkProperty.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkRenderer.h>
    #include <vtkTextProperty.h>
    #include <vtkNamedColors.h>

    int main (int argc, char *argv[])
    {
      if (argc < 3)
      {
        std::cout << "Usage: " << argv[0] << " combxyz.bin combq.bin" << std::endl;
        return EXIT_FAILURE;
      }

    // Create a PLOT3D reader and load the data.
      vtkSmartPointer<vtkMultiBlockPLOT3DReader> pl3d =
        vtkSmartPointer<vtkMultiBlockPLOT3DReader>::New();
      pl3d->SetXYZFileName(argv[1]);
      pl3d->SetQFileName(argv[2]);
      pl3d->SetScalarFunctionNumber(100);
      pl3d->SetVectorFunctionNumber(202);
      pl3d->Update();

      vtkStructuredGrid* pl3d_output =
        dynamic_cast<vtkStructuredGrid*>(pl3d->GetOutput()->GetBlock(0));

    // Create three the line source to use for the probe lines.
      vtkSmartPointer<vtkLineSource> line =
        vtkSmartPointer<vtkLineSource>::New();
      line->SetResolution(30);

    // Move the line into place and create the probe filter.  For
    // vtkProbeFilter, the probe line is the input, and the underlying data
    // set is the source.
      vtkSmartPointer<vtkTransform> transL1 =
        vtkSmartPointer<vtkTransform>::New();
      transL1->Translate(3.7, 0.0, 28.37);
      transL1->Scale(5, 5, 5);
      transL1->RotateY(90);

      vtkSmartPointer<vtkTransformPolyDataFilter> tf =
        vtkSmartPointer<vtkTransformPolyDataFilter>::New();
      tf->SetInputConnection(line->GetOutputPort());
      tf->SetTransform(transL1);

      vtkSmartPointer<vtkProbeFilter> probe =
        vtkSmartPointer<vtkProbeFilter>::New();
      probe->SetInputConnection(tf->GetOutputPort());
      probe->SetSourceData(pl3d_output);

    // Move the line again and create another probe filter.
      vtkSmartPointer<vtkTransform> transL2 =
        vtkSmartPointer<vtkTransform>::New();
      transL2->Translate(9.2, 0.0, 31.20);
      transL2->Scale(5, 5, 5);
      transL2->RotateY(90);

      vtkSmartPointer<vtkTransformPolyDataFilter>tf2 =
        vtkSmartPointer<vtkTransformPolyDataFilter>::New();
      tf2->SetInputConnection(line->GetOutputPort());
      tf2->SetTransform(transL2);
      vtkSmartPointer<vtkProbeFilter> probe2 =
        vtkSmartPointer<vtkProbeFilter>::New();
      probe2->SetInputConnection(tf2->GetOutputPort());
      probe2->SetSourceData(pl3d_output);

    // Move the line again and create a third probe filter.
      vtkSmartPointer<vtkTransform> transL3 =
        vtkSmartPointer<vtkTransform>::New();
      transL3->Translate(13.27, 0.0, 33.40);
      transL3->Scale(4.5, 4.5, 4.5);
      transL3->RotateY(90);
      vtkSmartPointer<vtkTransformPolyDataFilter> tf3 =
        vtkSmartPointer<vtkTransformPolyDataFilter>::New();
      tf3->SetInputConnection(line->GetOutputPort());
      tf3->SetTransform(transL3);
      vtkSmartPointer<vtkProbeFilter> probe3 =
        vtkSmartPointer<vtkProbeFilter>::New();
      probe3->SetInputConnection(tf3->GetOutputPort());
      probe3->SetSourceData(pl3d_output);

    // Create a vtkAppendPolyData to merge the output of the three probe
    // filters into one data set.
      vtkSmartPointer<vtkAppendPolyData> appendF =
        vtkSmartPointer<vtkAppendPolyData>::New();
      appendF->AddInputConnection(probe->GetOutputPort());
      appendF->AddInputConnection(probe2->GetOutputPort());
      appendF->AddInputConnection(probe3->GetOutputPort());

    // Create a tube filter to represent the lines as tubes.  Set up the
    // associated mapper and actor.
      vtkSmartPointer<vtkTubeFilter> tuber =
        vtkSmartPointer<vtkTubeFilter>::New();
      tuber->SetInputConnection(appendF->GetOutputPort());
      tuber->SetRadius(0.1);
      vtkSmartPointer<vtkPolyDataMapper> lineMapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
      lineMapper->SetInputConnection(tuber->GetOutputPort());
      vtkSmartPointer<vtkActor> lineActor =
        vtkSmartPointer<vtkActor>::New();
      lineActor->SetMapper(lineMapper);

    // Create an xy-plot using the output of the 3 probe filters as input.
    // The x-values we are plotting are arc length.
      vtkSmartPointer<vtkNamedColors> colors =
        vtkSmartPointer<vtkNamedColors>::New();

      vtkSmartPointer<vtkXYPlotActor> xyplot =
        vtkSmartPointer<vtkXYPlotActor>::New();
      xyplot->AddDataSetInputConnection(probe->GetOutputPort());
      xyplot->AddDataSetInputConnection(probe2->GetOutputPort());
      xyplot->AddDataSetInputConnection(probe3->GetOutputPort());
      xyplot->GetPositionCoordinate()->SetValue(0.0, 0.67, 0);
      xyplot->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0); //relative to Position;
      xyplot->SetXValuesToArcLength();
      xyplot->SetNumberOfXLabels(6);
      xyplot->SetTitle("Pressure vs. Arc Length (Zoomed View)");
      xyplot->SetXTitle("");
      xyplot->SetYTitle("P");
      xyplot->SetXRange(.1, .35);
      xyplot->SetYRange(.2, .4);
      xyplot->GetProperty()->SetColor(colors->GetColor3d("Black").GetData());
      xyplot->GetProperty()->SetLineWidth(2);
    // Set text prop color
    // Assign same object to all text props
      vtkTextProperty *tprop = xyplot->GetTitleTextProperty();
      tprop->SetColor(xyplot->GetProperty()->GetColor());
      xyplot->SetAxisTitleTextProperty(tprop);
      xyplot->SetAxisLabelTextProperty(tprop);

    // Create an xy-plot using the output of the 3 probe filters as input.
    // The x-values we are plotting are normalized arc length.
      vtkSmartPointer<vtkXYPlotActor> xyplot2 =
        vtkSmartPointer<vtkXYPlotActor>::New();
      xyplot2->AddDataSetInputConnection(probe->GetOutputPort());
      xyplot2->AddDataSetInputConnection(probe2->GetOutputPort());
      xyplot2->AddDataSetInputConnection(probe3->GetOutputPort());
      xyplot2->GetPositionCoordinate()->SetValue(0.00, 0.33, 0);
      xyplot2->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0); //relative to Position;
      xyplot2->SetXValuesToNormalizedArcLength();
      xyplot2->SetNumberOfXLabels(6);
      xyplot2->SetTitle("Pressure vs. Normalized Arc Length");
      xyplot2->SetXTitle("");
      xyplot2->SetYTitle("P");
      xyplot2->PlotPointsOn();
      xyplot2->PlotLinesOff();
      xyplot2->GetProperty()->SetColor(colors->GetColor3d("Tomato").GetData());
      xyplot2->GetProperty()->SetPointSize(5);
    // Set text prop color
    // Assign same object to all text props
      tprop = xyplot2->GetTitleTextProperty();
      tprop->SetColor(xyplot2->GetProperty()->GetColor());
      xyplot2->SetAxisTitleTextProperty(tprop);
      xyplot2->SetAxisLabelTextProperty(tprop);

    // Create an xy-plot using the output of the 3 probe filters as input.
    // The x-values we are plotting are the underlying point data values.
      vtkSmartPointer<vtkXYPlotActor> xyplot3 =
        vtkSmartPointer<vtkXYPlotActor>::New();
      xyplot3->AddDataSetInputConnection(probe->GetOutputPort());
      xyplot3->AddDataSetInputConnection(probe2->GetOutputPort());
      xyplot3->AddDataSetInputConnection(probe3->GetOutputPort());
      xyplot3->GetPositionCoordinate()->SetValue(0.0, 0.0, 0);
      xyplot3->GetPosition2Coordinate()->SetValue(1.0, 0.33, 0); // relative to Position;
        xyplot3->SetXValuesToIndex();
      xyplot3->SetNumberOfXLabels(6);
      xyplot3->SetTitle("Pressure vs. Point Id");
      xyplot3->SetXTitle("Probe Length");
      xyplot3->SetYTitle("P");
      xyplot3->PlotPointsOn();
      xyplot3->GetProperty()->SetColor(colors->GetColor3d("Peacock").GetData());
      xyplot3->GetProperty()->SetPointSize(3);
    // Set text prop color
    // Assign same object to all text props
      tprop = xyplot3->GetTitleTextProperty();
      tprop->SetColor(xyplot3->GetProperty()->GetColor());
      xyplot3->SetAxisTitleTextProperty(tprop);
      xyplot3->SetAxisLabelTextProperty(tprop);

    // Draw an outline of the PLOT3D data set.
      vtkSmartPointer<vtkStructuredGridOutlineFilter> outline =
        vtkSmartPointer<vtkStructuredGridOutlineFilter>::New();
      outline->SetInputData(pl3d_output);
      vtkSmartPointer<vtkPolyDataMapper> outlineMapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
      outlineMapper->SetInputConnection(outline->GetOutputPort());
      vtkSmartPointer<vtkActor> outlineActor =
        vtkSmartPointer<vtkActor>::New();
      outlineActor->SetMapper(outlineMapper);
      outlineActor->GetProperty()->SetColor(colors->GetColor3d("Black").GetData());

    // Create the Renderers, RenderWindow, and RenderWindowInteractor.
      vtkSmartPointer<vtkRenderer> renderer =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderer> renderer2 =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();
      renderWindow->AddRenderer(renderer);
      renderWindow->AddRenderer(renderer2);
      vtkSmartPointer<vtkRenderWindowInteractor> interactor =
        vtkSmartPointer<vtkRenderWindowInteractor>::New();
      interactor->SetRenderWindow(renderWindow);

    // Set the background, viewport (necessary because we want to have the
    // renderers draw to different parts of the render window) of the first
    // renderer.  Add the outline and line actors to the renderer.
      renderer->SetBackground(colors->GetColor3d("blue_light").GetData());
      renderer->SetViewport(0, 0, .5, 1);
      renderer->AddActor(outlineActor);
      renderer->AddActor(lineActor);

    // Set the background and viewport of the second renderer.  Add the
    // xy-plot actors to the renderer.  Set the size of the render window.
      renderer2->SetBackground(colors->GetColor3d("silver").GetData());
      renderer2->SetViewport(0.5, 0.0, 1.0, 1.0);
      renderer2->AddActor2D(xyplot);
      renderer2->AddActor2D(xyplot2);
      renderer2->AddActor2D(xyplot3);
      renderWindow->SetSize(800, 600);

    // Set up the camera parameters.
      vtkCamera *cam1 = renderer->GetActiveCamera();
      cam1->SetClippingRange(3.95297, 100);
      cam1->SetFocalPoint(8.88908, 0.595038, 29.3342);
      cam1->SetPosition(-12.3332, 31.7479, 41.2387);
      cam1->SetViewUp(0.060772, -0.319905, 0.945498);

      interactor->Initialize();
      renderWindow->Render();
      interactor->Start();

      return EXIT_SUCCESS;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

    project(XYPlot)

    find_package(VTK COMPONENTS
      vtkCommonColor
      vtkCommonCore
      vtkCommonDataModel
      vtkCommonTransforms
      vtkFiltersCore
      vtkFiltersGeneral
      vtkFiltersSources
      vtkIOParallel
      vtkInteractionStyle
      vtkRenderingAnnotation
      vtkRenderingContextOpenGL2
      vtkRenderingCore
      vtkRenderingFreeType
      vtkRenderingGL2PSOpenGL2
      vtkRenderingOpenGL2 QUIET)
    if (NOT VTK_FOUND)
      message("Skipping XYPlot: ${VTK_NOT_FOUND_MESSAGE}")
      return ()
    endif()
    message (STATUS "VTK_VERSION: ${VTK_VERSION}")
    if (VTK_VERSION VERSION_LESS "8.90.0")
      # old system
      include(${VTK_USE_FILE})
      add_executable(XYPlot MACOSX_BUNDLE XYPlot.cxx )
      target_link_libraries(XYPlot PRIVATE ${VTK_LIBRARIES})
    else ()
      # include all components
      add_executable(XYPlot MACOSX_BUNDLE XYPlot.cxx )
      target_link_libraries(XYPlot PRIVATE ${VTK_LIBRARIES})
      # vtk_module_autoinit is needed
      vtk_module_autoinit(
        TARGETS XYPlot
        MODULES ${VTK_LIBRARIES}
        )
    endif ()

### Download and Build XYPlot

Click here to download XYPlot and its CMakeLists.txt file. Once the tarball XYPlot.tar has been downloaded and extracted,

    cd XYPlot/build

If VTK is installed:

    cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

    cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

    make

and run it:

    ./XYPlot

WINDOWS USERS

Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.