VS2019+CMake+Vtk9.3.0+Qt5.14.2 配置

VS2019+CMake+Vtk9.3.0+Qt5.14.2 配置环境

第一步 下载

基本配置

• 系统环境：windows11 x64

• Qt：5.14.2

  这是最后最新的LTS qt离线版本，后续版本都需要在线安装，同时使用qt5.14也避免版权问题。

  • Qt 5.14：大部分模块基于LGPL v3许可，允许以动态链接的方式使用而不公开源码，适合开发闭源、商业软件。
  • Qt 6：虽然也提供LGPL v3和GPL许可，但部分模块在GPL下提供，可能会有更严格的开源要求。此外，Qt 6的早期版本中缺少了一些模块，如图表、数据可视化和WebEngine，这可能会影响某些应用的开发

• VTK：9.3.0

  VTK 9.3.0 发布于 2023 年 11 月 9 日

• CMake：3.29

  CMake 3.29发布于 2024 年 3 月 26 日

• VS2019

  因为qt5.14 默认使用msvc2017，也就是VS2019的编译器，虽说通过一些设置也可以在VS2022跑起来，不过图省事，还是使用VS2019了。

下载链接

链接：https://pan.baidu.com/s/1lbwPTIx-FKuVxX54AbzXGw?pwd=3cyi
提取码：3cyi

安装Qt

运行qt-opensource-windows-x86-5.14.2.exe , 注意安装路径下不要用中文，也不要有空格！

设置好路径，一路next，只有这里需要稍微注意下

安装CMake

略

安装VS2019

运行vs_community__2019.exe

安装c++桌面开发即可

第二步 编译VTK

过程相当痛苦，所以我才写这个攻略 orz

配置CMake

1.初步Configure

qt配置

检查qt的配置项，注意标红的几点，如果没有Qt附带的拿下Dir，设置好Qt5_Dir后再Configure一次，应该都会刷新出来。

另外如果你安装了anaconda，你的qt里面可能会是anaconda里的qt路径，需要更新正确。

安装位置

自定义一个安装位置，这是后续编译好的库文件和头文件的存放位置。

2.Generate

点击generate， 会在build文件夹下生成VTK.sln,使用VS2019打开该解决方案。

3.进入VS生成

编译时选择【生成->批生成】

先生成Debug和Release的库

编译时间视个人配置各不相同。几十分钟到几小时不等。

生成好后再进行批安装。

一切顺利的话，安装结果如下：

如果实在嫌麻烦也可以使用我已经编译好的库，下载链接里也有。

FAQ:

1. FilterReduction报错重编译的解决方法

https://blog.csdn.net/martian665/article/details/139340218

加上/force(注意空格)

不过/force 只是强制link，可能会导致别的问题。

2. 获取当前目录下lib的名称

将下面的代码写入文件，修改后缀名bat。运行即可得。

@echo off
dir /b *.lib > lib_files.txt
echo "All *.lib file names have been written to lib_files.txt"
1
2
3

第三部 配置

配置环境变量（否则运行时有问题）

环境变量->Path里加上如下bin的路径，具体需要根据你自己的安装位置做适配

• D:\Program Files\CMake\bin
• D:\Dev\VTK\bin
• D:\Qt5\Qt5.14.2\5.14.2\msvc2017_64\bin
• D:\Qt5\Qt5.14.2\5.14.2\msvc2017\bin

第四部 测试demo

demo1简单图形

CMakelists

cmake_minimum_required(VERSION 3.12 FATAL_ERROR)

project(Tutorial_Step1)

find_package(VTK COMPONENTS 
  CommonColor
  CommonCore
  FiltersSources
  InteractionStyle
  RenderingContextOpenGL2
  RenderingCore
  RenderingFreeType
  RenderingGL2PSOpenGL2
  RenderingOpenGL2
)

if (NOT VTK_FOUND)
  message(FATAL_ERROR "Tutorial_Step1: Unable to find the VTK build folder.")
