summaryrefslogtreecommitdiffstats
path: root/src/datavisualization/doc/src/qtdatavisualization.qdoc
blob: 9c951877a8a20cacff3abff5b842e1ef17cc7271 (plain)
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc
** All rights reserved.
** For any questions to Digia, please use contact form at http://qt.digia.com
**
** This file is part of the QtDataVisualization module.
**
** Licensees holding valid Qt Enterprise licenses may use this file in
** accordance with the Qt Enterprise License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.
**
** If you have questions regarding the use of this file, please use
** contact form at http://qt.digia.com
**
****************************************************************************/

/*!
    \module QtDataVisualization
    \title Qt Data Visualization C++ Classes
    \ingroup modules

    \brief C++ classes for the Qt Data Visualization API.

    The Qt Data Visualization functionality can be accessed via these C++ classes.
*/

/*!
    \qmlmodule QtDataVisualization 1.0
    \title Qt Data Visualization QML Types
    \ingroup qmlmodules

    \brief QML types for the Qt Data Visualization API.

    The Qt Data Visualization functionality can be accessed via these QML types.

    \section1 QML Types
*/

/*!
    \group datavisualization_examples
    \title Qt Data Visualization Examples

    \brief Examples for the Qt Data Visualization.

    For some code examples, see one of the Qt Data Visualization examples:

    \section1 Examples

    \annotatedlist qtdatavisualization_examples
*/

/*!
    \group qtdatavisualization_getting_started
    \title Qt Data Visualization Getting Started

    \section1 Building Qt Data Visualization

    To build the Qt Data Visualization module, set up a command prompt with an environment for
    building Qt applications, navigate to the directory containing \c qtdatavisualization.pro, and
    configure the project with qmake:
    \code
    qmake
    \endcode

    After running qmake, build the project with make:
    \table
    \header
      \li OS                       \li Make command
    \row
      \li Linux                    \li make
    \row
      \li Windows (MinGw)          \li mingw32-make
    \row
      \li Windows (MSVC)           \li nmake
    \row
      \li OSX                      \li make
    \endtable

    The above generates the default makefiles for your configuration, which is typically
    the release build if you are using precompiled binary Qt distribution. To build both debug
    and release, or one specifically, use one of the following qmake lines instead.

    For debug builds:
    \code
    qmake CONFIG+=debug
    make
    \endcode
    or
    \code
    qmake CONFIG+=debug_and_release
    make debug
    \endcode

    For release builds:
    \code
    qmake CONFIG+=release
    make
    \endcode
    or
    \code
    qmake CONFIG+=debug_and_release
    make release
    \endcode

    For both builds (Windows/Mac only):
    \code
    qmake CONFIG+="debug_and_release build_all"
    make
    \endcode

    After building, install the module to your Qt directory:
    \code
    make install
    \endcode

    If you want to uninstall the module:
    \code
    make uninstall
    \endcode

    To build a statically linked version of the Qt Data Visualization module, give the following
    commands:

    \snippet doc_src_qtdatavisualization.cpp 7

    \section1 Running examples

    Qt Data Visualization examples are found under the \c examples subdirectory. To build and run a
    single example, for example, the qmlsurface example, navigate to the example directory and enter the
    following commands:

    \snippet doc_src_qtdatavisualization.cpp 8

    \note On some platforms, such as Windows, the executable can be generated under debug or
    release folders, depending on your build.

    \section1 Creating a simple application

    To create a simple application, start by creating a new Qt Gui Application project in Qt
    Creator and add this line to the \c .pro file of the project:

    \snippet doc_src_qtdatavisualization.pro 0

    In the \c main.cpp file, include the module headers and declare namespace usage:

    \snippet doc_src_qtdatavisualization.cpp 0

    Then, add the sample code found in one of the following pages, depending on what kind of
    visualization you are interested in:
    \l{How to construct a minimal Q3DBars graph},
    \l{How to construct a minimal Q3DScatter graph}, or
    \l{How to construct a minimal Q3DSurface graph}.

    To use Qt Data Visualization graphs in widget based applications, you can use
    the QWidget::createWindowContainer() function to wrap the graph into a widget:

    \snippet doc_src_qtdatavisualization.cpp 9

    For further code examples, see one of the Qt Data Visualization examples:

    \annotatedlist qtdatavisualization_examples
*/

