/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:FDL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Free Documentation License Usage
** Alternatively, this file may be used under the terms of the GNU Free
** Documentation License version 1.3 as published by the Free Software
** Foundation and appearing in the file included in the packaging of
** this file. Please review the following information to ensure
** the GNU Free Documentation License version 1.3 requirements
** will be met: https://www.gnu.org/licenses/fdl-1.3.html.
** $QT_END_LICENSE$
**
****************************************************************************/

/*!
    \namespace QtDataVisualization
    \inmodule QtDataVisualization
    \brief Contains the classes and enumerations in the Qt Data Visualization
    module.

    \generatelist{classesbymodule QtDataVisualization}
*/

/*!
    \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.2
    \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
    \ingroup all-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
*/

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

    \section1 Series

    A series is a combination of a 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. All graphs can have multiple series added simultaneously.

    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.

    Often the item models will have a single role that contains information you want to map to
    multiple values. A typical example of this is a timestamp field when generating a bar graph
    with two time related axes, for example years and months. To enable mapping a single item
    model role to more than one data field, pattern matching and replacing mechanism is provided
    by item model proxies. You can also use this mechanism to reformat data even in one-to-one
    mapping cases.

    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 unnecessary 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. For the best performance with the scatter graphs, only keep
    the data you need in the proxy.

    Surface data, while on item level similar to scatter data, is already assigned into rows and
    columns, so the surface renderer can optimize drawing by making the assumption that
    the data in the rows and columns is sorted along their respective axes. It is not quite as
    efficient as in the bars case, but nearly so.
*/

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

    \section1 Interacting with Data

    End users can interact with the rendered graph by using either the mouse or
    touch to rotate, zoom, or select data. Graphs can be rotated freely by
    holding down the right mouse button and moving the mouse. Zooming is done by
    rolling the mouse wheel. Selecting, if enabled, is done by pressing the left
    mouse button. The scene can be reset to the default camera view by clicking
    the mouse wheel. In touch devices, rotation is done by tap-and-move,
    selection by tap-and-hold, and zoom by pinch.

    Qt Data Visualization has default handlers for mouse actions and touch
    gestures. For the default mouse controls, see Q3DInputHandler, and for
    the default touch controls, see QTouch3DInputHandler. The default handlers
    must be disabled when using customized input handlers.

    The \l{Custom Input Example} illustrates how to use a custom input handler
    to select items upon mouseover instead of mouse click. The information
    below the mouse cursor is displayed as a popup.

    In addition to perspective projection, orthographic projection can be used
    to create 2D graphs by replacing the default input handler with one that
    does not allow rotating the graph and setting the camera to view the graph
    directly from the side or from the top.

    \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. Bar graph also supports selecting/slicing a whole row and/or
    column by clicking the axis label, based on selection mode.

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

/*!
    \page qtdatavisualization_known_issues.html
    \title Qt Data Visualization Known Issues

    \list
        \li Some platforms like Android and WinRT cannot handle multiple native windows properly,
            so only the Qt Quick 2 graphs are available in practice for those platforms.
        \li Surfaces with non-straight rows and columns do not always render properly.
        \li Q3DLight class (and Light3D QML item) are currently not usable for anything.
        \li Changing most of Q3DScene properties affecting subviewports currently has no effect.
        \li Widget based examples layout incorrectly in iOS.
        \li Reparenting a graph to an item in another QQuickWindow is not supported.
        \li Android builds of QML applications importing QtDataVisualization also require
            "QT += datavisualization" in the pro file. This is because Qt Data Visualization
            QML plugin has a dependency to Qt Data Visualization C++ library, which Qt Creator
            doesn't automatically add to the deployment package.
    \endlist
*/

/*!
 * \fn QSurfaceFormat QtDataVisualization::qDefaultSurfaceFormat(bool antialias)
 * \relates QAbstract3DGraph
 *
 * This convenience function can be used to create a custom surface format suitable for use by
 * Qt Data Visualization graphs.
 *
 * The \a antialias parameter specifies whether or not antialiasing is activated.
 *
 * Give the surface format returned by this function to the graph constructor (C++) or set
 * it as the window format for QQuickView (QML) before calling \c show() on it.
 *
 * For example, disable antialiasing on C++ application:
 *
 * \code
 * #include <QtDataVisualization/qutils.h>
 *
 * // ...
 *
 * Q3DBars *graph = new Q3DBars(QtDataVisualization::qDefaultSurfaceFormat(false));
 * \endcode
 *
 * For example, enable antialiasing for direct rendering modes on QML application:
 *
 * \code
 * #include <QtDataVisualization/qutils.h>
 *
 * // ...
 *
 * QQuickView viewer;
 * viewer.setFormat(QtDataVisualization::qDefaultSurfaceFormat());
 * \endcode
 *
 * \note Antialiasing is not supported in OpenGL ES2 environments.
 */