endif()

# 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.")
add_executable(Tutorial_Step1 MACOSX_BUNDLE Tutorial_Step1.cpp )
  target_link_libraries(Tutorial_Step1 PRIVATE ${VTK_LIBRARIES}
)
# vtk_module_autoinit is needed
vtk_module_autoinit(
  TARGETS Tutorial_Step1
  MODULES ${VTK_LIBRARIES}
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Tutorial_Step1.cpp

#include"vtkSmartPointer.h"
#include"vtkPolyData.h"
#include "vtkType.h"
#include "vtkPoints.h"
#include "vtkCellArray.h"
#include "vtkFloatArray.h"
#include "vtkPolyData.h"
#include "vtkPointData.h"
#include "vtkPolyDataMapper.h"
#include "vtkActor.h"
#include "vtkProperty.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif
#define CIR_CUT (100.0)
namespace Data
{
	//存放点集
	using Point = std::vector<double>;
	using Pointlist = std::vector<Point>;
	//绘制面的索引
	using Triangular = std::vector<vtkIdType>;
	using TriangularList = std::vector<Triangular>;
}
int main()
{

	//设置内环,外环半径
	double Rinner = 20.0;
	double Rexcir = 40.0;

	Data::Pointlist mPointlist;
	Data::TriangularList mTriangularList;
	//
	std::vector<double> angles;
	angles.reserve(CIR_CUT + 1);
	double angleInterval = (2 * M_PI) / CIR_CUT;
	for (auto i = 0; i <= CIR_CUT; i++)
		angles.push_back(i * angleInterval);
	//生成点集和三角面
	for (auto index = 0; index < CIR_CUT; index++)
	{
		__int64 lastsize = mPointlist.size();
		Data::Point p1 = { Rinner * cos(angles[index]), Rinner * sin(angles[index]), 0.0 };
		Data::Point p2 = { Rinner * cos(angles[index + 1]), Rinner * sin(angles[index + 1]), 0.0 };
		Data::Point p3 = { Rexcir * cos(angles[index + 1]), Rexcir * sin(angles[index + 1]), 0.0 };
		Data::Point p4 = { Rexcir * cos(angles[index]), Rexcir * sin(angles[index]), 0.0 };
		Data::Triangular f1 = { 0 + lastsize, 1 + lastsize, 2 + lastsize };
		Data::Triangular f2 = { 2 + lastsize, 3 + lastsize, 0 + lastsize };
		mPointlist.push_back(p1);
		mPointlist.push_back(p2);
		mPointlist.push_back(p3);
		mPointlist.push_back(p4);
		mTriangularList.push_back(f1);
		mTriangularList.push_back(f2);
	}

	//可视化流程
	//source源，绘制图形的基本数据
	vtkSmartPointer<vtkPoints> cirpoints = vtkSmartPointer<vtkPoints>::New();
	vtkSmartPointer<vtkCellArray> cellarray = vtkSmartPointer<vtkCellArray>::New();
	vtkSmartPointer<vtkFloatArray> calaes = vtkSmartPointer<vtkFloatArray>::New();
	for (__int64 index = 0; index < mPointlist.size(); index++)
	{
		cirpoints->InsertPoint(index, mPointlist[index].data());
		calaes->InsertTuple1(index, index);
	}
	for (auto&& i : mTriangularList)
		cellarray->InsertNextCell(vtkIdType(i.size()), i.data());

	vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
	polydata->SetPoints(cirpoints);
	polydata->SetPolys(cellarray);
	polydata->GetPointData()->SetScalars(calaes);
	//过滤器--这里没有使用,可以跳过

	//映射器通过将数据表现为有形的几何图形
	vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
	mapper->SetInputData(polydata);
	mapper->SetScalarRange(polydata->GetScalarRange());
	//关闭根据标量设置颜色
	mapper->ScalarVisibilityOff();

	//表演者 调整可见的属性
	vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
	actor->SetMapper(mapper);
	actor->GetProperty()->SetColor(1.0, 0.5, 1.0);
	//渲染器
	vtkSmartPointer<vtkRenderer> render = vtkSmartPointer<vtkRenderer>::New();
	render->AddActor(actor);
	//渲染窗口
	vtkSmartPointer<vtkRenderWindow> rw = vtkSmartPointer<vtkRenderWindow>::New();
	rw->AddRenderer(render);
	//渲染窗口交互器
	vtkSmartPointer<vtkRenderWindowInteractor> ri = vtkSmartPointer<vtkRenderWindowInteractor>::New();
	ri->SetRenderWindow(rw);
	actor->GetProperty()->SetRepresentationToWireframe();//显示边框
	rw->Render();
	ri->Start();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

demo2 MinimalQtVTKApp

VTK+Qt

CMakelists

cmake_minimum_required(VERSION 3.12 FATAL_ERROR)

if(POLICY CMP0020)
  cmake_policy(SET CMP0020 NEW)
  cmake_policy(SET CMP0071 NEW)
endif()

PROJECT(MinimalQtVTKApp)

find_package(VTK COMPONENTS 
  CommonCore
  CommonDataModel
  FiltersSources
  GUISupportQt
  InteractionStyle
  RenderingContextOpenGL2
  RenderingCore
  RenderingFreeType
  RenderingGL2PSOpenGL2
  RenderingOpenGL2
  GUISupportQt
  RenderingQt
)

if(NOT VTK_FOUND)
  message(FATAL_ERROR "MinimalQtVTKApp: Unable to find the VTK build folder.")
endif()

if(NOT(TARGET VTK::GUISupportQt))
  message(FATAL_ERROR "MinimalQtVTKApp: 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(MinimalQtVTKApp MACOSX_BUNDLE
  ${CXX_FILES} ${UISrcs} ${QT_WRAP}
)
if (Qt${VTK_QT_VERSION}Widgets_VERSION VERSION_LESS "5.11.0")
  qt5_use_modules(MinimalQtVTKApp ${qt_components})
else()
  target_link_libraries(MinimalQtVTKApp ${qt_modules})
endif()
target_link_libraries(MinimalQtVTKApp ${VTK_LIBRARIES})
# vtk_module_autoinit is needed
vtk_module_autoinit(
  TARGETS MinimalQtVTKApp
  MODULES ${VTK_LIBRARIES}
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

MinimalQtVTKApp.cpp

#include <QVTKOpenGLNativeWidget.h>
#include <vtkActor.h>
#include <vtkDataSetMapper.h>
#include <vtkDoubleArray.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkPointData.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkSphereSource.h>

#include <QApplication>
#include <QDockWidget>
#include <QGridLayout>
#include <QLabel>
#include <QMainWindow>
#include <QPointer>
#include <QPushButton>
#include <QVBoxLayout>

#include <cmath>
#include <cstdlib>
#include <random>

namespace {
/**
 * Deform the sphere source using a random amplitude and modes and render it in
 * the window
 *
 * @param sphere the original sphere source
 * @param mapper the mapper for the scene
 * @param window the window to render to
 * @param randEng the random number generator engine
 */
void Randomize(vtkSphereSource* sphere, vtkMapper* mapper,
               vtkGenericOpenGLRenderWindow* window, std::mt19937& randEng);
} // namespace

int main(int argc, char* argv[])
{
  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());

  QApplication app(argc, argv);

  // Main window.
  QMainWindow mainWindow;
  mainWindow.resize(1200, 900);

  // Control area.
  QDockWidget controlDock;
  mainWindow.addDockWidget(Qt::LeftDockWidgetArea, &controlDock);

  QLabel controlDockTitle("Control Dock");
  controlDockTitle.setMargin(20);
  controlDock.setTitleBarWidget(&controlDockTitle);

  QPointer<QVBoxLayout> dockLayout = new QVBoxLayout();
  QWidget layoutContainer;
  layoutContainer.setLayout(dockLayout);
  controlDock.setWidget(&layoutContainer);

  QPushButton randomizeButton;
  randomizeButton.setText("Randomize");
  dockLayout->addWidget(&randomizeButton);

  // Render area.
  QPointer<QVTKOpenGLNativeWidget> vtkRenderWidget =
      new QVTKOpenGLNativeWidget();
  mainWindow.setCentralWidget(vtkRenderWidget);

  // VTK part.
  vtkNew<vtkGenericOpenGLRenderWindow> window;
  vtkRenderWidget->setRenderWindow(window.Get());

  vtkNew<vtkSphereSource> sphere;
  sphere->SetRadius(1.0);
  sphere->SetThetaResolution(100);
  sphere->SetPhiResolution(100);

  vtkNew<vtkDataSetMapper> mapper;
  mapper->SetInputConnection(sphere->GetOutputPort());

  vtkNew<vtkActor> actor;
  actor->SetMapper(mapper);
  actor->GetProperty()->SetEdgeVisibility(true);
  actor->GetProperty()->SetRepresentationToSurface();

  vtkNew<vtkRenderer> renderer;
  renderer->AddActor(actor);

  window->AddRenderer(renderer);

  // Setup initial status.
  std::mt19937 randEng(0);
  ::Randomize(sphere, mapper, window, randEng);

  // connect the buttons
  QObject::connect(&randomizeButton, &QPushButton::released,
                   [&]() { ::Randomize(sphere, mapper, window, randEng); });

  mainWindow.show();

  return app.exec();
}

namespace {
void Randomize(vtkSphereSource* sphere, vtkMapper* mapper,
               vtkGenericOpenGLRenderWindow* window, std::mt19937& randEng)
{
  // Generate randomness.
  double randAmp = 0.2 + ((randEng() % 1000) / 1000.0) * 0.2;
  double randThetaFreq = 1.0 + (randEng() % 9);
  double randPhiFreq = 1.0 + (randEng() % 9);

  // Extract and prepare data.
  sphere->Update();
  vtkSmartPointer<vtkPolyData> newSphere;
  newSphere.TakeReference(sphere->GetOutput()->NewInstance());
  newSphere->DeepCopy(sphere->GetOutput());
  vtkNew<vtkDoubleArray> height;
  height->SetName("Height");
  height->SetNumberOfComponents(1);
  height->SetNumberOfTuples(newSphere->GetNumberOfPoints());
  newSphere->GetPointData()->AddArray(height);

  // Deform the sphere.
  for (int iP = 0; iP < newSphere->GetNumberOfPoints(); iP++)
  {
    double pt[3] = {0.0};
    newSphere->GetPoint(iP, pt);
    double theta = std::atan2(pt[1], pt[0]);
    double phi =
        std::atan2(pt[2], std::sqrt(std::pow(pt[0], 2) + std::pow(pt[1], 2)));
    double thisAmp =
        randAmp * std::cos(randThetaFreq * theta) * std::sin(randPhiFreq * phi);
    height->SetValue(iP, thisAmp);
    pt[0] += thisAmp * std::cos(theta) * std::cos(phi);
    pt[1] += thisAmp * std::sin(theta) * std::cos(phi);
    pt[2] += thisAmp * std::sin(phi);
    newSphere->GetPoints()->SetPoint(iP, pt);
  }
  newSphere->GetPointData()->SetScalars(height);

  // Reconfigure the pipeline to take the new deformed sphere.
  mapper->SetInputDataObject(newSphere);
  mapper->SetScalarModeToUsePointData();
  mapper->ColorByArrayComponent("Height", 0);
  window->Render();
}
} // namespace
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

成功结果

点击 Randomize 可以切换渲染模型