/*!
    \page qtdatavisualization_data_handling.html
    \title Qt Data Visualization Data Handling

    \section1 Series

    Series is combination of logically connected set of data items (handled by a data proxy)
    and visual properties that describe how the data items should be rendered, such as item
    meshes and colors. Each visualization type has its own series type. For example, bar graphs
    use QBar3DSeries. Bar and scatter graphs can have multiple series added simultaneously.
    Surface graphs support only a single series at a time.

    This code snippet shows how to use QBar3DSeries to render bars as cylinders and with a
    gradient instead of a uniform color:

    \snippet doc_src_qtdatavisualization.cpp 11

    \section1 Data proxies

    The data that users wish to visualize comes in many formats, all of which cannot obviously be
    directly supported. Therefore, Qt Data Visualization implements data proxies into which
    user can feed their data in a known format. Each visualization type has a basic proxy type,
    which takes data in a format suitable for that visualization.
    For example, the basic proxy for QBar3DSeries is QBarDataProxy, which stores rows of QBarDataItem
    objects. Each QBarDataItem stores a single bar value. Additional typedefs are provided for
    \c QBarDataArray and \c QBarDataRow containers.

    This code snippet shows how to use basic proxy when your data is stored in some hypothetical
    \c myData object:

    \snippet doc_src_qtdatavisualization.cpp 10

    \note Series objects can own only a single proxy at a time. The existing proxy is deleted
    when another is set to the series. Graphs can contain multiple series, though.
    If you need to switch back and forth between two different sets of data,
    it is usually more efficient to store each set in a different series and just change the series,
    rather than reset the data in one proxy every time you need to switch.

    \section1 Item models and data mapping

    For common use cases, Qt Data Visualization offers specialized proxies. One such case is having
    data in an item model (QAbstractItemModel subclass), which is a common way to store data in
    Qt applications. Each of the visualization types offers a special proxy class for this purpose,
    for example, QItemModelBarDataProxy for QBar3DSeries.
    These proxies are simple to use: just give them a pointer to the item model containing the
    data and the rules how to map the data into format the basic proxy can digest.

    Mapping works with item model roles. Each data item in the model can have different
    values for different roles. For example, with QItemModelBarDataProxy you can specify which
    role is used to determine which row the item belongs to, which role does the same for columns,
    and which role specifies the value of the item. When the proxy resolves the data from the model,
    it uses these mappings to generate the rows and columns of the bar graph.

    Depending on the visualization type, proxies may support other functionalities as well,
    such as QItemModelBarDataProxy optionally mapping QAbstractItemModel rows and columns directly
    into bar graph rows and columns. See individual proxy classes for more information and examples
    about how to use them: QItemModelBarDataProxy, QItemModelScatterDataProxy, and
    QItemModelSurfaceDataProxy.

    \section1 Other custom proxies

    QHeightMapSurfaceDataProxy is a specialized proxy for generating a surface graph from a
    heightmap image. See the QHeightMapSurfaceDataProxy documentation for more information.

    The \l{Custom Proxy Example}{Custom Proxy} example shows how a custom proxy can be created. It
    defines a custom data set based on variant lists and an extension of the basic proxy to resolve
    that data with an associated mapper.

    \section1 Dealing with real-time data

    When you have a data set that updates rapidly, it is important to handle data properly to
    ensure good performance. Since memory allocation is a costly operation, always use
    QList::reserve() and QVector::resize() where possible to avoid reallocations when constructing
    the array to give to the proxy. If you need to change the entire data set for each frame,
    it is in most cases best to reuse the existing array - especially if the array dimensions do not
    change. If you need to add, insert, remove, or change several rows or items for each frame, it
    is always more efficient to do it with one method call instead of multiple calls affecting
    a single row or item each. For example, adding ten rows with a single QBarDataProxy::addRows() call
    is much more efficient than ten separate QBarDataProxy::addRow() calls.

    Bars renderer is optimized to access only data that is within the data window and thus should not
    suffer noticeable slowdown even if more data is continually added to the proxy.

    Due to the unsorted nature of the scatter data, any change in the data window ranges requires
    all data points to be checked for visibility, which can cause increasing slowdown if data is
    continually added to the proxy.

    Surface data, while on item level similar to scatter data, is already assigned into rows and
    columns, so the surface renderer can do some optimization by making the assumption that the data in
    rows and columns is sorted along their respective axes, but it is nowhere near as efficient
    as in the bars case. Surface rendering can suffer significant slowdown if the data size grows unchecked.

    For the best performance with the scatter and surface graphs, only keep the data you need in the
    proxy.
*/

/*!
    \page qtdatavisualization_interacting_with_data.html
    \title Qt Data Visualization Interacting with Data

    \section1 Interacting with data

    You can interact with the rendered graph with either mouse or touch to rotate, zoom, or select
    data. For the default mouse controls, see Q3DInputHandler documentation, and for the default
    touch controls, see QTouch3DInputHandler documentation.

    \section1 Data selection modes

    All visualization types support selecting a single data item - a bar, a scatter item, or a surface
    vertex - using mouse, touch, and programmatically via the series APIs. The selected item is highlighted
    in the rendered graph, and selecting causes emission of a series specific signal for this purpose,
    for example, QBar3DSeries::selectedBarChanged(), which the application can handle.

    Bar and surface graphs support slice selection modes, where the selected row or column is drawn
    in a separate viewport as a pseudo-2D graph. This makes it easier to see the actual values of
    a single row or column.

    Bar graph additionally supports simply highlighting the whole row and/or column of the selected bar
    without opening the slice view.

    When multiple series are added to a graph, selecting an item in one of them will clear the selection
    on other series.
*/