BarChartQt
Repository source: BarChartQt
Description¶
This example shows how to create a Bar Chart.
Also see the BarChart example.
Question
If you have a question about this example, please use the VTK Discourse Forum
Code¶
BarChartQt.cxx
#include "BarChartQt.h"
#include "ui_BarChartQt.h"
#include <vtkAxis.h>
#include <vtkChartXY.h>
#include <vtkContextView.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkIntArray.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPlot.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkTable.h>
#include <vtkTextProperty.h>
#include <vtkVersion.h>
#include <array>
#include <iostream>
#include <string>
#if VTK_VERSION_NUMBER >= 89000000000ULL
#define VTK890 1
#endif
#if VTK_VERSION_NUMBER >= 90000000000ULL
#define VTK900 1
#endif
namespace {
// Monthly circulation data.
int data_2008[] = {10822, 10941, 9979, 10370, 9460, 11228,
15093, 12231, 10160, 9816, 9384, 7892};
int data_2009[] = {9058, 9474, 9979, 9408, 8900, 11569,
14688, 12231, 10294, 9585, 8957, 8590};
int data_2010[] = {9058, 10941, 9979, 10270, 8900, 11228,
14688, 12231, 10160, 9585, 9384, 8590};
} // namespace
// Constructor
BarChartQt::BarChartQt(QWidget* parent)
: QMainWindow(parent), ui(new Ui::BarChartQt)
{
this->ui->setupUi(this);
vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
#if VTK890
this->ui->qvtkWidget->setRenderWindow(renderWindow);
#else
this->ui->qvtkWidget->SetRenderWindow(renderWindow);
#endif
vtkNew<vtkNamedColors> colors;
vtkColor3d backgroundColor = colors->GetColor3d("Seashell");
vtkColor3d axisColor = colors->GetColor3d("Black");
vtkColor3d titleColor = colors->GetColor3d("MidnightBlue");
vtkNew<vtkChartXY> chart;
// Set various properties.
vtkAxis* xAxis = chart->GetAxis(vtkAxis::BOTTOM);
xAxis->SetTitle("Monthly");
xAxis->GetTitleProperties()->SetColor(axisColor.GetData());
xAxis->GetTitleProperties()->SetFontSize(16);
xAxis->GetTitleProperties()->ItalicOn();
xAxis->GetLabelProperties()->SetColor(axisColor.GetData());
xAxis->SetGridVisible(true);
xAxis->GetGridPen()->SetColor(colors->GetColor4ub("Black"));
vtkAxis* yAxis = chart->GetAxis(vtkAxis::LEFT);
yAxis->SetTitle("Circulation");
yAxis->GetTitleProperties()->SetColor(axisColor.GetData());
yAxis->GetTitleProperties()->SetFontSize(16);
yAxis->GetTitleProperties()->ItalicOn();
yAxis->GetLabelProperties()->SetColor(axisColor.GetData());
yAxis->SetGridVisible(true);
yAxis->GetGridPen()->SetColor(colors->GetColor4ub("Black"));
chart->SetTitle("Circulation 2008, 2009, 2010");
chart->GetTitleProperties()->SetFontSize(24);
chart->GetTitleProperties()->SetColor(titleColor.GetData());
chart->GetTitleProperties()->BoldOn();
// Set up a 2D scene, add an XY chart to it
vtkNew<vtkContextView> view;
view->SetRenderWindow(renderWindow);
view->GetRenderer()->SetBackground(backgroundColor.GetData());
view->GetRenderWindow()->SetSize(640, 480);
view->GetScene()->AddItem(chart);
// Create a table with some points in it...
vtkNew<vtkTable> table;
vtkNew<vtkIntArray> arrMonth;
arrMonth->SetName("Month");
table->AddColumn(arrMonth);
vtkNew<vtkIntArray> arr2008;
arr2008->SetName("2008");
table->AddColumn(arr2008);
vtkNew<vtkIntArray> arr2009;
arr2009->SetName("2009");
table->AddColumn(arr2009);
vtkNew<vtkIntArray> arr2010;
arr2010->SetName("2010");
table->AddColumn(arr2010);
table->SetNumberOfRows(12);
for (int i = 0; i < 12; i++)
{
table->SetValue(i, 0, i + 1);
table->SetValue(i, 1, data_2008[i]);
table->SetValue(i, 2, data_2009[i]);
table->SetValue(i, 3, data_2010[i]);
}
// Add multiple line plots, setting the colors etc.
vtkPlot* line = 0;
line = chart->AddPlot(vtkChart::BAR);
line->SetInputData(table, 0, 1);
auto rgba = colors->GetColor4ub("YellowGreen");
line->SetColor(rgba[0], rgba[1], rgba[2], rgba[3]);
line = chart->AddPlot(vtkChart::BAR);
line->SetInputData(table, 0, 2);
rgba = colors->GetColor4ub("Salmon");
line->SetColor(rgba[0], rgba[1], rgba[2], rgba[3]);
line = chart->AddPlot(vtkChart::BAR);
line->SetInputData(table, 0, 3);
rgba = colors->GetColor4ub("CornflowerBlue");
line->SetColor(rgba[0], rgba[1], rgba[2], rgba[3]);
view->GetRenderWindow()->SetMultiSamples(0);
#if !defined(VTK900)
view->SetInteractor(this->ui->qvtkWidget->GetInteractor());
#endif
// VTK/Qt wedded
#if VTK890
this->ui->qvtkWidget->setRenderWindow(view->GetRenderWindow());
#else
this->ui->qvtkWidget->SetRenderWindow(view->GetRenderWindow());
#endif
// Set up action signals and slots.
connect(this->ui->actionExit, SIGNAL(triggered()), this, SLOT(slotExit()));
}
BarChartQt::~BarChartQt()
{
delete this->ui;
}
void BarChartQt::slotExit()
{
std::cout << "Exiting" << std::endl;
qApp->exit();
}
BarChartQtDriver.cxx
#include <QApplication>
#include <QSurfaceFormat>
#include <QVTKOpenGLNativeWidget.h>
#include "BarChartQt.h"
int main(int argc, char* argv[])
{
// Needed to ensure appropriate OpenGL context is created for VTK rendering.
QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
// QT Stuff
QApplication app(argc, argv);
BarChartQt BarChartQt;
BarChartQt.show();
return app.exec();
}
BarChartQt.ui
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>BarChartQt</class>
<widget class="QMainWindow" name="BarChartQt">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>660</width>
<height>520</height>
</rect>
</property>
<property name="windowTitle">
<string>BarChartQt</string>
</property>
<widget class="QWidget" name="centralwidget">
<widget class="QVTKOpenGLNativeWidget" name="qvtkWidget">
<property name="geometry">
<rect>
<x>10</x>
<y>20</y>
<width>640</width>
<height>480</height>
</rect>
</property>
</widget>
</widget>
<action name="actionOpenFile">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Open File...</string>
</property>
</action>
<action name="actionExit">
<property name="text">
<string>Exit</string>
</property>
</action>
<action name="actionPrint">
<property name="text">
<string>Print</string>
</property>
</action>
<action name="actionHelp">
<property name="text">
<string>Help</string>
</property>
</action>
<action name="actionSave">
<property name="text">
<string>Save</string>
</property>
</action>
</widget>
<customwidgets>
<customwidget>
<class>QVTKOpenGLNativeWidget</class>
<extends>QWidget</extends>
<header>QVTKOpenGLNativeWidget.h</header>
</customwidget>
</customwidgets>
<resources>
</resources>
<connections/>
</ui>
BarChartQt.h
#ifndef BarChartQt_H
#define BarChartQt_H
#include <QMainWindow>
/*
* See "The Single Inheritance Approach" in this link:
* [Using a Designer UI File in Your C++
* Application](https://doc.qt.io/qt-5/designer-using-a-ui-file.html)
*/
namespace Ui {
class BarChartQt;
}
class BarChartQt : public QMainWindow
{
Q_OBJECT
public:
// Constructor/Destructor
explicit BarChartQt(QWidget* parent = nullptr);
virtual ~BarChartQt();
public slots:
void slotExit();
private:
// Designer form
Ui::BarChartQt* ui = nullptr;
};
#endif
CMakeLists.txt¶
cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
if(POLICY CMP0020)
cmake_policy(SET CMP0020 NEW)
cmake_policy(SET CMP0071 NEW)
endif()
PROJECT(BarChartQt)
find_package(VTK COMPONENTS
ChartsCore
CommonColor
CommonCore
CommonDataModel
InteractionStyle
RenderingContextOpenGL2
RenderingCore
RenderingFreeType
RenderingGL2PSOpenGL2
RenderingOpenGL2
ViewsContext2D
GUISupportQt
RenderingQt
)
if(NOT VTK_FOUND)
message(FATAL_ERROR "BarChartQt: Unable to find the VTK build folder.")
endif()
if(NOT(TARGET VTK::GUISupportQt))
message(FATAL_ERROR "BarChartQt: VTK not built with Qt support.")
endif()
if(NOT DEFINED VTK_QT_VERSION)
set(VTK_QT_VERSION 5)
endif()
set(qt_components Core Gui Widgets)
if(${VTK_QT_VERSION} VERSION_GREATER_EQUAL 6)
list(APPEND qt_components OpenGLWidgets)
endif()
list(SORT qt_components)
# We have ui files, so this will also bring in the macro:
# qt5_wrap_ui or qt_wrap_ui from Widgets.
find_package(Qt${VTK_QT_VERSION} QUIET
REQUIRED COMPONENTS ${qt_components}
)
foreach(_qt_comp IN LISTS qt_components)
list(APPEND qt_modules "Qt${VTK_QT_VERSION}::${_qt_comp}")
endforeach()
message (STATUS "VTK_VERSION: ${VTK_VERSION}, Qt Version: ${Qt${VTK_QT_VERSION}Widgets_VERSION}")
# Instruct CMake to run moc and uic automatically when needed.
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
file(GLOB UI_FILES *.ui)
file(GLOB QT_WRAP *.h)
file(GLOB CXX_FILES *.cxx)
# For VTK versions greater than or equal to 8.90.0:
# CMAKE_AUTOUIC is ON so we handle uic automatically for Qt targets.
# CMAKE_AUTOMOC is ON so we handle moc automatically for Qt targets.
# Prevent a "command line is too long" failure in Windows.
set(CMAKE_NINJA_FORCE_RESPONSE_FILE "ON" CACHE BOOL "Force Ninja to use response files.")
# CMAKE_AUTOMOC in ON so the MOC headers will be automatically wrapped.
add_executable(BarChartQt MACOSX_BUNDLE
${CXX_FILES} ${UI_FILES} ${QT_WRAP}
)
if (Qt${VTK_QT_VERSION}Widgets_VERSION VERSION_LESS "5.11.0")
qt5_use_modules(BarChartQt ${qt_components})
else()
target_link_libraries(BarChartQt ${qt_modules})
endif()
target_link_libraries(BarChartQt ${VTK_LIBRARIES})
# vtk_module_autoinit is needed
vtk_module_autoinit(
TARGETS BarChartQt
MODULES ${VTK_LIBRARIES}
)
Download and Build BarChartQt¶
Click here to download BarChartQt and its CMakeLists.txt file. Once the tarball BarChartQt.tar has been downloaded and extracted,
cd BarChartQt/build
This example requires Qt and VTK.
If VTK and Qt are 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=/home/me/vtk_build ..
If Qt is not found on your system, you will need to tell CMake where to find qmake:
cmake -DQT_QMAKE_EXECUTABLE:FILEPATH=/usr/something/qmake ..
Build the project:
make
and run it:
./BarChartQt
WINDOWS USERS
Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time. You may also need to add a Qt related path.