mirrors/JKQtPlotter
1
0
Fork 0
mirror of https://github.com/jkriege2/JKQtPlotter.git synced 2024-12-24 17:41:39 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

extensive renaming of classes --> using a unified CamelCase-Scheme now for class/function names

Browse Source
This commit is contained in:
jkriege2 2019-01-20 10:49:29 +01:00
parent 306436f770
commit 86c2f3fa76
176 changed files with 4618 additions and 4623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
README.md
View File

@ -1,11 +1,11 @@
# JKQtPlotter - A Qt Plotting Library
# JKQTPLotter - A Qt Plotting Library
This is an extensive library of function/data plotter classes for Qt (>= 4.7, tested with Qt up to 5.11).
This software is licensed under the term of the [GNU Lesser General Public License 2.1
(LGPL 2.1)](./LICENSE) or above.
## Main Features
- 2D Plotter class (JKQtPlotter)
- 2D Plotter class (JKQTPLotter)
- high-quality plotting
- no other dependencies than Qt >=4.7 (compatible with Qt 5.xx)
- highly customizable axes/grids (linear/log, date/time, custom ticks ...)
@ -33,16 +33,16 @@ This software is licensed under the term of the [GNU Lesser General Public Licen
- extensive library of image plots (inclusing different color-scale modes, RGBA-plots, overlays/masks)
- contour plots
- geometric forms/annotations
- can be easily extended by deriving a new graph from JKQTPplotElement or JKQTPplotObject
- can be easily extended by deriving a new graph from JKQTPPlotElement or JKQTPPlotObject
- optional: OpenCV interface
- extensive set of [Examples/Tutorials](./examples/README.md)
- extensive doxygen-generated [Documentation](http://jkriege2.github.io/JKQtPlotter/index.html)
- extensive doxygen-generated [Documentation](http://jkriege2.github.io/JKQTPLotter/index.html)
## [Documentation](http://jkriege2.github.io/JKQtPlotter/index.html)
## [Documentation](http://jkriege2.github.io/JKQTPLotter/index.html)
A Documentation (auto-)generated with [doxygen](http://www.doxygen.nl/) from the trunk source code can be found here:
**[http://jkriege2.github.io/JKQtPlotter/index.html](http://jkriege2.github.io/JKQtPlotter/index.html)**
**[http://jkriege2.github.io/JKQTPLotter/index.html](http://jkriege2.github.io/JKQTPLotter/index.html)**
Documentation is auto-generated after pushes by [Travis](https://travis-ci.org/jkriege2/JKQtPlotter): [![Build Status](https://travis-ci.org/jkriege2/JKQtPlotter.svg?branch=master)](https://travis-ci.org/jkriege2/JKQtPlotter)
Documentation is auto-generated after pushes by [Travis](https://travis-ci.org/jkriege2/JKQTPLotter): [![Build Status](https://travis-ci.org/jkriege2/JKQTPLotter.svg?branch=master)](https://travis-ci.org/jkriege2/JKQTPLotter)
## [Examples](./examples/)
There is a [large set of usage examples (with explanations for each) and tutorials](./examples/) in the folder [`./examples/`](./examples).

4
doc/Doxyfile
View File

@ -32,7 +32,7 @@ DOXYFILE_ENCODING = UTF-8
# title of most generated pages and in a few other places.
# The default value is: My Project.
PROJECT_NAME = JKQtPlotter
PROJECT_NAME = JKQTPLotter
# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
# could be handy for archiving the generated documentation or if some version
@ -158,7 +158,7 @@ INLINE_INHERITED_MEMB = NO
# shortest path that makes the file name unique will be used
# The default value is: YES.
FULL_PATH_NAMES = YES
FULL_PATH_NAMES = NO
# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
# Stripping is only done if one of the specified strings matches the left-hand

96
doc/dox/examples_and_tutorials.dox
View File

@ -12,53 +12,53 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
<table>
<tr><th>Screenshot<th>Description<th>Notes
<tr><td> \image html jkqtplotter_simpletest1_small.png
<td> \subpage JKQTPlotterSimpleTest
<td> `JKQTPxyLineGraph` <br> C++-style QVector arrays of data
<td> \subpage JKQTPLotterSimpleTest
<td> `JKQTPXYLineGraph` <br> C++-style QVector arrays of data
<tr><td> \image html jkqtplotter_simpletest_speed_small.png
<td> \subpage JKQtPlotterSpeedTest
<td> `JKQTPxyLineGraph` <br> external `std::array<double,N>` data, not owned by datastore <br> live-data, measure plotting speed <br> tipps to increas plotting speed
<td> \subpage JKQTPLotterSpeedTest
<td> `JKQTPXYLineGraph` <br> external `std::array<double,N>` data, not owned by datastore <br> live-data, measure plotting speed <br> tipps to increas plotting speed
<tr><td> \image html jkqtplotter_simpletest_symbols_and_styles_small.png
<td> \subpage JKQtPlotterSymbolsAndStyles
<td> `JKQTPxyLineGraph` <br> C++ vector of data <br> setting line styles and symbol styles <br> automatic graph coloring
<td> \subpage JKQTPLotterSymbolsAndStyles
<td> `JKQTPXYLineGraph` <br> C++ vector of data <br> setting line styles and symbol styles <br> automatic graph coloring
<tr><td> \image html jkqtplotter_simpletest_stepplots_small.png
<td> \subpage JKQtPlotterStepPlot
<td> `JKQTPstepHorizontalGraph` (and `JKQTPxyLineGraph`) <br> C++ vector of data <br> different step modes, filled and line-only
<td> \subpage JKQTPLotterStepPlot
<td> `JKQTPStepHorizontalGraph` (and `JKQTPXYLineGraph`) <br> C++ vector of data <br> different step modes, filled and line-only
<tr><td> \image html jkqtplotter_simpletest_symbols_and_errors_small.png
<td> \subpage JKQtPlotterSymbolsErrors
<td> `JKQTPxyLineErrorGraph` <br> C-style arrays of data
<td> \subpage JKQTPLotterSymbolsErrors
<td> `JKQTPXYLineErrorGraph` <br> C-style arrays of data
<tr><td> \image html jkqtplotter_simpletest_errorbarstyles_small.png
<td> \subpage JKQtPlotterErrorBarStyles
<td> `JKQTPxyLineErrorGraph` <br> different styles of error indicators for x- and y-errors <br> C++-style QVector for data <br> styling error indicators <br> moving key and formatting plotter grid
<td> \subpage JKQTPLotterErrorBarStyles
<td> `JKQTPXYLineErrorGraph` <br> different styles of error indicators for x- and y-errors <br> C++-style QVector for data <br> styling error indicators <br> moving key and formatting plotter grid
<tr><td> \image html jkqtplotter_simpletest_barchart_small.png
<td> \subpage JKQtPlotterBarcharts
<td> `JKQTPbarVerticalGraph` <br> C-style arrays of data
<tr><td> \image html JKQTPbarHorizontalGraphStacked_small.png
<td> \subpage JKQtPlotterStackedBarChart
<td> `JKQTPbarVerticalStackableGraph`, `JKQTPbarHorizontalStackableGraph` <br> C++-style vectors of data
<td> \subpage JKQTPLotterBarcharts
<td> `JKQTPBarVerticalGraph` <br> C-style arrays of data
<tr><td> \image html JKQTPBarHorizontalGraphStacked_small.png
<td> \subpage JKQTPLotterStackedBarChart
<td> `JKQTPBarVerticalStackableGraph`, `JKQTPBarHorizontalStackableGraph` <br> C++-style vectors of data
<tr><td> \image html jkqtplotter_simpletest_filledgraphs_small.png
<td> \subpage JKQtPlotterFilledGraphs
<td> `JKQTPbarVerticalGraph` <br> setting/altering data in `JKQTPdatstore` directly <br> transparent plots <br> calculating histograms
<td> \subpage JKQTPLotterFilledGraphs
<td> `JKQTPBarVerticalGraph` <br> setting/altering data in `JKQTPDatstore` directly <br> transparent plots <br> calculating histograms
<tr><td> \image html jkqtplotter_simpletest_impulsesplot_small.png
<td> \subpage JKQtPlotterImpulsePlots
<td> `JKQTPimpulsesVerticalGraph` and `JKQTPimpulsesHorizontalGraph` <br> C++-style QVector as plot data
<td> \subpage JKQTPLotterImpulsePlots
<td> `JKQTPImpulsesVerticalGraph` and `JKQTPImpulsesHorizontalGraph` <br> C++-style QVector as plot data
<tr><td> \image html jkqtplotter_simpletest_paramscatterplot_small.png
<td> \subpage JKQtPlotterParamScatter
<td> `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> modify scatter/points/line-graph properties by data
<td> \subpage JKQTPLotterParamScatter
<td> `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> modify scatter/points/line-graph properties by data
<tr><td> \image html jkqtplotter_simpletest_paramscatterplot_image_small.png
<td> \subpage JKQtPlotterParamScatterImage
<td> `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> rectangular arrangement of scatters <br> generative computer graphics
<td> \subpage JKQTPLotterParamScatterImage
<td> `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> rectangular arrangement of scatters <br> generative computer graphics
<tr><td> \image html jkqtplotter_simpletest_parametriccurve_small.png
<td> \subpage JKQtPlotterParametricCurves
<td> `JKQTPxyLineGraph` and `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> parametric curve plotting
<td> \subpage JKQTPLotterParametricCurves
<td> `JKQTPXYLineGraph` and `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> parametric curve plotting
<tr><td> \image html jkqtplotter_simpletest_functionplot_small.png
<td> \subpage JKQtPlotterFunctionPlots
<td> `JKQTPxFunctionLineGraph` <br> diretly plotting C/C++-functions
<td> \subpage JKQTPLotterFunctionPlots
<td> `JKQTPXFunctionLineGraph` <br> diretly plotting C/C++-functions
<tr><td> \image html jkqtplotter_simpletest_parsedfunctionplot_small.png
<td> \subpage JKQtPlotterParsedFunctionPlot
<td> `JKQTPxParsedFunctionLineGraph` <br> plotting functions with the internal math equation parser/evaluator
<td> \subpage JKQTPLotterParsedFunctionPlot
<td> `JKQTPXParsedFunctionLineGraph` <br> plotting functions with the internal math equation parser/evaluator
<tr><td> \image html jkqtplotter_simpletest_geometric_small.png
<td> \subpage JKQtPlotterGeometricGraphs
<td> `JKQTPplotObject`, `JKQTPgeoArc`, `JKQTPgeoLine`, `JKQTPgeoRectangle`, ...
<td> \subpage JKQTPLotterGeometricGraphs
<td> `JKQTPPlotObject`, `JKQTPGeoArc`, `JKQTPGeoLine`, `JKQTPGeoRectangle`, ...
</table>
@ -67,11 +67,11 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
<table>
<tr><th> Screenshot <th> Description <th> Notes
<tr><td> \image html jkqtplotter_simpletest_logaxes_small.png
<td> \subpage JKQtPlotterLogAxes
<td> `JKQTPxyLineGraph` and `JKQTPgeoText` <br> C++ vector of data <br> logarithmic axes and styling <br> plot line styles <br> internal LaTeX parser <br> add commenting text to a graph
<td> \subpage JKQTPLotterLogAxes
<td> `JKQTPXYLineGraph` and `JKQTPGeoText` <br> C++ vector of data <br> logarithmic axes and styling <br> plot line styles <br> internal LaTeX parser <br> add commenting text to a graph
<tr><td> \image html jkqtplotter_simpletest_dateaxes_timeaxis_small.png
<td> \subpage JKQtPlotterDateTimeAxes
<td> `JKQTPxyLineGraph` and `JKQTPfilledVerticalRangeGraph` <br> C++ vector of data <br> date/time axes <br> plot min/max range graph <br> internal LaTeX parser <br> data from CSV files
<td> \subpage JKQTPLotterDateTimeAxes
<td> `JKQTPXYLineGraph` and `JKQTPFilledVerticalRangeGraph` <br> C++ vector of data <br> date/time axes <br> plot min/max range graph <br> internal LaTeX parser <br> data from CSV files
</table>
@ -81,22 +81,22 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
<table>
<tr><th> Screenshot <th> Description <th> Notes
<tr><td> \image html jkqtplotter_simpletest_rgbimageplot_qt_small.png
<td> \subpage JKQtPlotterImagePlotQImageRGB
<td> \subpage JKQTPLotterImagePlotQImageRGB
<td> `JKQTPImage` <br> `QImage` drawn onto a plot with arbitrary scaling)
<tr><td> \image html jkqtplotter_simpletest_imageplot_small.png
<td> \subpage JKQtPlotterImagePlot
<td> \subpage JKQTPLotterImagePlot
<td> `JKQTPColumnMathImage` <br> image data copied from C-style row-major array into a single column of the internal datastore <br> Describes several options of the image plotting classes (different ways of color coding, what to do with data above/below the limits etc.)
<tr><td> \image html jkqtplotter_simpletest_imageplot_modifier_small.png
<td> \subpage JKQtPlotterImagePlotModifier
<td> \subpage JKQTPLotterImagePlotModifier
<td> `JKQTPColumnMathImage` <br> image data copied from C-style row-major array into a single column of the internal datastore <br> Image is modified by a second image to display two data dimensions at the same time
<tr><td> \image html jkqtplotter_simpletest_imageplot_nodatastore_small.png
<td> \subpage JKQtPlotterImagePlotNoDatastore
<td> \subpage JKQTPLotterImagePlotNoDatastore
<td> `JKQTPMathImage` <br> image data in a C-style row-major array, not using internal datastore
<tr><td> \image html jkqtplotter_simpletest_imageplot_opencv_small.png
<td> \subpage JKQtPlotterImagePlotOpenCV
<td> \subpage JKQTPLotterImagePlotOpenCV
<td> `JKQTPColumnMathImage` <br> image data copied from OpenCV cv::Mat-structure into a single column of the internal datastore
<tr><td> \image html jkqtplotter_simpletest_rgbimageplot_opencv_small.png
<td> \subpage JKQtPlotterImagePlotRGBOpenCV
<td> \subpage JKQTPLotterImagePlotRGBOpenCV
<td> `JKQTPColumnRGBMathImage` <br> image data copied from OpenCV cv::Mat-structure into three columns of the internal datastore
</table>
@ -107,11 +107,11 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
<table>
<tr><th> Screenshot <th> Description <th> Notes
<tr><td> \image html test_multiplot_small.png
<td> \subpage JKQtPlotterMultiPlotLayout
<td> \subpage JKQTPLotterMultiPlotLayout
<td> Combining plots in Qt Layouts <br> linking plot axes <br> copy data from a `std::map` int the datastore <br> print plots/print preview
<tr><td> \image html jkqtplotter_simpletest_ui_small.png
<td> \subpage JKQtPlotterQtCreator
<td> using Qt Form Designer <br> parsed function plots (`JKQTPxParsedFunctionLineGraph`) </table>
<td> \subpage JKQTPLotterQtCreator
<td> using Qt Form Designer <br> parsed function plots (`JKQTPXParsedFunctionLineGraph`) </table>
</table>
@ -121,8 +121,8 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
<table>
<tr><th> Screenshot <th> Description <th> Notes
<tr><td> \image html jkqtmathtext_simpletest_small.png
<td> \subpage JKQTmathTextSimpleExample
<td> JKQTmathText<br>render LaTeX markup (Schrödinger's equation)
<td> \subpage JKQTMathTextSimpleExample
<td> JKQTMathText<br>render LaTeX markup (Schrödinger's equation)
</table>

2
doc/dox/jkqtfastplotter.dox
View File

@ -3,7 +3,7 @@
\defgroup jkqtfastplotter JKQTFastPlotter: Speed-Optimized Plotter class
This is an indepent (and fully self-contained) plotter class, which is optimized for drawing speed, rather than
output quality. It lacks several of the advanced features of JKQtPlotter, but can be used in cases, where fast
output quality. It lacks several of the advanced features of JKQTPLotter, but can be used in cases, where fast
update of plots or real-time plotting is required.
An example for the usage of this class can be found here: \link ../../examples/jkqtfastplotter_test \endlink

8
doc/dox/jkqtmathtext.dox
View File

@ -1,15 +1,15 @@
/*!
\defgroup jkqtmathtext JKQTmathText LaTeX-Renderer for Qt
\defgroup jkqtmathtext JKQTMathText LaTeX-Renderer for Qt
This group contains JKQTmathText, a self-contained LaTeX-renderer for Qt. It is used to renderer
labels in JKQtPlotter, but can be used independently. The class does not depend on any library,
This group contains JKQTMathText, a self-contained LaTeX-renderer for Qt. It is used to renderer
labels in JKQTPLotter, but can be used independently. The class does not depend on any library,
except Qt. In particular it actually parses a LaTeX string and draws it in pure C++. It does NOT rely
on an installed LaTeX for the rendering!
Examples for the usage of this class can be found here:
- \ref JKQTmathTextSimpleExample
- \ref JKQTMathTextSimpleExample
.

32
doc/dox/jkqtplotter.dox
View File

@ -1,6 +1,6 @@
/*!
\defgroup jkqtptools Tool Functions and Definitions for JKQtPlotter
\defgroup jkqtptools Tool Functions and Definitions for JKQTPLotter
This group contains a set of tools that I've written over the years to enhance the
C++ standard library.
@ -27,9 +27,9 @@ C++ standard library.
\defgroup jkqtplotter JKQtPlotter: Qt based Scientific Plotter Class
\defgroup jkqtplotter JKQTPLotter: Qt based Scientific Plotter Class
A Qt based plotter for 2D scientific graphs. Main Plotting widget is JKQtPlotter.
A Qt based plotter for 2D scientific graphs. Main Plotting widget is JKQTPLotter.
\defgroup jkqtpdatastorage Data Storage Classes/System
@ -44,11 +44,11 @@ classes.
\defgroup jkqtpopencvinterface OpenCV Interfaceing Tools
\ingroup jkqtpdatastorage
Classes and functions in this group allow JKQtPlotter to directly work with <a href="https://opencv.org/">OpenCV</a> data structures.
Classes and functions in this group allow JKQTPLotter to directly work with <a href="https://opencv.org/">OpenCV</a> data structures.
Examples:
- \ref JKQtPlotterImagePlotOpenCV
- \ref JKQtPlotterImagePlotRGBOpenCV
- \ref JKQTPLotterImagePlotOpenCV
- \ref JKQTPLotterImagePlotRGBOpenCV
.
\defgroup jkqtpplotterclasses Plotter Class & Plotter Widget
@ -58,15 +58,15 @@ This group contains the actual plotter classes, that implement layout management
coordinate system management an actual plotter widget ...
There are two main classes:
- JKQtBasePlotter is a QObject-derived class that implements all the plotting logic and drawing code. It does not implement a Qt widget though.
- JKQtPlotter is a QWidget-based class that contains a JKQtBasePlotter and uses it to draw plots onto a Qt form.
- JKQTBasePlotter is a QObject-derived class that implements all the plotting logic and drawing code. It does not implement a Qt widget though.
- JKQTPLotter is a QWidget-based class that contains a JKQTBasePlotter and uses it to draw plots onto a Qt form.
.
\defgroup jkqtplotter_elements Plot Elements
\ingroup jkqtplotter
This group assembles all classes that represent different elements of a plot (managed by JKQtBasePlotter/JKQtPlotter).
This group assembles all classes that represent different elements of a plot (managed by JKQTBasePlotter/JKQTPLotter).
There are these major subgroups:
- \ref jkqtpbaseplotter_elements contains all non-graph objects, i.e. things like coordinate axes and so on
- \ref jkqtplotter_graphsgroup contains the actual graph classes
@ -77,7 +77,7 @@ There are these major subgroups:
\ingroup jkqtplotter_elements
This group contains some tool classes that implement basic elements of the plot (coordinate axes, key, ...).
These classes are used by JKQtPlotterBase to output the plot
These classes are used by JKQTPLotterBase to output the plot
\defgroup jkqtplotter_graphsgroup Graph Classes
@ -109,7 +109,7 @@ These classes are used by JKQtPlotterBase to output the plot
\ingroup jkqtplotter_graphsgroup
Examples:
- \ref JKQtPlotterGeometricGraphs
- \ref JKQTPLotterGeometricGraphs
.
\defgroup jkqtplotter_diverse Diverse Other Graphs (Ranges, ...)
@ -133,17 +133,17 @@ Examples:
\defgroup jkqtpqtwidgetsttools Qt Widgets/Tools to work with JKQtPlotter
\defgroup jkqtpqtwidgetsttools Qt Widgets/Tools to work with JKQTPLotter
\ingroup jkqtplotter
This group assembles several Qt widgets and tool classes that are linked to JKQtPlotter/JKQtBasePlotter and allow to build advanced GUIs for these (e.g. model/view access to internal data ...)
This group assembles several Qt widgets and tool classes that are linked to JKQTPLotter/JKQTBasePlotter and allow to build advanced GUIs for these (e.g. model/view access to internal data ...)
\defgroup jkqtpgraphsmodel Qt Data Models to Access Graphs in a JKQtBasePlotter/JKQtPlotter
\defgroup jkqtpgraphsmodel Qt Data Models to Access Graphs in a JKQTBasePlotter/JKQTPLotter
\ingroup jkqtpqtwidgetsttools
Data models in this group allow to access different internal data from a JKQtBasePlotter/JKQtPlotter and in part to manipulate these.
Data models in this group allow to access different internal data from a JKQTBasePlotter/JKQTPLotter and in part to manipulate these.
\defgroup jkqtpcomboboxes Comboboxes for Properties of JKQtBasePlotter/JKQtPlotter
\defgroup jkqtpcomboboxes Comboboxes for Properties of JKQTBasePlotter/JKQTPLotter
\ingroup jkqtpqtwidgetsttools
This group contains several QComboBox-derived classes that can be used to select different enum-values (e.g. with JKQTPMathImageColorPaletteComboBox you can select a color-palette from JKQTPMathImageColorPalette ).

22
doc/dox/mainpage.dox
View File

@ -1,6 +1,6 @@
/*!
\mainpage JKQtPlotter - A Qt Plotting Library
\mainpage JKQTPLotter - A Qt Plotting Library
This is an extensive library of function/data plotter classes for Qt (>= 4.7, tested with Qt up to 5.11).
This software is licensed under the term of the GNU Lesser General Public License 2.1
@ -9,11 +9,11 @@ This software is licensed under the term of the GNU Lesser General Public Licens
\image html examplesbanner.png
\section jkqtp_main_features Main Features
- Extensive Scientific 2D Plotting framework (JKQtPlotter/JKQtBasePlotter)
- Extensive Scientific 2D Plotting framework (JKQTPLotter/JKQTBasePlotter)
- high-quality plotting
- no other dependencies than Qt >=4.7 (compatible with Qt 5.xx)
- highly customizable axes/grids (linear/log, date/time, custom ticks ...)
- integrated LaTeX parser/renderer JKQTmathText for axis labels, ticks, notes ...
- integrated LaTeX parser/renderer JKQTMathText for axis labels, ticks, notes ...
- extensive user-interactions pre-programmed (several zooming modes, selecting regions, custom context menus, switch graph visibility, ...)
- full print and export (PDF,PNG,...) support with preview and parametrization out-the-box
- highly customizable look and feel
@ -37,20 +37,20 @@ This software is licensed under the term of the GNU Lesser General Public Licens
- extensive library of image plots (inclusing different color-scale modes, RGBA-plots, overlays/masks)
- contour plots
- geometric forms/annotations, see: \ref jkqtplotter_geoplots
- can be easily extended by deriving a new graph from JKQTPplotElement or JKQTPplotObject
- can be easily extended by deriving a new graph from JKQTPPlotElement or JKQTPPlotObject
- optional: OpenCV interface, see: \ref jkqtpopencvinterface
- integrated LaTeX parser/renderer JKQTmathText:
- integrated LaTeX parser/renderer JKQTMathText:
- pure C++
- no dependencies in particular no installed LaTeX required
- can be used independently of JKQtPlotter
- can be used independently of JKQTPLotter
- see: \ref jkqtmathtext
- a second plotter widget JKQtFastPlotter:
- is optimized for fast plotting, but is not as feature-rich as JKQtPlotter
- may be used independently of JKQtPlotter
- a second plotter widget JKQTFastPlotter:
- is optimized for fast plotting, but is not as feature-rich as JKQTPLotter
- may be used independently of JKQTPLotter
- \see jkqtfastplotter
- extensive set of Examples and Tutorials, see: \ref exampleTutorialProjects
- extensive doxygen-generated <a href="http://jkriege2.github.io/JKQtPlotter/index.html">Online-Documentation (http://jkriege2.github.io/JKQtPlotter/index.html)</a>
- source code hosted&developed on GitHub <a href="https://github.com/jkriege2/JKQtPlotter">https://github.com/jkriege2/JKQtPlotter</a> (including continuous integration builds: <a href="https://ci.appveyor.com/project/jkriege2/jkqtplotter/branch/master">https://ci.appveyor.com/project/jkriege2/jkqtplotter/branch/master</a>)
- extensive doxygen-generated <a href="http://jkriege2.github.io/JKQTPLotter/index.html">Online-Documentation (http://jkriege2.github.io/JKQTPLotter/index.html)</a>
- source code hosted&developed on GitHub <a href="https://github.com/jkriege2/JKQTPLotter">https://github.com/jkriege2/JKQTPLotter</a> (including continuous integration builds: <a href="https://ci.appveyor.com/project/jkriege2/jkqtplotter/branch/master">https://ci.appveyor.com/project/jkriege2/jkqtplotter/branch/master</a>)
\image html screenshotsbanner.png

40
examples/README.md
View File

@ -1,4 +1,4 @@
# Example (JKQtPlotter): Examples & Tutorials {#exampleProjectsTutorials}
# Example (JKQTPLotter): Examples & Tutorials {#exampleProjectsTutorials}
This section assembles some simple examples of usage.
You can find more (complex) examples for the classes in this repository in the subfolder "test".
All test-projects are Qt-projects that use qmake to build. You can load them into QtCreator easily.
@ -7,29 +7,29 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
| Screenshot | Description | Notes |
|:-------------:| ------------- | ------------- |
| [![](../screenshots/jkqtplotter_simpletest1_small.png)](./simpletest/README.md) | [Very Basic Example (Line Graph)](./simpletest/README.md) | `JKQTPxyLineGraph` <br> C++-style QVector arrays of data |
| [![](../screenshots/jkqtplotter_simpletest_speed_small.png)](./simpletest_speed) | [Line Graph with Live Data / Speed Test](./simpletest_speed) | `JKQTPxyLineGraph` <br> external `std::array<double,N>` data, not owned by datastore <br> live-data, measure plotting speed <br> tipps to increas plotting speed |
| [![](../screenshots/jkqtplotter_simpletest_symbols_and_styles_small.png)](./simpletest_symbols_and_styles) | [Line Graph with Different Symbols and Line Styles](./simpletest_symbols_and_styles) | `JKQTPxyLineGraph` <br> C++ vector of data <br> setting line styles and symbol styles <br> automatic graph coloring |
| [![](../screenshots/jkqtplotter_simpletest_stepplots_small.png)](./simpletest_stepplots) | [Step Line Plots in Different Styles](./simpletest_stepplots) | `JKQTPstepHorizontalGraph` (and `JKQTPxyLineGraph`) <br> C++ vector of data <br> different step modes, filled and line-only |
| [![](../screenshots/jkqtplotter_simpletest_symbols_and_errors_small.png)](./simpletest_symbols_and_errors) | [Simple Line/Symbol Graph With Errorbars](./simpletest_symbols_and_errors) | `JKQTPxyLineErrorGraph` <br> C-style arrays of data |
| [![](../screenshots/jkqtplotter_simpletest_errorbarstyles_small.png)](./simpletest_errorbarstyles) | [Different Types of Error Indicators](./simpletest_errorbarstyles) | `JKQTPxyLineErrorGraph` <br> different styles of error indicators for x- and y-errors <br> C++-style QVector for data <br> styling error indicators <br> moving key and formatting plotter grid |
| [![](../screenshots/jkqtplotter_simpletest_barchart_small.png)](./simpletest_barchart) | [Simple Bar Charts](./simpletest_barchart) | `JKQTPbarVerticalGraph` <br> C-style arrays of data |
| [![](../screenshots/JKQTPbarVerticalGraphStacked_small.png) <br> ![](../screenshots/JKQTPbarHorizontalGraphStacked_small.png)](./simpletest_stackedbars) | [Stacked Bar Charts](./simpletest_stackedbars) | `JKQTPbarVerticalStackableGraph`, `JKQTPbarHorizontalStackableGraph` <br> C++-style vectors of data |
| [![](../screenshots/jkqtplotter_simpletest_filledgraphs_small.png)](./simpletest_filledgraphs) | [Filled Curve Plots](./simpletest_filledgraphs) | `JKQTPbarVerticalGraph` <br> setting/altering data in `JKQTPdatstore` directly <br> transparent plots <br> calculating histograms |
| [![](../screenshots/jkqtplotter_simpletest_impulsesplot_small.png)](./simpletest_impulsesplot) | [Impulse Plots](./simpletest_impulsesplot) | `JKQTPimpulsesVerticalGraph` and `JKQTPimpulsesHorizontalGraph` <br> C++-style QVector as plot data |
| [![](../screenshots/jkqtplotter_simpletest_paramscatterplot_small.png)](./simpletest_paramscatterplot) | [Scatter Graph with Parametrized Symbols/Colors](./simpletest_paramscatterplot) | `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> modify scatter/points/line-graph properties by data |
| [![](../screenshots/jkqtplotter_simpletest_paramscatterplot_image_small.png)](./simpletest_paramscatterplot_image) | [Draw an Artistic Image with a Parametrized Scatter Graph](./simpletest_paramscatterplot_image) | `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> rectangular arrangement of scatters <br> generative computer graphics |
| [![](../screenshots/jkqtplotter_simpletest_parametriccurve_small.png)](./simpletest_parametriccurve) | [Plotting Parametric Curves](./simpletest_parametriccurve) | `JKQTPxyLineGraph` and `JKQTPxyParametrizedScatterGraph` <br> C++-style QVector as plot data <br> parametric curve plotting |
| [![](../screenshots/jkqtplotter_simpletest_functionplot_small.png)](./simpletest_functionplot) | [Plotting Mathematical Functions as Line Graphs](./simpletest_functionplot) | `JKQTPxFunctionLineGraph` <br> diretly plotting C/C++-functions |
| [![](../screenshots/jkqtplotter_simpletest_parsedfunctionplot_small.png)](./simpletest_parsedfunctionplot) | [Plotting Parsed Mathematical Functions as Line Graphs](./simpletest_parsedfunctionplot) | `JKQTPxParsedFunctionLineGraph` <br> plotting functions with the internal math equation parser/evaluator |
| [![](../screenshots/jkqtplotter_simpletest1_small.png)](./simpletest/README.md) | [Very Basic Example (Line Graph)](./simpletest/README.md) | `JKQTPXYLineGraph` <br> C++-style QVector arrays of data |
| [![](../screenshots/jkqtplotter_simpletest_speed_small.png)](./simpletest_speed) | [Line Graph with Live Data / Speed Test](./simpletest_speed) | `JKQTPXYLineGraph` <br> external `std::array<double,N>` data, not owned by datastore <br> live-data, measure plotting speed <br> tipps to increas plotting speed |
| [![](../screenshots/jkqtplotter_simpletest_symbols_and_styles_small.png)](./simpletest_symbols_and_styles) | [Line Graph with Different Symbols and Line Styles](./simpletest_symbols_and_styles) | `JKQTPXYLineGraph` <br> C++ vector of data <br> setting line styles and symbol styles <br> automatic graph coloring |
| [![](../screenshots/jkqtplotter_simpletest_stepplots_small.png)](./simpletest_stepplots) | [Step Line Plots in Different Styles](./simpletest_stepplots) | `JKQTPStepHorizontalGraph` (and `JKQTPXYLineGraph`) <br> C++ vector of data <br> different step modes, filled and line-only |
| [![](../screenshots/jkqtplotter_simpletest_symbols_and_errors_small.png)](./simpletest_symbols_and_errors) | [Simple Line/Symbol Graph With Errorbars](./simpletest_symbols_and_errors) | `JKQTPXYLineErrorGraph` <br> C-style arrays of data |
| [![](../screenshots/jkqtplotter_simpletest_errorbarstyles_small.png)](./simpletest_errorbarstyles) | [Different Types of Error Indicators](./simpletest_errorbarstyles) | `JKQTPXYLineErrorGraph` <br> different styles of error indicators for x- and y-errors <br> C++-style QVector for data <br> styling error indicators <br> moving key and formatting plotter grid |
| [![](../screenshots/jkqtplotter_simpletest_barchart_small.png)](./simpletest_barchart) | [Simple Bar Charts](./simpletest_barchart) | `JKQTPBarVerticalGraph` <br> C-style arrays of data |
| [![](../screenshots/JKQTPBarVerticalGraphStacked_small.png) <br> ![](../screenshots/JKQTPBarHorizontalGraphStacked_small.png)](./simpletest_stackedbars) | [Stacked Bar Charts](./simpletest_stackedbars) | `JKQTPBarVerticalStackableGraph`, `JKQTPBarHorizontalStackableGraph` <br> C++-style vectors of data |
| [![](../screenshots/jkqtplotter_simpletest_filledgraphs_small.png)](./simpletest_filledgraphs) | [Filled Curve Plots](./simpletest_filledgraphs) | `JKQTPBarVerticalGraph` <br> setting/altering data in `JKQTPDatstore` directly <br> transparent plots <br> calculating histograms |
| [![](../screenshots/jkqtplotter_simpletest_impulsesplot_small.png)](./simpletest_impulsesplot) | [Impulse Plots](./simpletest_impulsesplot) | `JKQTPImpulsesVerticalGraph` and `JKQTPImpulsesHorizontalGraph` <br> C++-style QVector as plot data |
| [![](../screenshots/jkqtplotter_simpletest_paramscatterplot_small.png)](./simpletest_paramscatterplot) | [Scatter Graph with Parametrized Symbols/Colors](./simpletest_paramscatterplot) | `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> modify scatter/points/line-graph properties by data |
| [![](../screenshots/jkqtplotter_simpletest_paramscatterplot_image_small.png)](./simpletest_paramscatterplot_image) | [Draw an Artistic Image with a Parametrized Scatter Graph](./simpletest_paramscatterplot_image) | `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> rectangular arrangement of scatters <br> generative computer graphics |
| [![](../screenshots/jkqtplotter_simpletest_parametriccurve_small.png)](./simpletest_parametriccurve) | [Plotting Parametric Curves](./simpletest_parametriccurve) | `JKQTPXYLineGraph` and `JKQTPXYParametrizedScatterGraph` <br> C++-style QVector as plot data <br> parametric curve plotting |
| [![](../screenshots/jkqtplotter_simpletest_functionplot_small.png)](./simpletest_functionplot) | [Plotting Mathematical Functions as Line Graphs](./simpletest_functionplot) | `JKQTPXFunctionLineGraph` <br> diretly plotting C/C++-functions |
| [![](../screenshots/jkqtplotter_simpletest_parsedfunctionplot_small.png)](./simpletest_parsedfunctionplot) | [Plotting Parsed Mathematical Functions as Line Graphs](./simpletest_parsedfunctionplot) | `JKQTPXParsedFunctionLineGraph` <br> plotting functions with the internal math equation parser/evaluator |
| [![](../screenshots/jkqtplotter_simpletest_geometric_small.png)](./simpletest_geometric) | [Plotting Geometric Objects](./simpletest_geometric) | |
## Styling the Plot, Keys, Axes, ...
| Screenshot | Description | Notes |
|:-------------:| ------------- | ------------- |
| [![](../screenshots/jkqtplotter_simpletest_logaxes_small.png)](./simpletest_logaxes) | [logarithmic axes](./simpletest_logaxes) | `JKQTPxyLineGraph` and `JKQTPgeoText` <br> C++ vector of data <br> logarithmic axes and styling <br> plot line styles <br> internal LaTeX parser <br> add commenting text to a graph |
| [![](../screenshots/jkqtplotter_simpletest_dateaxes_small.png) <br> ![](../screenshots/jkqtplotter_simpletest_dateaxes_dates_small.png) <br> ![](../screenshots/jkqtplotter_simpletest_dateaxes_timeaxis_small.png)](./simpletest_dateaxes) | [date/time axes](./simpletest_dateaxes) | `JKQTPxyLineGraph` and `JKQTPfilledVerticalRangeGraph` <br> C++ vector of data <br> date/time axes <br> plot min/max range graph <br> internal LaTeX parser <br> data from CSV files |
| [![](../screenshots/jkqtplotter_simpletest_logaxes_small.png)](./simpletest_logaxes) | [logarithmic axes](./simpletest_logaxes) | `JKQTPXYLineGraph` and `JKQTPGeoText` <br> C++ vector of data <br> logarithmic axes and styling <br> plot line styles <br> internal LaTeX parser <br> add commenting text to a graph |
| [![](../screenshots/jkqtplotter_simpletest_dateaxes_small.png) <br> ![](../screenshots/jkqtplotter_simpletest_dateaxes_dates_small.png) <br> ![](../screenshots/jkqtplotter_simpletest_dateaxes_timeaxis_small.png)](./simpletest_dateaxes) | [date/time axes](./simpletest_dateaxes) | `JKQTPXYLineGraph` and `JKQTPFilledVerticalRangeGraph` <br> C++ vector of data <br> date/time axes <br> plot min/max range graph <br> internal LaTeX parser <br> data from CSV files |
## Image data Plots
@ -48,12 +48,12 @@ All test-projects are Qt-projects that use qmake to build. You can load them int
| Screenshot | Description | Notes |
|:-------------:| ------------- | ------------- |
| [![](../screenshots/test_multiplot_small.png)](./test_multiplot) | [Layouting Several Plots](./test_multiplot) | Combining plots in Qt Layouts <br> linking plot axes <br> copy data from a `std::map` int the datastore <br> print plots/print preview |
| [![](../screenshots/jkqtplotter_simpletest_ui_small.png)](./simpletest_ui) | [Placing JKQtPlotter into a Qt User-Interface-XML-file (`*.ui`)](./simpletest_ui) | using Qt Form Designer <br> parsed function plots (`JKQTPxParsedFunctionLineGraph`) |
| [![](../screenshots/jkqtplotter_simpletest_ui_small.png)](./simpletest_ui) | [Placing JKQTPLotter into a Qt User-Interface-XML-file (`*.ui`)](./simpletest_ui) | using Qt Form Designer <br> parsed function plots (`JKQTPXParsedFunctionLineGraph`) |
## Tools and Special Features
| Screenshot | Description | Notes |
|:-------------:| ------------- | ------------- |
| [![](../screenshots/jkqtmathtext_simpletest_small.png)](./jkqtmathtext_simpletest) | [JKQTmathText: LaTeX Renderer](./jkqtmathtext_simpletest) | |
| [![](../screenshots/jkqtmathtext_simpletest_small.png)](./jkqtmathtext_simpletest) | [JKQTMathText: LaTeX Renderer](./jkqtmathtext_simpletest) | |

2
examples/jkqtfastplotter_test/jkqtfastplotter_test.pro
View File

@ -28,7 +28,7 @@ DEFINES += DEBUG_TIMING
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# include JKQtPlotter library
# include JKQTPLotter library
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

2
examples/jkqtfastplotter_test/jkqtfastplotter_test_testmain.cpp
View File

@ -1,5 +1,5 @@
/** \example jkqtfastplotter_test_testmain.cpp
* Example of how to use JKQtFastPlotter
* Example of how to use JKQTFastPlotter
*/
#include "jkqtfastplotter_test_testmain.h"

12
examples/jkqtmathtext_simpletest/README.md
View File

@ -1,10 +1,10 @@
# Example (JKQTmathText): A simple usage example {#JKQTmathTextSimpleExample}
JKQTmathText is a hand-written LaTeX-renderer for Qt (implemented in native C++, using Qt). It supports a large set of standard LaTeX markup and can render it to a QPainter.
# Example (JKQTMathText): A simple usage example {#JKQTMathTextSimpleExample}
JKQTMathText is a hand-written LaTeX-renderer for Qt (implemented in native C++, using Qt). It supports a large set of standard LaTeX markup and can render it to a QPainter.
This project (see `./examples/jkqtmathtext_simpletest/`) simply creates a QLabel (as a new window) that displays a rendered LaTeX equation (here the time-dependent Schrödinger equation).
The QMake project looks like this (see [`jkqtmathtext_simpletest.pro`](../jkqtmathtext_simpletest/jkqtmathtext_simpletest.pro):
```.qmake
# include JKQTmathText source-code, including the open-source XITS fonts
# include JKQTMathText source-code, including the open-source XITS fonts
include(../../lib/jkqtmathtext_with_xits.pri)
SOURCES += jkqtmathtext_simpletest.cpp
@ -37,10 +37,10 @@ int main(int argc, char* argv[])
pix.fill(QColor("white"));
QPainter painter;
// 2. now we create a JKQTmathText object.
// Also we configure the JKQTmathText to use the XITS fonts that
// 2. now we create a JKQTMathText object.
// Also we configure the JKQTMathText to use the XITS fonts that
// were included in the *.pro-file
JKQTmathText mathText;
JKQTMathText mathText;
mathText.useXITS();
mathText.set_fontSize(20);

10
examples/jkqtmathtext_simpletest/jkqtmathtext_simpletest.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtmathtext_simpletest.cpp
* A very basic example for the usage of JKQTmathText
* A very basic example for the usage of JKQTMathText
*
* \ref JKQTmathTextSimpleExample
* \ref JKQTMathTextSimpleExample
*/
#include <QApplication>
@ -21,10 +21,10 @@ int main(int argc, char* argv[])
pix.fill(QColor("white"));
QPainter painter;
// 2. now we create a JKQTmathText object.
// Also we configure the JKQTmathText to use the XITS fonts that
// 2. now we create a JKQTMathText object.
// Also we configure the JKQTMathText to use the XITS fonts that
// were included in the *.pro-file
JKQTmathText mathText;
JKQTMathText mathText;
mathText.useXITS();
mathText.set_fontSize(20);

2
examples/jkqtmathtext_test/asana.qrc
View File

@ -1,5 +1,5 @@
<RCC>
<qresource prefix="/JKQTmathText/fonts">
<qresource prefix="/JKQTMathText/fonts">
<file alias="asana-math.otf">asana/Asana-Math.otf</file>
</qresource>
</RCC>

6
examples/jkqtmathtext_test/jkqtmathtext_test.cpp
View File

@ -20,7 +20,7 @@
HighResTimer ht;
double draw(QPainter& painter, double X, double YY, JKQTmathText& mt, QString name) {
double draw(QPainter& painter, double X, double YY, JKQTMathText& mt, QString name) {
double Y=YY;
painter.save();
ht.start();
@ -67,7 +67,7 @@ void timingTest(QPainter& painter, QString text, QString name, double fontSize)
std::cout<<"testing '"<<name.toStdString()<<"':\nparse [ms],\tsize [ms],\tdraw [ms]\n---------------------------------------------\n";
for (int i=0; i<N; i++) {
double t;
JKQTmathText mt;
JKQTMathText mt;
mt.set_fontSize(fontSize);
ht.start(); mt.parse(text); t=ht.get_time()/1000.0;
sum_parse+=t;
@ -118,7 +118,7 @@ int main(int argc, char* argv[])
QPixmap pix(W, H), pix2(W,H);
pix.fill();
QPainter painter;
JKQTmathText mt(&win);
JKQTMathText mt(&win);
double Y=Y1;

38
examples/jkqtmathtext_test/testform.cpp
View File

@ -148,7 +148,7 @@ TestForm::~TestForm()
double TestForm::draw(QPainter& painter, double X, double YY, JKQTmathText& mt, QString name, double& durationSizingMS, double&durationTimingMS) {
double TestForm::draw(QPainter& painter, double X, double YY, JKQTMathText& mt, QString name, double& durationSizingMS, double&durationTimingMS) {
double Y=YY;
@ -190,34 +190,34 @@ double TestForm::draw(QPainter& painter, double X, double YY, JKQTmathText& mt,
return mt.getDescent(painter)+mt.getAscent(painter)+40;
}
QTreeWidgetItem *TestForm::createTree(JKQTmathText::MTnode *node, QTreeWidgetItem* parent)
QTreeWidgetItem *TestForm::createTree(JKQTMathText::MTnode *node, QTreeWidgetItem* parent)
{
QString name;
JKQTmathText::MTtextNode* txtN=dynamic_cast<JKQTmathText::MTtextNode*>(node);
JKQTmathText::MTwhitespaceNode* spN=dynamic_cast<JKQTmathText::MTwhitespaceNode*>(node);
JKQTmathText::MTsymbolNode* symN=dynamic_cast<JKQTmathText::MTsymbolNode*>(node);
JKQTmathText::MTlistNode* lstN=dynamic_cast<JKQTmathText::MTlistNode*>(node);
JKQTmathText::MTinstruction1Node* inst1N=dynamic_cast<JKQTmathText::MTinstruction1Node*>(node);
JKQTmathText::MTsubscriptNode* subN=dynamic_cast<JKQTmathText::MTsubscriptNode*>(node);
JKQTmathText::MTsuperscriptNode* superN=dynamic_cast<JKQTmathText::MTsuperscriptNode*>(node);
JKQTmathText::MTbraceNode* braceN=dynamic_cast<JKQTmathText::MTbraceNode*>(node);
JKQTmathText::MTsqrtNode* sqrtN=dynamic_cast<JKQTmathText::MTsqrtNode*>(node);
JKQTmathText::MTfracNode* fracN=dynamic_cast<JKQTmathText::MTfracNode*>(node);
JKQTmathText::MTmatrixNode* matrixN=dynamic_cast<JKQTmathText::MTmatrixNode*>(node);
JKQTmathText::MTdecoratedNode* decoN=dynamic_cast<JKQTmathText::MTdecoratedNode*>(node);
JKQTMathText::MTtextNode* txtN=dynamic_cast<JKQTMathText::MTtextNode*>(node);
JKQTMathText::MTwhitespaceNode* spN=dynamic_cast<JKQTMathText::MTwhitespaceNode*>(node);
JKQTMathText::MTsymbolNode* symN=dynamic_cast<JKQTMathText::MTsymbolNode*>(node);
JKQTMathText::MTlistNode* lstN=dynamic_cast<JKQTMathText::MTlistNode*>(node);
JKQTMathText::MTinstruction1Node* inst1N=dynamic_cast<JKQTMathText::MTinstruction1Node*>(node);
JKQTMathText::MTsubscriptNode* subN=dynamic_cast<JKQTMathText::MTsubscriptNode*>(node);
JKQTMathText::MTsuperscriptNode* superN=dynamic_cast<JKQTMathText::MTsuperscriptNode*>(node);
JKQTMathText::MTbraceNode* braceN=dynamic_cast<JKQTMathText::MTbraceNode*>(node);
JKQTMathText::MTsqrtNode* sqrtN=dynamic_cast<JKQTMathText::MTsqrtNode*>(node);
JKQTMathText::MTfracNode* fracN=dynamic_cast<JKQTMathText::MTfracNode*>(node);
JKQTMathText::MTmatrixNode* matrixN=dynamic_cast<JKQTMathText::MTmatrixNode*>(node);
JKQTMathText::MTdecoratedNode* decoN=dynamic_cast<JKQTMathText::MTdecoratedNode*>(node);
QTreeWidgetItem* ti=nullptr;
if (parent) ti=new QTreeWidgetItem(parent);
else ti=new QTreeWidgetItem(ui->tree);
if (decoN) {
name=QString("MTdecoratedNode: mode='%1'").arg(JKQTmathText::decorationToString(decoN->get_decoration()));
name=QString("MTdecoratedNode: mode='%1'").arg(JKQTMathText::decorationToString(decoN->get_decoration()));
if (decoN->get_child()) ti->addChild(createTree(decoN->get_child(), ti));
} else if (matrixN) {
int l=matrixN->get_lines();
int c=matrixN->get_columns();
name=QString("MTmatrixNode: l*c=%1*%2").arg(l).arg(c);
QVector<QVector<JKQTmathText::MTnode*> > children=matrixN->get_children();
QVector<QVector<JKQTMathText::MTnode*> > children=matrixN->get_children();
for (int y=0; y<l; y++) {
for (int x=0; x<c; x++) {
if (children[y].at(x)!=nullptr) {
@ -228,7 +228,7 @@ QTreeWidgetItem *TestForm::createTree(JKQTmathText::MTnode *node, QTreeWidgetIte
}
}
} else if (fracN) {
name=QString("MTfracNode: mode='%1'").arg(JKQTmathText::fracModeToString(fracN->get_mode()));
name=QString("MTfracNode: mode='%1'").arg(JKQTMathText::fracModeToString(fracN->get_mode()));
if (fracN->get_child1()) ti->addChild(createTree(fracN->get_child1(), ti));
if (fracN->get_child2()) ti->addChild(createTree(fracN->get_child2(), ti));
} else if (sqrtN) {
@ -248,7 +248,7 @@ QTreeWidgetItem *TestForm::createTree(JKQTmathText::MTnode *node, QTreeWidgetIte
if (inst1N->get_child()) ti->addChild(createTree(inst1N->get_child(), ti));
} else if (lstN) {
name=QString("MTlistNode");
QList<JKQTmathText::MTnode*> list=lstN->get_nodes();
QList<JKQTMathText::MTnode*> list=lstN->get_nodes();
for (int i=0; i<list.size(); i++) {
ti->addChild(createTree(list[i], ti));
}
@ -308,7 +308,7 @@ void TestForm::updateMath()
QPixmap pix(W, H);
pix.fill();
QPainter painter;
JKQTmathText mt(this);
JKQTMathText mt(this);
double Y=Y1;

4
examples/jkqtmathtext_test/testform.h
View File

@ -26,9 +26,9 @@ class TestForm : public QWidget
private:
Ui::TestForm *ui;
JKQTPHighResTimer ht;
double draw(QPainter& painter, double X, double YY, JKQTmathText& mt, QString name, double &durationSizingMS, double &durationTimingMS);
double draw(QPainter& painter, double X, double YY, JKQTMathText& mt, QString name, double &durationSizingMS, double &durationTimingMS);
QTreeWidgetItem* createTree(JKQTmathText::MTnode* node, QTreeWidgetItem *parent=NULL);
QTreeWidgetItem* createTree(JKQTMathText::MTnode* node, QTreeWidgetItem *parent=NULL);
};
#endif // TESTFORM_H

4
examples/jkqtmathtext_test/testform.ui
View File

@ -193,7 +193,7 @@
</layout>
</item>
<item row="15" column="0" colspan="2">
<widget class="JKQTmathTextLabel" name="labMath">
<widget class="JKQTMathTextLabel" name="labMath">
<property name="text">
<string>left(left[sqrt{2picdotint_{-infty}^infty f(x);mathrm{d}x}right]right) </string>
</property>
@ -418,7 +418,7 @@
</widget>
<customwidgets>
<customwidget>
<class>JKQTmathTextLabel</class>
<class>JKQTMathTextLabel</class>
<extends>QLabel</extends>
<header>jkqtmathtext/jkqtmathtext.h</header>
</customwidget>

12
examples/jkqtplot_test/TestWidgetBarcharts.cpp
View File

@ -17,7 +17,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
QVBoxLayout* barchartLayout=new QVBoxLayout(this);
setLayout(barchartLayout);
resize(1000, 800);
plotBarchart=new JKQtPlotter(true, this);
plotBarchart=new JKQTPLotter(true, this);
plotBarchart->set_doDrawing(false);
plotBarchart->get_plotter()->set_plotLabel(tr("\\textbf{bar charts}"));
plotBarchart->setObjectName("plotBarchart");
@ -47,7 +47,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
size_t bcpy2=plotBarchart->getDatastore()->addCopiedColumn(dataBCY2, "y2");
size_t bcpye2=plotBarchart->getDatastore()->addCopiedColumn(dataBCYE2, "ye2");
JKQTPbarVerticalErrorGraph* plteBar1=new JKQTPbarVerticalErrorGraph(plotBarchart->get_plotter());
JKQTPBarVerticalErrorGraph* plteBar1=new JKQTPBarVerticalErrorGraph(plotBarchart->get_plotter());
plteBar1->set_title(tr("bars 1"));
plteBar1->set_xColumn(bcpxd);
plteBar1->set_yColumn(bcpy1);
@ -56,7 +56,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
plteBar1->set_shift(-0.25);
plotBarchart->get_plotter()->addGraph(plteBar1);
JKQTPbarVerticalErrorGraph* plteBar2=new JKQTPbarVerticalErrorGraph(plotBarchart->get_plotter());
JKQTPBarVerticalErrorGraph* plteBar2=new JKQTPBarVerticalErrorGraph(plotBarchart->get_plotter());
plteBar2->set_xColumn(bcpxd);
plteBar2->set_yColumn(bcpy2);
plteBar2->set_yErrorColumn(bcpye2);
@ -74,7 +74,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
plotBarchart2=new JKQtPlotter(false, this, plotBarchart->getDatastore());
plotBarchart2=new JKQTPLotter(false, this, plotBarchart->getDatastore());
plotBarchart2->set_doDrawing(false);
plotBarchart2->get_plotter()->set_plotLabel(tr("\\textbf{bar charts}"));
plotBarchart2->setObjectName("plotBarchart2");
@ -82,7 +82,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
barchartLayout->addWidget(plotBarchart2);
JKQTPbarHorizontalErrorGraph* plteBar3=new JKQTPbarHorizontalErrorGraph(plotBarchart2->get_plotter());
JKQTPBarHorizontalErrorGraph* plteBar3=new JKQTPBarHorizontalErrorGraph(plotBarchart2->get_plotter());
plteBar3->set_title(tr("bars 1"));
plteBar3->set_yColumn(bcpx);
plteBar3->set_xColumn(bcpy1);
@ -91,7 +91,7 @@ TestWidgetBarcharts::TestWidgetBarcharts(QWidget *parent) :
plteBar3->set_shift(-0.25);
plotBarchart2->get_plotter()->addGraph(plteBar3);
JKQTPbarHorizontalErrorGraph* plteBar4=new JKQTPbarHorizontalErrorGraph(plotBarchart2->get_plotter());
JKQTPBarHorizontalErrorGraph* plteBar4=new JKQTPBarHorizontalErrorGraph(plotBarchart2->get_plotter());
plteBar4->set_yColumn(bcpx);
plteBar4->set_xColumn(bcpy2);
plteBar4->set_xErrorColumn(bcpye2);

4
examples/jkqtplot_test/TestWidgetBarcharts.h
View File

@ -44,8 +44,8 @@ class TestWidgetBarcharts : public QWidget
protected:
JKQtPlotter* plotBarchart;
JKQtPlotter* plotBarchart2;
JKQTPLotter* plotBarchart;
JKQTPLotter* plotBarchart2;
QCheckBox* chkBarLog;
QSpinBox* spinBarLabelAngel;
QSpinBox* spinBarLabelAngel2;

4
examples/jkqtplot_test/TestWidgetContourPlots.cpp
View File

@ -16,14 +16,14 @@ TestWidgetContourPlots::TestWidgetContourPlots(QWidget *parent) :
// contour plot
QHBoxLayout* layoutContour=new QHBoxLayout(this);
setLayout(layoutContour);
JKQtPlotter* plotContour=new JKQtPlotter(true, this);
JKQTPLotter* plotContour=new JKQTPLotter(true, this);
plotContour->set_doDrawing(false);
plotContour->get_plotter()->set_plotLabel(tr("\\textbf{hist contour plot}"));
plotContour->setObjectName("contour");
plotContour->get_plotter()->set_userSettigsFilename(QApplication::applicationDirPath()+"/usersettings.ini", "contour/");
layoutContour->addWidget(plotContour);
JKQtPlotter* plotDensity=new JKQtPlotter(true, this);
JKQTPLotter* plotDensity=new JKQTPLotter(true, this);
plotContour->set_doDrawing(false);
plotContour->get_plotter()->set_plotLabel(tr("\\textbf{2D histogram plot with contours}"));
plotDensity->get_plotter()->set_plotLabel(tr("\\textbf{2D histogram}"));

4
examples/jkqtplot_test/TestWidgetEmptyPlot.cpp
View File

@ -14,8 +14,8 @@ TestWidgetEmptyPlot::TestWidgetEmptyPlot(QWidget *parent) :
#define NEMPTY 500
JKQtPlotter* plotEmpty=new JKQtPlotter(true, this);
JKQTPxyLineGraph* efunc=new JKQTPxyLineGraph(plotEmpty->get_plotter());
JKQTPLotter* plotEmpty=new JKQTPLotter(true, this);
JKQTPXYLineGraph* efunc=new JKQTPXYLineGraph(plotEmpty->get_plotter());
double xef[NEMPTY], efy[NEMPTY];
for (int i=0; i<NEMPTY; i++) {
xef[i]=i;

10
examples/jkqtplot_test/TestWidgetFunctionPlots.cpp
View File

@ -16,9 +16,9 @@ TestWidgetFunctionPlots::TestWidgetFunctionPlots(QWidget *parent) :
QVBoxLayout* plotFuncLayout=new QVBoxLayout(this);
setLayout(plotFuncLayout);
plotFuncPlt=new JKQtPlotter(true, this);
plotFuncPlt=new JKQTPLotter(true, this);
plotFuncLayout->addWidget(plotFuncPlt);
pfunc=new JKQTPxParsedFunctionLineGraph(plotFuncPlt->get_plotter());
pfunc=new JKQTPXParsedFunctionLineGraph(plotFuncPlt->get_plotter());
pfunc->set_function("x^2/10+sin(x*pi*10)");
pfunc->set_errorFunction("x^2/20");
pfunc->set_drawErrorPolygons(true);
@ -26,7 +26,7 @@ TestWidgetFunctionPlots::TestWidgetFunctionPlots(QWidget *parent) :
plotFuncPlt->addGraph(pfunc);
plotFuncPlt->update_plot();
pfuncErrorStyle=new JKQTPerrorPlotstyleComboBox(this);
pfuncErrorStyle=new JKQTPErrorPlotstyleComboBox(this);
pfuncErrorStyle->setCurrentIndex(3);
plotFuncLayout->addWidget(pfuncErrorStyle);
connect(pfuncErrorStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(setPFuncStyle()));
@ -84,8 +84,8 @@ void TestWidgetFunctionPlots::setPFuncStyle()
{
pfunc->set_drawErrorLines(false);
pfunc->set_drawErrorPolygons(false);
if (pfuncErrorStyle->getErrorStyle()==JKQTPerrorLines) pfunc->set_drawErrorLines(true);
if (pfuncErrorStyle->getErrorStyle()==JKQTPerrorPolygons) pfunc->set_drawErrorPolygons(true);
if (pfuncErrorStyle->getErrorStyle()==JKQTPErrorLines) pfunc->set_drawErrorLines(true);
if (pfuncErrorStyle->getErrorStyle()==JKQTPErrorPolygons) pfunc->set_drawErrorPolygons(true);
pfunc->set_drawLine(chkPFuncDrawLine->isChecked());
pfunc->set_displaySamplePoints(chkPFuncDrawSamples->isChecked());
plotFuncPlt->update_plot();

6
examples/jkqtplot_test/TestWidgetFunctionPlots.h
View File

@ -46,9 +46,9 @@ class TestWidgetFunctionPlots : public QWidget
protected:
JKQTPxParsedFunctionLineGraph* pfunc;
JKQtPlotter* plotFuncPlt;
JKQTPerrorPlotstyleComboBox* pfuncErrorStyle;
JKQTPXParsedFunctionLineGraph* pfunc;
JKQTPLotter* plotFuncPlt;
JKQTPErrorPlotstyleComboBox* pfuncErrorStyle;
QCheckBox* chkPFuncDrawSamples;
QCheckBox* chkPFuncDrawLine;

36
examples/jkqtplot_test/TestWidgetGeometry.cpp
View File

@ -15,7 +15,7 @@ TestWidgetGeometry::TestWidgetGeometry(QWidget *parent) :
QVBoxLayout* layout1=new QVBoxLayout(this);
setLayout(layout1);
resize(1000, 800);
JKQtPlotter* plotGeo=new JKQtPlotter(true, this);
JKQTPLotter* plotGeo=new JKQTPLotter(true, this);
plotGeo->set_doDrawing(false);
plotGeo->setObjectName("plotGeo");
layout1->addWidget(plotGeo);
@ -30,21 +30,21 @@ TestWidgetGeometry::TestWidgetGeometry(QWidget *parent) :
plotGeo->get_plotter()->set_axisAspectRatio(1);
// JKQTPgeoLine* line1=new JKQTPgeoLine(plotGeo->get_plotter(), -1, -2, 2, 1.5);
// JKQTPGeoLine* line1=new JKQTPGeoLine(plotGeo->get_plotter(), -1, -2, 2, 1.5);
//plotGeo->get_plotter()->addGraph(line1);
// JKQTPgeoLine* line2=new JKQTPgeoLine(plotGeo->get_plotter(), 1, -5, 4, 3, QColor("blue"), 4);
// JKQTPGeoLine* line2=new JKQTPGeoLine(plotGeo->get_plotter(), 1, -5, 4, 3, QColor("blue"), 4);
//plotGeo->get_plotter()->addGraph(line2);
JKQTPgeoRectangle* rect1=new JKQTPgeoRectangle(plotGeo->get_plotter(), 1,1,2,2, QColor("blue"),2, Qt::SolidLine, QColor("lightblue"));
JKQTPGeoRectangle* rect1=new JKQTPGeoRectangle(plotGeo->get_plotter(), 1,1,2,2, QColor("blue"),2, Qt::SolidLine, QColor("lightblue"));
rect1->set_angle(30);
//plotGeo->get_plotter()->addGraph(rect1);
JKQTPgeoRectangle* rect2=new JKQTPgeoRectangle(plotGeo->get_plotter(), 1,1,2,2, QColor("red"),2);
JKQTPGeoRectangle* rect2=new JKQTPGeoRectangle(plotGeo->get_plotter(), 1,1,2,2, QColor("red"),2);
rect2->set_angle(45);
//plotGeo->get_plotter()->addGraph(rect2);
JKQTPgeoRectangle* rect3=new JKQTPgeoRectangle(plotGeo->get_plotter(), 1,1,2,4, QColor("green"),2);
JKQTPGeoRectangle* rect3=new JKQTPGeoRectangle(plotGeo->get_plotter(), 1,1,2,4, QColor("green"),2);
rect3->set_angle(-30);
//plotGeo->get_plotter()->addGraph(rect3);
JKQTPgeoEllipse* ell3=new JKQTPgeoEllipse(plotGeo->get_plotter(), 1,1,2,4, QColor("green"),2, Qt::SolidLine, QColor("lightgreen"), Qt::CrossPattern);
JKQTPGeoEllipse* ell3=new JKQTPGeoEllipse(plotGeo->get_plotter(), 1,1,2,4, QColor("green"),2, Qt::SolidLine, QColor("lightgreen"), Qt::CrossPattern);
ell3->set_angle(-30);
//plotGeo->get_plotter()->addGraph(ell3);
@ -55,31 +55,31 @@ TestWidgetGeometry::TestWidgetGeometry(QWidget *parent) :
p.append(QPointF(0,-2));
p.append(QPointF(M_PI,5.5));
// JKQTPgeoPolygon* poly=new JKQTPgeoPolygon(plotGeo->get_plotter(), p, QColor("black"), 1.5, Qt::SolidLine, QColor(128,128,0,128));
// JKQTPGeoPolygon* poly=new JKQTPGeoPolygon(plotGeo->get_plotter(), p, QColor("black"), 1.5, Qt::SolidLine, QColor(128,128,0,128));
//plotGeo->get_plotter()->addGraph(poly);
// JKQTPgeoPolyLines* lines=new JKQTPgeoPolyLines(plotGeo->get_plotter(), p, QColor(255,255,0), 3);
// JKQTPGeoPolyLines* lines=new JKQTPGeoPolyLines(plotGeo->get_plotter(), p, QColor(255,255,0), 3);
//plotGeo->get_plotter()->addGraph(lines);
JKQTPgeoEllipse* ell1=new JKQTPgeoEllipse(plotGeo->get_plotter(), 0,0,2,4, QColor("black"),1.5, Qt::DotLine);
JKQTPGeoEllipse* ell1=new JKQTPGeoEllipse(plotGeo->get_plotter(), 0,0,2,4, QColor("black"),1.5, Qt::DotLine);
plotGeo->get_plotter()->addGraph(ell1);
// JKQTPgeoArc* arc=new JKQTPgeoArc(plotGeo->get_plotter(), 0,0,2,4,0, 135, QColor("blue"),3, Qt::SolidLine);
// JKQTPGeoArc* arc=new JKQTPGeoArc(plotGeo->get_plotter(), 0,0,2,4,0, 135, QColor("blue"),3, Qt::SolidLine);
//plotGeo->get_plotter()->addGraph(arc);
// JKQTPgeoPie* pie=new JKQTPgeoPie(plotGeo->get_plotter(), 0,0,2,4,35, 98, QColor("blue"),3, Qt::SolidLine, QColor(0,0,255,127));
// JKQTPGeoPie* pie=new JKQTPGeoPie(plotGeo->get_plotter(), 0,0,2,4,35, 98, QColor("blue"),3, Qt::SolidLine, QColor(0,0,255,127));
//plotGeo->get_plotter()->addGraph(pie);
// JKQTPgeoChord* chord=new JKQTPgeoChord(plotGeo->get_plotter(), 0,0,2,4,35, 98, QColor("blue"),3, Qt::SolidLine, QColor(0,0,255,127));
// JKQTPGeoChord* chord=new JKQTPGeoChord(plotGeo->get_plotter(), 0,0,2,4,35, 98, QColor("blue"),3, Qt::SolidLine, QColor(0,0,255,127));
//plotGeo->get_plotter()->addGraph(chord);
JKQTPgeoInfiniteLine* iline=new JKQTPgeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,1,1, QColor("blue"), 3);
JKQTPGeoInfiniteLine* iline=new JKQTPGeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,1,1, QColor("blue"), 3);
plotGeo->get_plotter()->addGraph(iline);
JKQTPgeoInfiniteLine* iline1=new JKQTPgeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,-1,0, QColor("red"), 3);
JKQTPGeoInfiniteLine* iline1=new JKQTPGeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,-1,0, QColor("red"), 3);
plotGeo->get_plotter()->addGraph(iline1);
JKQTPgeoInfiniteLine* iline2=new JKQTPgeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,0,1, QColor("red"), 3);
JKQTPGeoInfiniteLine* iline2=new JKQTPGeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,0,1, QColor("red"), 3);
plotGeo->get_plotter()->addGraph(iline2);
JKQTPgeoInfiniteLine* iline3=new JKQTPgeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,-1,0.5, QColor("green"), 3);
JKQTPGeoInfiniteLine* iline3=new JKQTPGeoInfiniteLine(plotGeo->get_plotter(), 0.5,1,-1,0.5, QColor("green"), 3);
iline3->set_two_sided(true);
plotGeo->get_plotter()->addGraph(iline3);
JKQTPgeoText* text=new JKQTPgeoText(plotGeo->get_plotter(), -1, -1, "Test $f(x)=\\sqrt{\\sin(x^2)}$ \\textbf{bold}", 12, QColor("red"));
JKQTPGeoText* text=new JKQTPGeoText(plotGeo->get_plotter(), -1, -1, "Test $f(x)=\\sqrt{\\sin(x^2)}$ \\textbf{bold}", 12, QColor("red"));
plotGeo->get_plotter()->addGraph(text);
plotGeo->set_doDrawing(true);

90
examples/jkqtplot_test/TestWidgetGraphs.cpp
View File

@ -19,11 +19,11 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
ovlTime.start();
plot=new JKQtPlotter(true, this);
plot=new JKQTPLotter(true, this);
plot->set_doDrawing(false);
plotBot=new JKQtPlotter(false, this, plot->getDatastore());
plotBot2=new JKQtPlotter(false, this, plot->getDatastore());
ovl1=new JKQTPoverlayVerticalLine(0.0, tr("test"), plot->get_plotter());
plotBot=new JKQTPLotter(false, this, plot->getDatastore());
plotBot2=new JKQTPLotter(false, this, plot->getDatastore());
ovl1=new JKQTPOverlayVerticalLine(0.0, tr("test"), plot->get_plotter());
plot->get_plotter()->addOverlayElement(ovl1);
plot->setObjectName("plot");
plotBot->setObjectName("plotBot");
@ -48,7 +48,7 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
resize(1000, 800);
plotBot->synchronizeToMaster(plot, true, false);
connect(plot, SIGNAL(zoomChangedLocally(double,double,double,double,JKQtPlotter*)), plotBot, SLOT(synchronizeXAxis(double,double,double,double,JKQtPlotter*)));
connect(plot, SIGNAL(zoomChangedLocally(double,double,double,double,JKQTPLotter*)), plotBot, SLOT(synchronizeXAxis(double,double,double,double,JKQTPLotter*)));
plot->get_plotter()->set_gridPrinting(true);
plot->get_plotter()->addGridPrintingPlotter(0,1,plotBot->get_plotter());
plot->get_plotter()->addGridPrintingPlotter(0,2,plotBot2->get_plotter());
@ -75,16 +75,16 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
y21r[i]=double(rand()%100)/10.0-5.0;
y21re[i]=y21r[i]*double(rand()%10)/40.0;
}
JKQTPdatastore* ds=plot->get_plotter()->getDatastore();
JKQTPDatastore* ds=plot->get_plotter()->getDatastore();
//size_t cx1=ds->addColumn(x1, N1, "x1");
//size_t cy11=ds->addColumn(y11, N1, "y11");
//size_t cy12=ds->addColumn(y12, N1, "y12");
//size_t cy13=ds->addColumn(y13, N1, "y13");
//plot->addGraph(cx1, cy11, "$\\sin(x)$", JKQTPpoints);
//plot->addGraph(cy12, cx1, "$\\cos(x)$", JKQTPfilledCurveY);
//plot->addGraphWithXError(cy12, cx1, cy13, "$\\cos(x)$ with errors", JKQTPfilledCurveY, JKQTPerrorPolygons);
//plot->addGraph(cx1, cy11, "$\\sin(x)$", JKQTPPoints);
//plot->addGraph(cy12, cx1, "$\\cos(x)$", JKQTPFilledCurveY);
//plot->addGraphWithXError(cy12, cx1, cy13, "$\\cos(x)$ with errors", JKQTPFilledCurveY, JKQTPErrorPolygons);
for (unsigned int i=0; i<N2; i++) {
x2[i]=(double)(i+1)/(double)N2*8*M_PI;
@ -104,26 +104,26 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
size_t cy21re=ds->addColumn(y21re, N2, "y21re");
size_t id=plot->get_plotter()->addGraph(cx2, cy21, "$5\\cdot\\sin(x)$", JKQTPfilledCurveX);
JKQTPfilledCurveXGraph* fcxgr=qobject_cast<JKQTPfilledCurveXGraph*>(plot->get_plotter()->getGraph(id));
size_t id=plot->get_plotter()->addGraph(cx2, cy21, "$5\\cdot\\sin(x)$", JKQTPFilledCurveX);
JKQTPFilledCurveXGraph* fcxgr=qobject_cast<JKQTPFilledCurveXGraph*>(plot->get_plotter()->getGraph(id));
if (fcxgr) {
fcxgr->set_baseline(2);
}
size_t yeb=plot->get_plotter()->addGraphWithXYError(cx2, cy21, cy22, cy22, "sine with errors", JKQTPfilledCurveX);
size_t yeb=plot->get_plotter()->addGraphWithXYError(cx2, cy21, cy22, cy22, "sine with errors", JKQTPFilledCurveX);
plteErrors=plot->get_plotter()->getGraph(yeb);
setErrorStyle(0);
yeb=plot->get_plotter()->addGraph(cx2, cy21, "$5\\cdot\\sin(x)$", JKQTPlinesPoints);
yeb=plot->get_plotter()->addGraph(cx2, cy21, "$5\\cdot\\sin(x)$", JKQTPLinesPoints);
plteSymbols=plot->get_plotter()->getGraph(yeb);
pltePlot2=new JKQTPxyLineErrorGraph(plotBot->get_plotter());
pltePlot2=new JKQTPXYLineErrorGraph(plotBot->get_plotter());
pltePlot2->set_xColumn(cx2r);
pltePlot2->set_yColumn(cy21r);
pltePlot2->set_title(tr("random numbers"));
pltePlot2->set_drawLine(true);
pltePlot2->set_yErrorColumn(cy21re);
pltePlot2->set_yErrorStyle(JKQTPerrorBarsPolygons);
pltePlot2->set_symbol(JKQTPfilledStar);
pltePlot2->set_yErrorStyle(JKQTPErrorBarsPolygons);
pltePlot2->set_symbol(JKQTPFilledStar);
plotBot->get_plotter()->addGraph(pltePlot2);
plotBot->zoomToFit();
@ -164,21 +164,21 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
ts<<"bars 1"<<"bars 2"<<"bars 3";
plot->get_plotter()->addVerticalBargraph(cb, cbp, ts);
JKQTPverticalRange* r1=new JKQTPverticalRange(plot->get_plotter());
JKQTPVerticalRange* r1=new JKQTPVerticalRange(plot->get_plotter());
r1->set_rangeMin(5);
r1->set_rangeMax(10);
r1->set_rangeCenter(7.5);
r1->set_title("vert. range");
plot->get_plotter()->addGraph(r1);
JKQTPhorizontalRange* r2=new JKQTPhorizontalRange(plot->get_plotter());
JKQTPHorizontalRange* r2=new JKQTPHorizontalRange(plot->get_plotter());
r2->set_rangeMin(5);
r2->set_rangeMax(10);
r2->set_rangeCenter(7.5);
r2->set_title("hor. range");
plot->get_plotter()->addGraph(r2);
JKQTPboxplotVerticalGraph* box=new JKQTPboxplotVerticalGraph(plotBot2->get_plotter());
JKQTPBoxplotVerticalGraph* box=new JKQTPBoxplotVerticalGraph(plotBot2->get_plotter());
box->set_posColumn(cbxbox);
box->set_medianColumn(cbmed);
box->set_meanColumn(cbmean);
@ -190,7 +190,7 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
plotBot2->addGraph(box);
plotBot2->zoomToFit();
/*JKQTPyFunctionLineGraph* g=new JKQTPyFunctionLineGraph(&plot);
/*JKQTPYFunctionLineGraph* g=new JKQTPYFunctionLineGraph(&plot);
g->set_title("function 1");
g->set_plotFunction(f1);
g->set_errorFunction(f1e);
@ -199,18 +199,18 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
g->set_color(QColor("red"));
plot->addGraph(g);*/
/*JKQTPxFunctionLineGraph* g=new JKQTPxFunctionLineGraph(&plot);
/*JKQTPXFunctionLineGraph* g=new JKQTPXFunctionLineGraph(&plot);
g->set_title("function 2");
g->set_plotFunction(f2);
plot->addGraph(g);*/
/*JKQTPstepVerticalGraph* g=new JKQTPstepVerticalGraph(&plot);
/*JKQTPStepVerticalGraph* g=new JKQTPStepVerticalGraph(&plot);
g->set_xColumn(cy11);
g->set_yColumn(cx1);
g->set_fillCurve(true);
g->set_valuesCentered(true);
plot->addGraph(g);
plot->addGraph(cy11, cx1, "$\\sin(x)$", JKQTPpoints);*/
plot->addGraph(cy11, cx1, "$\\sin(x)$", JKQTPPoints);*/
plot->set_doDrawing(true);
plot->get_plotter()->zoomToFit(true, false);//, true);
@ -232,12 +232,12 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
layout->addWidget(chkInvertY);
layout->addWidget(chkInvertX);
layout->addWidget(chkInvertY);
JKQTPSymbolComboBox* cmbJKQTPplotSymbol=new JKQTPSymbolComboBox(this);
cmbJKQTPplotSymbol->setSymbol(JKQTPplus);
connect(cmbJKQTPplotSymbol, SIGNAL(currentIndexChanged(int)), this, SLOT(setESSymbol(int)));
layout->addWidget(cmbJKQTPplotSymbol);
JKQTPerrorPlotstyleComboBox* cmbErrors=new JKQTPerrorPlotstyleComboBox(this);
cmbErrors->setCurrentErrorStyle(JKQTPerrorBars);
JKQTPSymbolComboBox* cmbJKQTPPlotSymbol=new JKQTPSymbolComboBox(this);
cmbJKQTPPlotSymbol->setSymbol(JKQTPPlus);
connect(cmbJKQTPPlotSymbol, SIGNAL(currentIndexChanged(int)), this, SLOT(setESSymbol(int)));
layout->addWidget(cmbJKQTPPlotSymbol);
JKQTPErrorPlotstyleComboBox* cmbErrors=new JKQTPErrorPlotstyleComboBox(this);
cmbErrors->setCurrentErrorStyle(JKQTPErrorBars);
connect(cmbErrors, SIGNAL(currentIndexChanged(int)), this, SLOT(setErrorStyle(int)));
layout->addWidget(cmbErrors);
QDoubleSpinBox* spinScale=new QDoubleSpinBox(this);
@ -258,13 +258,13 @@ TestWidgetGraphs::TestWidgetGraphs(QWidget *parent) :
layout->addWidget(cmbSortOrder2);
JKQTPkeyLayoutComboBox* cmbKeyLayout=new JKQTPkeyLayoutComboBox(this);
connect(cmbKeyLayout, SIGNAL(currentLayoutChanged(JKQTPkeyLayout)), this, SLOT(setKeyLayout2(JKQTPkeyLayout)));
JKQTPKeyLayoutComboBox* cmbKeyLayout=new JKQTPKeyLayoutComboBox(this);
connect(cmbKeyLayout, SIGNAL(currentLayoutChanged(JKQTPKeyLayout)), this, SLOT(setKeyLayout2(JKQTPKeyLayout)));
layout->addWidget(cmbKeyLayout);
JKQTPkeyPositionComboBox* cmbKeyPos=new JKQTPkeyPositionComboBox(this);
connect(cmbKeyPos, SIGNAL(currentPositionChanged(JKQTPkeyPosition)), this, SLOT(setKeyPos2(JKQTPkeyPosition)));
JKQTPKeyPositionComboBox* cmbKeyPos=new JKQTPKeyPositionComboBox(this);
connect(cmbKeyPos, SIGNAL(currentPositionChanged(JKQTPKeyPosition)), this, SLOT(setKeyPos2(JKQTPKeyPosition)));
layout->addWidget(cmbKeyPos);
@ -303,14 +303,14 @@ void TestWidgetGraphs::setErrorStyle(int /*index*/)
{
QComboBox* cmb=qobject_cast<QComboBox*>(sender());
if (cmb) {
JKQTPxyGraphErrors* exy=dynamic_cast<JKQTPxyGraphErrors*>(plteErrors);
// JKQTPxGraphErrors* ex=dynamic_cast<JKQTPxGraphErrors*>(plteErrors);
JKQTPyGraphErrors* ey=dynamic_cast<JKQTPyGraphErrors*>(plteErrors);
JKQTPXYGraphErrors* exy=dynamic_cast<JKQTPXYGraphErrors*>(plteErrors);
// JKQTPXGraphErrors* ex=dynamic_cast<JKQTPXGraphErrors*>(plteErrors);
JKQTPYGraphErrors* ey=dynamic_cast<JKQTPYGraphErrors*>(plteErrors);
if (exy) {
exy->set_yErrorStyle(String2JKQTPerrorPlotstyle(cmb->itemData(cmb->currentIndex()).toString()));
exy->set_yErrorStyle(String2JKQTPErrorPlotstyle(cmb->itemData(cmb->currentIndex()).toString()));
}
if (ey) {
ey->set_yErrorStyle(String2JKQTPerrorPlotstyle(cmb->itemData(cmb->currentIndex()).toString()));
ey->set_yErrorStyle(String2JKQTPErrorPlotstyle(cmb->itemData(cmb->currentIndex()).toString()));
}
plot->update_plot();
}
@ -320,9 +320,9 @@ void TestWidgetGraphs::setESSymbol(int /*index*/)
{
QComboBox* cmb=qobject_cast<QComboBox*>(sender());
if (cmb) {
JKQTPxyLineGraph* exy=dynamic_cast<JKQTPxyLineGraph*>(plteSymbols);
JKQTPXYLineGraph* exy=dynamic_cast<JKQTPXYLineGraph*>(plteSymbols);
if (exy) {
exy->set_symbol(String2JKQTPgraphSymbols(cmb->itemData(cmb->currentIndex()).toString()));
exy->set_symbol(String2JKQTPGraphSymbols(cmb->itemData(cmb->currentIndex()).toString()));
}
plot->update_plot();
@ -332,13 +332,13 @@ void TestWidgetGraphs::setESSymbol(int /*index*/)
void TestWidgetGraphs::setSortOrder2(int index)
{
if (index==0) pltePlot2->set_sortData(JKQTPxyGraph::Unsorted);
if (index==1) pltePlot2->set_sortData(JKQTPxyLineGraph::SortedX);
if (index==2) pltePlot2->set_sortData(JKQTPxyLineGraph::SortedY);
if (index==0) pltePlot2->set_sortData(JKQTPXYGraph::Unsorted);
if (index==1) pltePlot2->set_sortData(JKQTPXYLineGraph::SortedX);
if (index==2) pltePlot2->set_sortData(JKQTPXYLineGraph::SortedY);
plotBot->update_plot();
}
void TestWidgetGraphs::setKeyLayout2(JKQTPkeyLayout layout)
void TestWidgetGraphs::setKeyLayout2(JKQTPKeyLayout layout)
{
plot->get_plotter()->set_keyLayout(layout);
plotBot->get_plotter()->set_keyLayout(layout);
@ -348,7 +348,7 @@ void TestWidgetGraphs::setKeyLayout2(JKQTPkeyLayout layout)
plotBot2->update_plot();
}
void TestWidgetGraphs::setKeyPos2(JKQTPkeyPosition layout)
void TestWidgetGraphs::setKeyPos2(JKQTPKeyPosition layout)
{
plot->get_plotter()->set_keyPosition(layout);
plotBot->get_plotter()->set_keyPosition(layout);

20
examples/jkqtplot_test/TestWidgetGraphs.h
View File

@ -43,8 +43,8 @@ class TestWidgetGraphs : public QWidget
void setSortOrder2(int index);
void setKeyLayout2(JKQTPkeyLayout layout);
void setKeyPos2(JKQTPkeyPosition layout);
void setKeyLayout2(JKQTPKeyLayout layout);
void setKeyPos2(JKQTPKeyPosition layout);
protected:
double x1[N1], x2[N2], x2r[N2]/*, x3[N3]*/;
@ -53,15 +53,15 @@ class TestWidgetGraphs : public QWidget
double b1[N3], b2[N3], b3[N3];
JKQTPoverlayVerticalLine* ovl1;
JKQtPlotter* plot;
JKQtPlotter* plotLOG;
JKQtPlotter* plotBot;
JKQtPlotter* plotBot2;
JKQTPOverlayVerticalLine* ovl1;
JKQTPLotter* plot;
JKQTPLotter* plotLOG;
JKQTPLotter* plotBot;
JKQTPLotter* plotBot2;
JKQTPplotElement* plteErrors;
JKQTPplotElement* plteSymbols;
JKQTPxyLineErrorGraph* pltePlot2;
JKQTPPlotElement* plteErrors;
JKQTPPlotElement* plteSymbols;
JKQTPXYLineErrorGraph* pltePlot2;
int ovlCnt;

2
examples/jkqtplot_test/TestWidgetImages.cpp
View File

@ -19,7 +19,7 @@ TestWidgetImages::TestWidgetImages(QWidget *parent) :
layouti->addLayout(layWid);
setLayout(layouti);
resize(1000, 800);
plotImg=new JKQtPlotter(true, this);
plotImg=new JKQTPLotter(true, this);
plotImg->set_doDrawing(false);
plotImg->get_plotter()->set_plotLabel(tr("\\textbf{image plot}"));
plotImg->setObjectName("plotImg");

2
examples/jkqtplot_test/TestWidgetImages.h
View File

@ -47,7 +47,7 @@ class TestWidgetImages : public QWidget
JKQTPMathImage* pimg2;
JKQTPMathImage* pimg3;
JKQtPlotter* plotImg;
JKQTPLotter* plotImg;
};

6
examples/jkqtplot_test/TestWidgetLogGraphs.cpp
View File

@ -13,12 +13,12 @@ TestWidgetLogGraphs::TestWidgetLogGraphs(QWidget *parent) :
QWidget(parent)
{
JKQtPlotter* plotLOG=new JKQtPlotter(this);
JKQTPLotter* plotLOG=new JKQTPLotter(this);
plotLOG->set_doDrawing(false);
plotLOG->setObjectName("plotLOG");
plotLOG->get_plotter()->set_userSettigsFilename(QApplication::applicationDirPath()+"/usersettings.ini", "plotLOG/");
JKQTPdatastore* ds=plotLOG->get_plotter()->getDatastore();
JKQTPDatastore* ds=plotLOG->get_plotter()->getDatastore();
QVector<double> x,y;
for (unsigned int i=0; i<N2; i++) {
const double xx=static_cast<double>(i+1)/static_cast<double>(N2)*15.0;
@ -38,7 +38,7 @@ TestWidgetLogGraphs::TestWidgetLogGraphs(QWidget *parent) :
resize(1000, 800);
plotLOG->get_plotter()->addGraph(cx2, cy23, "data, $f(x)=5^{x/5}$", JKQTPlines);
plotLOG->get_plotter()->addGraph(cx2, cy23, "data, $f(x)=5^{x/5}$", JKQTPLines);
plotLOG->set_doDrawing(true);

8
examples/jkqtplot_test/TestWidgetParamScatterPlots.cpp
View File

@ -17,7 +17,7 @@ TestWidgetParamScatterPlots::TestWidgetParamScatterPlots(QWidget *parent) :
setLayout(layoutPSP);
resize(1000, 800);
plotPSP=new JKQtPlotter(true, this);
plotPSP=new JKQTPLotter(true, this);
plotPSP->set_doDrawing(false);
plotPSP->get_plotter()->set_plotLabel(tr("\\textbf{parametrized scatter plots}"));
plotPSP->setObjectName("plotPSP");
@ -50,7 +50,7 @@ TestWidgetParamScatterPlots::TestWidgetParamScatterPlots(QWidget *parent) :
int psps=plotPSP->getDatastore()->addCopiedColumn(dataS, "size");
int pspsy=plotPSP->getDatastore()->addCopiedColumn(dataSy, "symbol");
pltePSPCol=new JKQTPxyParametrizedErrorScatterGraph(plotPSP->get_plotter());
pltePSPCol=new JKQTPXYParametrizedErrorScatterGraph(plotPSP->get_plotter());
pltePSPCol->set_title(tr("changing color"));
pltePSPCol->set_xColumn(pspx);
pltePSPCol->set_yColumn(pspy);
@ -61,7 +61,7 @@ TestWidgetParamScatterPlots::TestWidgetParamScatterPlots(QWidget *parent) :
pltePSPCol->set_drawLine(true);
plotPSP->get_plotter()->addGraph(pltePSPCol);
pltePSPSize=new JKQTPxyParametrizedScatterGraph(plotPSP->get_plotter());
pltePSPSize=new JKQTPXYParametrizedScatterGraph(plotPSP->get_plotter());
pltePSPSize->set_xColumn(pspx);
pltePSPSize->set_yColumn(pspy1);
pltePSPSize->set_sizeColumn(psps);
@ -69,7 +69,7 @@ TestWidgetParamScatterPlots::TestWidgetParamScatterPlots(QWidget *parent) :
plotPSP->get_plotter()->addGraph(pltePSPSize);
pltePSPSymb=new JKQTPxyParametrizedScatterGraph(plotPSP->get_plotter());
pltePSPSymb=new JKQTPXYParametrizedScatterGraph(plotPSP->get_plotter());
pltePSPSymb->set_xColumn(pspx);
pltePSPSymb->set_yColumn(pspy3);
pltePSPSymb->set_symbolColumn(pspsy);

8
examples/jkqtplot_test/TestWidgetParamScatterPlots.h
View File

@ -40,10 +40,10 @@ class TestWidgetParamScatterPlots : public QWidget
protected:
JKQtPlotter* plotPSP;
JKQTPxyParametrizedErrorScatterGraph* pltePSPCol;
JKQTPxyParametrizedScatterGraph* pltePSPSize;
JKQTPxyParametrizedScatterGraph* pltePSPSymb;
JKQTPLotter* plotPSP;
JKQTPXYParametrizedErrorScatterGraph* pltePSPCol;
JKQTPXYParametrizedScatterGraph* pltePSPSize;
JKQTPXYParametrizedScatterGraph* pltePSPSymb;

2
examples/jkqtplot_test/TestWidgetPeaksPlots.cpp
View File

@ -18,7 +18,7 @@ TestWidgetPeaksPlots::TestWidgetPeaksPlots(QWidget *parent) :
QVBoxLayout* layoutpeaks=new QVBoxLayout(this);
setLayout(layoutpeaks);
resize(1000, 800);
plotPeaks=new JKQtPlotter(true, this);
plotPeaks=new JKQTPLotter(true, this);
plotPeaks->set_doDrawing(false);
plotPeaks->get_plotter()->set_plotLabel(tr("\\textbf{peaks stream plot}"));
plotPeaks->setObjectName("plotPeaks");

2
examples/jkqtplot_test/TestWidgetPeaksPlots.h
View File

@ -34,7 +34,7 @@ class TestWidgetPeaksPlots : public QWidget
protected:
JKQtPlotter* plotPeaks;
JKQTPLotter* plotPeaks;
JKQTPPeakStreamGraph* graphPeakStream1;
JKQTPPeakStreamGraph* graphPeakStream2;

2
examples/jkqtplot_test/TestWidgetRGBImages.cpp
View File

@ -19,7 +19,7 @@ TestWidgetRGBImages::TestWidgetRGBImages(QWidget *parent) :
QFormLayout* frm=new QFormLayout(nullptr);
winrgb->setLayout(layoutrgb);
winrgb->resize(1000, 800);
plotImgRGB=new JKQtPlotter(true, winrgb);
plotImgRGB=new JKQTPLotter(true, winrgb);
plotImgRGB->set_doDrawing(false);
plotImgRGB->get_plotter()->set_plotLabel(tr("\\textbf{RGB image plot}"));
plotImgRGB->setObjectName("plotImgRGB");

2
examples/jkqtplot_test/TestWidgetRGBImages.h
View File

@ -54,7 +54,7 @@ class TestWidgetRGBImages : public QWidget
int rgb_colr, rgb_colb, rgb_colg, rgb_cola;
JKQtPlotter* plotImgRGB;
JKQTPLotter* plotImgRGB;
JKQTPRGBMathImage* rgbimg;
JKQTPColumnRGBMathImage* rgbimg2;

2
examples/jkqtplot_test/jkqtpemfengineadapter.h
View File

@ -6,7 +6,7 @@
#include <QStringList>
#include "../../../jkqtpbaseplotter.h"
class JKQTPEmfEngineAdapter : public JKQtBasePlotter::JKQTPPaintDeviceAdapter
class JKQTPEmfEngineAdapter : public JKQTBasePlotter::JKQTPPaintDeviceAdapter
{
public:
JKQTPEmfEngineAdapter();

2
examples/jkqtplot_test/jkqtplot_test.pro
View File

@ -58,7 +58,7 @@ QT += core gui xml svg
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += $$PWD
#$$PWD/../../lib
INCLUDEPATH += ../../lib

2
examples/jkqtplot_test/testmain.cpp
View File

@ -27,7 +27,7 @@ TestMain::TestMain(QWidget *parent) :
{
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
#ifdef Q_WS_WIN
JKQtBasePlotter::registerPaintDeviceAdapter(new JKQTPEmfEngineAdapter());
JKQTBasePlotter::registerPaintDeviceAdapter(new JKQTPEmfEngineAdapter());
#endif
#endif

18
examples/simpletest/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Very simple line-graph {#JKQTPlotterSimpleTest}
This project (see `./examples/simpletest/`) simply creates a JKQtPlotter widget (as a new window) and adds a single line-graph (a sine-wave). Data is initialized from two QVector<double> objects.
# Example (JKQTPLotter): Very simple line-graph {#JKQTPLotterSimpleTest}
This project (see `./examples/simpletest/`) simply creates a JKQTPLotter widget (as a new window) and adds a single line-graph (a sine-wave). Data is initialized from two QVector<double> objects.
The QMake project looks like this (see [`jkqtplotter_simpletest.pro`](../simpletest/jkqtplotter_simpletest.pro):
```.qmake
# source code for this simple demo
@ -13,7 +13,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest
# include JKQtPlotter source headers and link against library
# include JKQTPLotter source headers and link against library
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {
@ -23,7 +23,7 @@ CONFIG (debug, debug|release) {
}
```
Alternatively to linking agains a `libjkqtplotter`, you can also directy add the JKQtPlotter sources to the project:
Alternatively to linking agains a `libjkqtplotter`, you can also directy add the JKQTPLotter sources to the project:
```.qmake
# source code for this simple demo
SOURCES = jkqtplotter_simpletest.cpp
@ -36,7 +36,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest
# include JKQtPlotter source code
# include JKQTPLotter source code
include(../../lib/jkqtplotter.pri)
```
The soruce code of the main application is (see [`jkqtplotter_simpletest.cpp`](../simpletest/jkqtplotter_simpletest.cpp):
@ -51,8 +51,8 @@ int main(int argc, char* argv[])
// 1. create a plotter window and get a pointer to the internal datastore
// (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for a simple plot (a sine curve)
QVector<double> X, Y;
@ -63,7 +63,7 @@ int main(int argc, char* argv[])
Y<<sin(x);
}
// 3. make data available to JKQtPlotter by adding it to the internal
// 3. make data available to JKQTPLotter by adding it to the internal
// datastore.
// Note: In this step the data is copied (of not specified otherwise), so
// you can reuse X and Y afterwards!
@ -74,7 +74,7 @@ int main(int argc, char* argv[])
size_t columnY=ds->addCopiedColumn(Y, "y");
// 4. create a graph in the plot, which plots the dataset X/Y:
JKQTPxyLineGraph* graph1=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph1=new JKQTPXYLineGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_title(QObject::tr("sine graph"));

12
examples/simpletest/jkqtplotter_simpletest.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest.cpp
* A very basic example for the usage of JKQtPlotter
* A very basic example for the usage of JKQTPLotter
*
* \ref JKQTPlotterSimpleTest
* \ref JKQTPLotterSimpleTest
*/
#include <QApplication>
@ -14,8 +14,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for a simple plot (a sine curve)
QVector<double> X, Y;
@ -26,7 +26,7 @@ int main(int argc, char* argv[])
Y<<sin(x);
}
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Note: In this step the data is copied (of not specified otherwise), so you can
// reuse X and Y afterwards!
// the variables columnX and columnY will contain the internal column ID of the newly
@ -35,7 +35,7 @@ int main(int argc, char* argv[])
size_t columnY=ds->addCopiedColumn(Y, "y");
// 4. create a graph in the plot, which plots the dataset X/Y:
JKQTPxyLineGraph* graph1=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph1=new JKQTPXYLineGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_title(QObject::tr("sine graph"));

2
examples/simpletest/jkqtplotter_simpletest.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest
# include JKQtPlotter source headers and link against library
# include JKQTPLotter source headers and link against library
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

22
examples/simpletest_barchart/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple barchart {#JKQtPlotterBarcharts}
This project (see [`simpletest_barchart`](../simpletest_barchart) simply creates a JKQtPlotter widget (as a new window) and adds several barcharts. They are ordered in groups.
# Example (JKQTPLotter): Simple barchart {#JKQTPLotterBarcharts}
This project (see [`simpletest_barchart`](../simpletest_barchart) simply creates a JKQTPLotter widget (as a new window) and adds several barcharts. They are ordered in groups.
The soruce code of the main application is (see [`jkqtplotter_simpletest_barchart.cpp`](../simpletest_barchart/jkqtplotter_simpletest_barchart.cpp):
```.cpp
@ -13,11 +13,11 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPLotter plot;
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for three simple barchart
QString L[Ndata]={ "cat. A", "cat. B", "cat. C", "cat. D", "other"};
@ -26,7 +26,7 @@ int main(int argc, char* argv[])
double Y2[Ndata]={ -5, -3, 1, 3, 6};
double Y3[Ndata]={ 6, 2, 5, 3, 6};
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Note: In this step the data is copied (of not specified otherwise)
// the variables columnX and columnY... will contain the internal column ID of the
// newly created columns with names "x" and "y..." and the (copied) data from X
@ -37,15 +37,15 @@ int main(int argc, char* argv[])
size_t columnY3=ds->addCopiedColumn(Y3, Ndata, "y3");
// 4. create graphs in the plot, which plots the dataset X/Y1, X/Y2 and X/Y3:
JKQTPbarVerticalGraph* graph1=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph1=new JKQTPBarVerticalGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY1);
graph1->set_title(QObject::tr("dataset 1"));
JKQTPbarVerticalGraph* graph2=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph2=new JKQTPBarVerticalGraph(&plot);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY2);
graph2->set_title(QObject::tr("dataset 2"));
JKQTPbarVerticalGraph* graph3=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph3=new JKQTPBarVerticalGraph(&plot);
graph3->set_xColumn(columnX);
graph3->set_yColumn(columnY3);
graph3->set_title(QObject::tr("dataset 3"));
@ -57,7 +57,7 @@ int main(int argc, char* argv[])
plot.addGraph(graph3);
// 6. now we set the graphs, so they are plotted side-by-side
// This function searches all JKQTPbarVerticalGraph in the current
// This function searches all JKQTPBarVerticalGraph in the current
// plot and sets their shift/scale so they form a nice plot with
// side-by-side groups
graph1->autoscaleBarWidthAndShift(0.75, 1);
@ -76,8 +76,8 @@ int main(int argc, char* argv[])
// type JKQTBasePlotter, which does the actual plotting.
// So many properties of the plot are only available in this internal
// object, which you can access by plot.get_plotter().
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPkeyLayoutOneRow);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPKeyLayoutOneRow);
// 9 autoscale the plot so the graph is contained
plot.zoomToFit();

22
examples/simpletest_barchart/jkqtplotter_simpletest_barchart.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_barchart.cpp
* Shows how to draw Barcharts with JKQtPlotter
* Shows how to draw Barcharts with JKQTPLotter
*
* \ref JKQtPlotterBarcharts
* \ref JKQTPLotterBarcharts
*/
#include <QApplication>
@ -15,11 +15,11 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPLotter plot;
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for three simple barchart
QString L[Ndata]={ "cat. A", "cat. C", "cat. B", "cat. D", "other"}; // unsorted category axis
@ -30,7 +30,7 @@ int main(int argc, char* argv[])
double Y2[Ndata]={ -5, -3, 1, 3, 6};
double Y3[Ndata]={ 6, 2, 5, 3, 6};
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Note: In this step the data is copied (of not specified otherwise)
// the variables columnX and columnY... will contain the internal column ID of the
// newly created columns with names "x" and "y..." and the (copied) data from X
@ -41,15 +41,15 @@ int main(int argc, char* argv[])
size_t columnY3=ds->addCopiedColumn(Y3, Ndata, "y3");
// 4. create graphs in the plot, which plots the dataset X/Y1, X/Y2 and X/Y3:
JKQTPbarVerticalGraph* graph1=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph1=new JKQTPBarVerticalGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY1);
graph1->set_title(QObject::tr("dataset 1"));
JKQTPbarVerticalGraph* graph2=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph2=new JKQTPBarVerticalGraph(&plot);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY2);
graph2->set_title(QObject::tr("dataset 2"));
JKQTPbarVerticalGraph* graph3=new JKQTPbarVerticalGraph(&plot);
JKQTPBarVerticalGraph* graph3=new JKQTPBarVerticalGraph(&plot);
graph3->set_xColumn(columnX);
graph3->set_yColumn(columnY3);
graph3->set_title(QObject::tr("dataset 3"));
@ -61,7 +61,7 @@ int main(int argc, char* argv[])
plot.addGraph(graph3);
// 6. now we set the graphs, so they are plotted side-by-side
// This function searches all JKQTPbarHorizontalGraph in the current
// This function searches all JKQTPBarHorizontalGraph in the current
// plot and sets their shift/scale so they form a nice plot with
// side-by-side groups
graph1->autoscaleBarWidthAndShift(0.75, 1);
@ -80,8 +80,8 @@ int main(int argc, char* argv[])
// type JKQTBasePlotter, which does the actual plotting.
// So many properties of the plot are only available in this internal
// object, which you can access by plot.get_plotter().
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPkeyLayoutOneRow);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPKeyLayoutOneRow);
// 9 autoscale the plot so the graph is contained
plot.zoomToFit();

2
examples/simpletest_barchart/jkqtplotter_simpletest_barchart.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_barchart
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

12
examples/simpletest_dateaxes/README.md
View File

@ -1,7 +1,7 @@
# Example (JKQtPlotter): Date/Time Axes {#JKQtPlotterDateTimeAxes}
# Example (JKQTPLotter): Date/Time Axes {#JKQTPLotterDateTimeAxes}
## Date Axis
This project (see `./examples/simpletest_dateaxes/`) simply creates a JKQtPlotter widget (as a new window) with the X-axis showing time or date(-time) values, formated as such.
This project (see `./examples/simpletest_dateaxes/`) simply creates a JKQTPLotter widget (as a new window) with the X-axis showing time or date(-time) values, formated as such.
The source code of the main application can be found in [`jkqtplotter_simpletest_dateaxes.cpp`](../simpletest_dateaxes/jkqtplotter_simpletest_dateaxes.cpp).
@ -39,10 +39,10 @@ The parsed data looks like this (data was taken from http://wetter.mpg-ge.de/NOA
...
```
Then two graphs are added. One of type `JKQTPfilledVerticalRangeGraph` plots the range of min+max temperature for each month:
Then two graphs are added. One of type `JKQTPFilledVerticalRangeGraph` plots the range of min+max temperature for each month:
```.cpp
// 3. add a plot for the data mean line (graphTemperature) and range (graphTemperatureRange)
JKQTPfilledVerticalRangeGraph* graphTemperatureRange=new JKQTPfilledVerticalRangeGraph(&plot);
JKQTPFilledVerticalRangeGraph* graphTemperatureRange=new JKQTPFilledVerticalRangeGraph(&plot);
// 4. copy data into datastore and immediately set the yColumn
size_t colDate=ds->addCopiedColumn(date, "date");
@ -66,7 +66,7 @@ On top of that plot, a second plot is added, which draws the average temperature
```.cpp
// 3. add a plot for the data mean line (graphTemperature) and range (graphTemperatureRange)
JKQTPxyLineErrorGraph* graphTemperature=new JKQTPxyLineErrorGraph(&plot);
JKQTPXYLineErrorGraph* graphTemperature=new JKQTPXYLineErrorGraph(&plot);
// 4. copy data into datastore and immediately set the yColumn
size_t colDate=ds->addCopiedColumn(date, "date");
@ -79,7 +79,7 @@ On top of that plot, a second plot is added, which draws the average temperature
// 6. average data
// don't use symbols
graphTemperature->set_symbol(JKQTPnoSymbol);
graphTemperature->set_symbol(JKQTPNoSymbol);
// set the line width
graphTemperature->set_lineWidth(1);
// draw small symbols

26
examples/simpletest_dateaxes/jkqtplotter_simpletest_dateaxes.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_dateaxes.cpp
* Shows how to use date/time axes with JKQtPlotter
* Shows how to use date/time axes with JKQTPLotter
*
* \ref JKQtPlotterDateTimeAxes
* \ref JKQTPLotterDateTimeAxes
*/
#include <QApplication>
@ -15,10 +15,10 @@
#include "jkqtplottertools/jkqtptools.h"
#include "jkqtplotter/jkqtpgraphsfilledcurve.h"
void drawWithDateAxis(JKQtPlotter& plot) {
void drawWithDateAxis(JKQTPLotter& plot) {
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data vectors with data parsed from a CSV-file
QVector<double> date;
@ -43,8 +43,8 @@ void drawWithDateAxis(JKQtPlotter& plot) {
}
// 3. add a plot for the data mean line (graphTemperature) and range (graphTemperatureRange)
JKQTPfilledVerticalRangeGraph* graphTemperatureRange=new JKQTPfilledVerticalRangeGraph(&plot);
JKQTPxyLineErrorGraph* graphTemperature=new JKQTPxyLineErrorGraph(&plot);
JKQTPFilledVerticalRangeGraph* graphTemperatureRange=new JKQTPFilledVerticalRangeGraph(&plot);
JKQTPXYLineErrorGraph* graphTemperature=new JKQTPXYLineErrorGraph(&plot);
// 4. copy data into datastore and immediately set the yColumn
size_t colDate=ds->addCopiedColumn(date, "date");
@ -67,7 +67,7 @@ void drawWithDateAxis(JKQtPlotter& plot) {
// 6. average data
// don't use symbols
graphTemperature->set_symbol(JKQTPnoSymbol);
graphTemperature->set_symbol(JKQTPNoSymbol);
// set the line width
graphTemperature->set_lineWidth(1);
// draw small symbols
@ -98,9 +98,9 @@ void drawWithDateAxis(JKQtPlotter& plot) {
plot.setWindowTitle("Date Axis");
}
void drawWithTimeAxis(JKQtPlotter& plot) {
void drawWithTimeAxis(JKQTPLotter& plot) {
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data vectors with data parsed from a CSV-file
QVector<double> time;
@ -124,7 +124,7 @@ void drawWithTimeAxis(JKQtPlotter& plot) {
}
// 3. add a plot for the data mean line (graphTemperature) and range (graphTemperatureRange)
JKQTPxyLineErrorGraph* graphTemperature=new JKQTPxyLineErrorGraph(&plot);
JKQTPXYLineErrorGraph* graphTemperature=new JKQTPXYLineErrorGraph(&plot);
// 4. copy data into datastore and immediately set the yColumn
size_t colDate=ds->addCopiedColumn(time, "time");
@ -134,7 +134,7 @@ void drawWithTimeAxis(JKQtPlotter& plot) {
// 6. average data
// don't use symbols
graphTemperature->set_symbol(JKQTPcross);
graphTemperature->set_symbol(JKQTPCross);
// set the line width
graphTemperature->set_lineWidth(1);
// draw small symbols
@ -169,10 +169,10 @@ void drawWithTimeAxis(JKQtPlotter& plot) {
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plotDate;
JKQTPLotter plotDate;
drawWithDateAxis(plotDate);
plotDate.move(100,100);
JKQtPlotter plotTime;
JKQTPLotter plotTime;
drawWithTimeAxis(plotTime);
plotTime.move(100,550);

2
examples/simpletest_dateaxes/jkqtplotter_simpletest_dateaxes.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_dateaxes
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

28
examples/simpletest_errorbarstyles/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Different Types of Errorindicators {#JKQtPlotterErrorBarStyles}
This project (see `./examples/simpletest_errorbarstyles/`) simply creates a JKQtPlotter widget (as a new window) and adds several curves show-casing different styles of error indicators. Data is initialized from two QVector<double> objects.
# Example (JKQTPLotter): Different Types of Errorindicators {#JKQTPLotterErrorBarStyles}
This project (see `./examples/simpletest_errorbarstyles/`) simply creates a JKQTPLotter widget (as a new window) and adds several curves show-casing different styles of error indicators. Data is initialized from two QVector<double> objects.
The source code of the main application can be found in [`jkqtplotter_simpletest_errorbarstyles.cpp`](../simpletest_errorbarstyles/jkqtplotter_simpletest_errorbarstyles.cpp).
@ -11,7 +11,7 @@ First some data is added to the internal datastore (mostly, like explained in se
// the array showXandYError indicates whether we want x- and y-error
// for a style for all stywhere this is false, only y-error-indicators
// are shown
QVector<JKQTPerrorPlotstyle> errorStyles {JKQTPnoError, JKQTPerrorBars, JKQTPerrorSimpleBars, JKQTPerrorLines, JKQTPerrorPolygons, JKQTPerrorBoxes, JKQTPerrorEllipses, JKQTPerrorBarsPolygons, JKQTPerrorBarsLines, JKQTPerrorSimpleBarsLines, JKQTPerrorSimpleBarsPolygons };
QVector<JKQTPErrorPlotstyle> errorStyles {JKQTPNoError, JKQTPErrorBars, JKQTPErrorSimpleBars, JKQTPErrorLines, JKQTPErrorPolygons, JKQTPErrorBoxes, JKQTPErrorEllipses, JKQTPErrorBarsPolygons, JKQTPErrorBarsLines, JKQTPErrorSimpleBarsLines, JKQTPErrorSimpleBarsPolygons };
QVector<bool> showXandYError { false , true , true , false , false , true , true , false , false , false , false };
for (int errorID=0; errorID<errorStyles.size(); errorID++) {
@ -22,7 +22,7 @@ First some data is added to the internal datastore (mostly, like explained in se
}
// create a graph object
JKQTPxyLineErrorGraph* graph=new JKQTPxyLineErrorGraph(&plot);
JKQTPXYLineErrorGraph* graph=new JKQTPXYLineErrorGraph(&plot);
// copy data into datastore and immediately set the yColumn
graph->set_xColumn(columnX);
@ -33,7 +33,7 @@ First some data is added to the internal datastore (mostly, like explained in se
// set error style, for the y-axis
graph->set_yErrorStyle(errorStyles[errorID]);
// no error indicators for the x-values
graph->set_xErrorStyle(JKQTPnoError);
graph->set_xErrorStyle(JKQTPNoError);
// ... unless: for some error styles we want error in both directions
if (showXandYError[errorID]) {
graph->set_xErrorStyle(errorStyles[errorID]);
@ -50,7 +50,7 @@ First some data is added to the internal datastore (mostly, like explained in se
// set symbol (cross/X) + pen style (and color)dashed)
graph->set_symbol(JKQTPcross);
graph->set_symbol(JKQTPCross);
graph->set_style(Qt::DashLine);
// set symbol size
graph->set_symbolSize(5);
@ -60,9 +60,9 @@ First some data is added to the internal datastore (mostly, like explained in se
graph->set_lineWidth(1);
// graph title is made from symbol+errorStylestyle, we use the LaTeX instruction \verb around the
// result of JKQTPerrorPlotstyle2String(), because it contains underscores that would otherwise
// result of JKQTPErrorPlotstyle2String(), because it contains underscores that would otherwise
// lead to lower-case letter, which we don't want
graph->set_title("\\verb{"+JKQTPerrorPlotstyle2String(errorStyles[errorID])+"}");
graph->set_title("\\verb{"+JKQTPErrorPlotstyle2String(errorStyles[errorID])+"}");
// add the graph to the plot, so it is actually displayed
plot.addGraph(graph);
@ -89,12 +89,12 @@ There are several variables that can be used to further style the error indicato
graph->set_errorbarSize(15);
```
There are more properties that you can find in the documentation of the mix-in classes `JKQTPxyGraphErrors`, `JKQTPxGraphErrors`, `JKQTPyGraphErrors`, `JKQTPgraphErrors`.
There are more properties that you can find in the documentation of the mix-in classes `JKQTPXYGraphErrors`, `JKQTPXGraphErrors`, `JKQTPYGraphErrors`, `JKQTPGraphErrors`.
In addition the plot key is moved outside the pot and the grid in the plot is switched off:
```.cpp
// 6. change locaion of key (outside top-right)
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideRightTop);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideRightTop);
// ... and switch off the grid
plot.get_xAxis()->set_drawGrid(false);
plot.get_xAxis()->set_drawMinorGrid(false);
@ -106,10 +106,10 @@ The result looks like this:
![jkqtplotter_simpletest_errorbarstyles](../../screenshots/jkqtplotter_simpletest_errorbarstyles.png)
Error bars are implemented in the mixin-classes `JKQTPxyGraphErrors`, `JKQTPxGraphErrors` and `JKQTPyGraphErrors` that are all derived from `JKQTPgraphErrors`. With these it is simple to add error indicators to several different plot styles. Usually you can recognize these by looking at the class name, e.g. `JKQTPxyLineGraph` is a simple line+symbol graph, and `JKQTPxyLineErrorGraph` is the same with error indictaors (see above). There are also several other plots with error indicators:
- `JKQTPbarVerticalErrorGraph` for barcharts with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_barcharts.png)
- `JKQTPimpulsesVerticalGraph` for impulse/candle-stick charts with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_impulses.png)
- `JKQTPfilledCurveXErrorGraph` for filled curves with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_filledcurves.png)
Error bars are implemented in the mixin-classes `JKQTPXYGraphErrors`, `JKQTPXGraphErrors` and `JKQTPYGraphErrors` that are all derived from `JKQTPGraphErrors`. With these it is simple to add error indicators to several different plot styles. Usually you can recognize these by looking at the class name, e.g. `JKQTPXYLineGraph` is a simple line+symbol graph, and `JKQTPXYLineErrorGraph` is the same with error indictaors (see above). There are also several other plots with error indicators:
- `JKQTPBarVerticalErrorGraph` for barcharts with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_barcharts.png)
- `JKQTPImpulsesVerticalGraph` for impulse/candle-stick charts with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_impulses.png)
- `JKQTPFilledCurveXErrorGraph` for filled curves with errors:<br>![](../../screenshots/jkqtplotter_simpletest_errorbarstyles_filledcurves.png)
.

22
examples/simpletest_errorbarstyles/jkqtplotter_simpletest_errorbarstyles.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_errorbarstyles.cpp
* Shows how to use different error indicator styles with JKQtPlotter
* Shows how to use different error indicator styles with JKQTPLotter
*
* \ref JKQtPlotterErrorBarStyles
* \ref JKQTPLotterErrorBarStyles
*/
#include <QApplication>
@ -15,8 +15,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data a vector of x-values for a simple plot
// and generate some values for varying errors
@ -41,7 +41,7 @@ int main(int argc, char* argv[])
// the array showXandYError indicates whether we want x- and y-error
// for a style for all stywhere this is false, only y-error-indicators
// are shown
QVector<JKQTPerrorPlotstyle> errorStyles {JKQTPnoError, JKQTPerrorBars, JKQTPerrorSimpleBars, JKQTPerrorLines, JKQTPerrorPolygons, JKQTPerrorBoxes, JKQTPerrorEllipses, JKQTPerrorBarsPolygons, JKQTPerrorBarsLines, JKQTPerrorSimpleBarsLines, JKQTPerrorSimpleBarsPolygons };
QVector<JKQTPErrorPlotstyle> errorStyles {JKQTPNoError, JKQTPErrorBars, JKQTPErrorSimpleBars, JKQTPErrorLines, JKQTPErrorPolygons, JKQTPErrorBoxes, JKQTPErrorEllipses, JKQTPErrorBarsPolygons, JKQTPErrorBarsLines, JKQTPErrorSimpleBarsLines, JKQTPErrorSimpleBarsPolygons };
QVector<bool> showXandYError { false , true , true , false , false , true , true , false , false , false , false };
for (int errorID=0; errorID<errorStyles.size(); errorID++) {
@ -51,7 +51,7 @@ int main(int argc, char* argv[])
Y<<xx*0.5+static_cast<double>(errorID)*2.5;
}
JKQTPxyLineErrorGraph* graph=new JKQTPxyLineErrorGraph(&plot);
JKQTPXYLineErrorGraph* graph=new JKQTPXYLineErrorGraph(&plot);
// copy data into datastore and immediately set the yColumn
graph->set_xColumn(columnX);
@ -62,7 +62,7 @@ int main(int argc, char* argv[])
// set error style, for the y-axis
graph->set_yErrorStyle(errorStyles[errorID]);
// no error indicators for the x-values
graph->set_xErrorStyle(JKQTPnoError);
graph->set_xErrorStyle(JKQTPNoError);
// ... unless: for some error styles we want error in both directions
if (showXandYError[errorID]) {
graph->set_xErrorStyle(errorStyles[errorID]);
@ -79,7 +79,7 @@ int main(int argc, char* argv[])
// set symbol (cross/X) + pen style (and color)dashed)
graph->set_symbol(JKQTPcross);
graph->set_symbol(JKQTPCross);
graph->set_style(Qt::DashLine);
// set symbol size
graph->set_symbolSize(5);
@ -89,9 +89,9 @@ int main(int argc, char* argv[])
graph->set_lineWidth(1);
// graph title is made from symbol+errorStylestyle, we use the LaTeX instruction \verb around the
// result of JKQTPerrorPlotstyle2String(), because it contains underscores that would otherwise
// result of JKQTPErrorPlotstyle2String(), because it contains underscores that would otherwise
// lead to lower-case letter, which we don't want
graph->set_title("\\verb{"+JKQTPerrorPlotstyle2String(errorStyles[errorID])+"}");
graph->set_title("\\verb{"+JKQTPErrorPlotstyle2String(errorStyles[errorID])+"}");
// add the graph to the plot, so it is actually displayed
plot.addGraph(graph);
@ -101,7 +101,7 @@ int main(int argc, char* argv[])
plot.zoomToFit();
// 6. change locaion of key (outside top-right)
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideRightTop);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideRightTop);
// ... and switch off the grid
plot.get_xAxis()->set_drawGrid(false);
plot.get_xAxis()->set_drawMinorGrid(false);

2
examples/simpletest_errorbarstyles/jkqtplotter_simpletest_errorbarstyles.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_errorbarstyles
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

18
examples/simpletest_filledgraphs/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Filled Curve Plots {#JKQtPlotterFilledGraphs}
This project (see `./examples/simpletest_filledgraphs/`) simply creates a JKQtPlotter widget (as a new window) and adds several filled curve graphs (Histograms). Data is initialized from QVector<int> objects.
# Example (JKQTPLotter): Filled Curve Plots {#JKQTPLotterFilledGraphs}
This project (see `./examples/simpletest_filledgraphs/`) simply creates a JKQTPLotter widget (as a new window) and adds several filled curve graphs (Histograms). Data is initialized from QVector<int> objects.
The source code of the main application can be found in [`jkqtplotter_simpletest_filledgraphs.cpp`](../simpletest_filledgraphs/jkqtplotter_simpletest_filledgraphs.cpp).
@ -15,12 +15,12 @@ And three columns with 256 entries each, which will be filled with the R-, G- an
size_t columnB=ds->addColumn(256, "historam_B");
```
In this example we will access the data in the internal datastore directly. This access is possible through objects of type JKQTPcolumn, which is a proxy to the data in one of the columns in a `JKQTdatastore`:
In this example we will access the data in the internal datastore directly. This access is possible through objects of type JKQTPColumn, which is a proxy to the data in one of the columns in a `JKQTdatastore`:
```.cpp
JKQTPcolumn cG=ds->getColumn(columnG);
JKQTPcolumn cR=ds->getColumn(columnR);
JKQTPcolumn cB=ds->getColumn(columnB);
JKQTPColumn cG=ds->getColumn(columnG);
JKQTPColumn cR=ds->getColumn(columnR);
JKQTPColumn cB=ds->getColumn(columnB);
```
In order to calculate the histograms, first all enries in the columns are set to 0:
@ -48,10 +48,10 @@ Finally the histogram is calculated:
cB.scale(100.0/static_cast<double>(image.width()*image.height()));
```
Finally three `JKQTPfilledCurveXGraph` objects are generated and added to the plot (here we show the code for the R-channel only):
Finally three `JKQTPFilledCurveXGraph` objects are generated and added to the plot (here we show the code for the R-channel only):
```.cpp
JKQTPfilledCurveXGraph* graphR=new JKQTPfilledCurveXGraph(&plot);
JKQTPFilledCurveXGraph* graphR=new JKQTPFilledCurveXGraph(&plot);
// set graph titles
graphR->set_title("R-channel");
@ -75,7 +75,7 @@ The result looks like this:
![jkqtplotter_simpletest_filledgraphs](../../screenshots/jkqtplotter_simpletest_filledgraphs.png)
If you use `JKQTPfilledCurveYGraph` instead of `JKQTPfilledCurveXGraph`, the curve will not be filled until the y=0-axis, but until the x=0-axis. Of course you will also have to swap the x- and y-data columns. The result will look like this:
If you use `JKQTPFilledCurveYGraph` instead of `JKQTPFilledCurveXGraph`, the curve will not be filled until the y=0-axis, but until the x=0-axis. Of course you will also have to swap the x- and y-data columns. The result will look like this:
![jkqtplotter_simpletest_filledgraphs_yaxis](../../screenshots/jkqtplotter_simpletest_filledgraphs_yaxis.png)

22
examples/simpletest_filledgraphs/jkqtplotter_simpletest_filledgraphs.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_filledgraphs.cpp
* Shows how to use filled graphs with JKQtPlotter
* Shows how to use filled graphs with JKQTPLotter
*
* \ref JKQtPlotterFilledGraphs
* \ref JKQTPLotterFilledGraphs
*/
#include <QApplication>
@ -13,8 +13,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create 4 datacolumns with length 256 entries in the datastore
// these will later hold the RGB-histogram and a linear x-values vector
@ -25,11 +25,11 @@ int main(int argc, char* argv[])
size_t columnR=ds->addColumn(256, "historam_R");
size_t columnG=ds->addColumn(256, "historam_G");
size_t columnB=ds->addColumn(256, "historam_B");
// - in addition JKQTPcolumn objects are generated, which can be used to access
// - in addition JKQTPColumn objects are generated, which can be used to access
// the data in the columns
JKQTPcolumn cG=ds->getColumn(columnG);
JKQTPcolumn cR=ds->getColumn(columnR);
JKQTPcolumn cB=ds->getColumn(columnB);
JKQTPColumn cG=ds->getColumn(columnG);
JKQTPColumn cR=ds->getColumn(columnR);
JKQTPColumn cB=ds->getColumn(columnB);
// - now all columns for RGB are initialized to 0
cR.setAll(0);
cG.setAll(0);
@ -53,9 +53,9 @@ int main(int argc, char* argv[])
// 4. now we add three semi-transparent, filled curve plots, one for each histogram
JKQTPfilledCurveXGraph* graphR=new JKQTPfilledCurveXGraph(&plot);
JKQTPfilledCurveXGraph* graphG=new JKQTPfilledCurveXGraph(&plot);
JKQTPfilledCurveXGraph* graphB=new JKQTPfilledCurveXGraph(&plot);
JKQTPFilledCurveXGraph* graphR=new JKQTPFilledCurveXGraph(&plot);
JKQTPFilledCurveXGraph* graphG=new JKQTPFilledCurveXGraph(&plot);
JKQTPFilledCurveXGraph* graphB=new JKQTPFilledCurveXGraph(&plot);
// set graph titles
graphR->set_title("R-channel");

2
examples/simpletest_filledgraphs/jkqtplotter_simpletest_filledgraphs.pro
View File

@ -12,7 +12,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_filledgraphs
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

28
examples/simpletest_functionplot/README.md
View File

@ -1,11 +1,11 @@
# Example (JKQtPlotter): Plotting Mathematical Functions as Line Graphs {#JKQtPlotterFunctionPlots}
# Example (JKQTPLotter): Plotting Mathematical Functions as Line Graphs {#JKQTPLotterFunctionPlots}
## Basics
This project (see `./examples/simpletest_functionplot/`) demonstrates how to plot mathematical functions as line graphs. The functions may be defined as static C functions, C++ functors or c++ inline functions. See [test/simpletest_parsedfunctionplot](../simpletest_parsedfunctionplot) for an example of how to use an internal equation parser provided with JKQtPlotter instead of directly defining functions.
This project (see `./examples/simpletest_functionplot/`) demonstrates how to plot mathematical functions as line graphs. The functions may be defined as static C functions, C++ functors or c++ inline functions. See [test/simpletest_parsedfunctionplot](../simpletest_parsedfunctionplot) for an example of how to use an internal equation parser provided with JKQTPLotter instead of directly defining functions.
## Simple C++ inline function
The first example shows how to plot a C++ inline function:
```.cpp
JKQTPxFunctionLineGraph* func1=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func1=new JKQTPXFunctionLineGraph(plot);
func1->set_plotFunction([](double x) { return 0.2*x*x-0.015*x*x*x; });
func1->set_title("C++-inline function $0.2x^2-0.015x^3$");
plot->addGraph(func1);
@ -14,7 +14,7 @@ The first example shows how to plot a C++ inline function:
## Simple C++ inline function with parameters
In any such plot function, you can also use parameters, provided via the second parameter. Usually these are "internal parameters", defined by `func2->set_paramsV(p0, p1, ...)`:
```.cpp
JKQTPxFunctionLineGraph* func2=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func2=new JKQTPXFunctionLineGraph(plot);
func2->set_plotFunction([](double x, void* params) {
QVector<double>* p=static_cast<QVector<double>*>(params);
return p->at(0)*sin(2.0*M_PI*x*p->at(1));
@ -27,7 +27,7 @@ In any such plot function, you can also use parameters, provided via the second
... but generally any pointer can be used as parameter (the set by `set_parameter(static_cast<void*>(myDataObject))`):
```.cpp
JKQTPxFunctionLineGraph* func3=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func3=new JKQTPXFunctionLineGraph(plot);
func3->set_plotFunction([](double x, void* params) {
QMap<QString,double>* p=static_cast<QMap<QString,double>*>(params);
return p->value("amplitude")*sin(2.0*M_PI*x*p->value("frequency"));
@ -56,7 +56,7 @@ You can also use C++ functors (or function objects):
// ...
JKQTPxFunctionLineGraph* func4=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func4=new JKQTPXFunctionLineGraph(plot);
func4->set_plotFunction(SincSqr(-8));
func4->set_title("C++ functor $-8*\\sin^2(x)/x^2$");
plot->addGraph(func4);
@ -71,17 +71,17 @@ You can also plot simple static C functions:
// ...
JKQTPxFunctionLineGraph* func5=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func5=new JKQTPXFunctionLineGraph(plot);
func5->set_plotFunction(&sinc);
func5->set_title("static C function $10*\\sin(x)/x$");
plot->addGraph(func5);
```
## Predefined "special" functions
Finally `JKQTPxFunctionLineGraph` provides a small set of special functions (polynomial `p0+p1*x+p2*x^2+...`, exponential `p0+p1*exp(x/p2)`, power-law `p0+p1*x^p2`, ...), which are parametrized from the internal or external parameters:
Finally `JKQTPXFunctionLineGraph` provides a small set of special functions (polynomial `p0+p1*x+p2*x^2+...`, exponential `p0+p1*exp(x/p2)`, power-law `p0+p1*x^p2`, ...), which are parametrized from the internal or external parameters:
```.cpp
JKQTPxFunctionLineGraph* func6=new JKQTPxFunctionLineGraph(plot);
func6->setSpecialFunction(JKQTPxFunctionLineGraph::Line);
JKQTPXFunctionLineGraph* func6=new JKQTPXFunctionLineGraph(plot);
func6->setSpecialFunction(JKQTPXFunctionLineGraph::Line);
// here we set offset p0=-1 and slope p1=1.5 of the line p0+p1*x
func6->set_paramsV(-1,1.5);
func6->set_title("special function: linear");
@ -90,8 +90,8 @@ Finally `JKQTPxFunctionLineGraph` provides a small set of special functions (pol
To demonstrate how to use parameters from a datastore column, have a look at the next example. It is derived from the special-function plot above, but adds a line with a different offset and slope and reads the parameters from a datastore column `paramCol`, which is initialized from the vector `params`:
```.cpp
JKQTPxFunctionLineGraph* func7=new JKQTPxFunctionLineGraph(plot);
func7->setSpecialFunction(JKQTPxFunctionLineGraph::Line);
JKQTPXFunctionLineGraph* func7=new JKQTPXFunctionLineGraph(plot);
func7->setSpecialFunction(JKQTPXFunctionLineGraph::Line);
// here we set offset p0=1 and slope p1=-1.5 of the line p0+p1*x by adding these into a column
// in the internal datastore and then set that column as parameterColumn for the function graph
QVector<double> params;
@ -110,9 +110,9 @@ This code snippets above result in a plot like this:
## Notes
Note that all the different variants to provide parameters can be used with all types of functions!
Also see the example [Plotting Parsed Mathematical Functions as Line Graphs](../simpletest_parsedfunctionplot) for details on how the actual plotting algorithm works. That example also shows how to define a function as a string, which is then parsed and evaluated by an expression parser library embedded in JKQtPlotter.
Also see the example [Plotting Parsed Mathematical Functions as Line Graphs](../simpletest_parsedfunctionplot) for details on how the actual plotting algorithm works. That example also shows how to define a function as a string, which is then parsed and evaluated by an expression parser library embedded in JKQTPLotter.
All examples above use the graph class `JKQTPxFunctionLineGraph`, which plots a function `y=f(x)`. If you want to plot a function `x=f(y)`, you can use the class `JKQTPyFunctionLineGraph` instead. If in the examples above, we exchange all `JKQTPxFunctionLineGraph` for `JKQTPyFunctionLineGraph`, the graphs will be rotated by 90 degree, as all functions are interpreted as `x=f(y)`:
All examples above use the graph class `JKQTPXFunctionLineGraph`, which plots a function `y=f(x)`. If you want to plot a function `x=f(y)`, you can use the class `JKQTPYFunctionLineGraph` instead. If in the examples above, we exchange all `JKQTPXFunctionLineGraph` for `JKQTPYFunctionLineGraph`, the graphs will be rotated by 90 degree, as all functions are interpreted as `x=f(y)`:
![jkqtplotter_simpletest_functionplot_fy](../../screenshots/jkqtplotter_simpletest_functionplot_fy.png)

40
examples/simpletest_functionplot/jkqtplotter_simpletest_functionplot.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_functionplot.cpp
* Shows how to plot Mathematical Functions as Line Graphs with JKQtPlotter (as evaluated C/C++ functions)
* Shows how to plot Mathematical Functions as Line Graphs with JKQTPLotter (as evaluated C/C++ functions)
*
* \ref JKQtPlotterFunctionPlots
* \ref JKQTPLotterFunctionPlots
*/
#include <QApplication>
@ -29,24 +29,24 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a window that conatins a line-edit to edit a function
// and a JKQtPlotter to display the function, combine everything in a layout
// and a JKQTPLotter to display the function, combine everything in a layout
QWidget mainWin;
JKQtPlotter* plot=new JKQtPlotter(&mainWin);
JKQTPLotter* plot=new JKQTPLotter(&mainWin);
QVBoxLayout* layout=new QVBoxLayout;
mainWin.setLayout(layout);
layout->addWidget(plot);
// 2. now we add a JKQTPxFunctionLineGraph object, which will draw a simple function
// 2. now we add a JKQTPXFunctionLineGraph object, which will draw a simple function
// the function is defined as C++ inline function
JKQTPxFunctionLineGraph* func1=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func1=new JKQTPXFunctionLineGraph(plot);
func1->set_plotFunction([](double x) { return 0.2*x*x-0.015*x*x*x; });
func1->set_title("C++-inline function $0.2x^2-0.015x^3$");
plot->addGraph(func1);
// 3. now we add a JKQTPxFunctionLineGraph object, which will draw a simple function
// 3. now we add a JKQTPXFunctionLineGraph object, which will draw a simple function
// the function is again defined as C++ inline function, but now uses internal
// parameters (handed over to the function as a pointer to QVector<double>
JKQTPxFunctionLineGraph* func2=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func2=new JKQTPXFunctionLineGraph(plot);
func2->set_plotFunction([](double x, void* params) {
QVector<double>* p=static_cast<QVector<double>*>(params);
return p->at(0)*sin(2.0*M_PI*x*p->at(1));
@ -56,10 +56,10 @@ int main(int argc, char* argv[])
func2->set_title("C++-inline function with int. params $p_0\\cdot\\sin(x*2.0*\\pi\\cdot p_1)$");
plot->addGraph(func2);
// 4. now we add a JKQTPxFunctionLineGraph object, which will draw a simple function
// 4. now we add a JKQTPXFunctionLineGraph object, which will draw a simple function
// the function is again defined as C++ inline function, but now uses external
// parameters, which may have any type (here QMap<QString,double)
JKQTPxFunctionLineGraph* func3=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func3=new JKQTPXFunctionLineGraph(plot);
func3->set_plotFunction([](double x, void* params) {
QMap<QString,double>* p=static_cast<QMap<QString,double>*>(params);
return p->value("amplitude")*sin(2.0*M_PI*x*p->value("frequency"));
@ -73,29 +73,29 @@ int main(int argc, char* argv[])
plot->addGraph(func3);
// 5. of course the function may also be any C+ funtor object:
JKQTPxFunctionLineGraph* func4=new JKQTPxFunctionLineGraph(plot);
JKQTPXFunctionLineGraph* func4=new JKQTPXFunctionLineGraph(plot);
func4->set_plotFunction(SincSqr(-8));
func4->set_title("C++ functor $-8*\\sin^2(x)/x^2$");
plot->addGraph(func4);
// 6. now we use a JKQTPxFunctionLineGraph to draw a static C function
JKQTPxFunctionLineGraph* func5=new JKQTPxFunctionLineGraph(plot);
// 6. now we use a JKQTPXFunctionLineGraph to draw a static C function
JKQTPXFunctionLineGraph* func5=new JKQTPXFunctionLineGraph(plot);
func5->set_plotFunction(&sinc);
func5->set_title("static C function $10*\\sin(x)/x$");
plot->addGraph(func5);
// 7. finally JKQTPxFunctionLineGraph defines a small set of common functions
JKQTPxFunctionLineGraph* func6=new JKQTPxFunctionLineGraph(plot);
func6->setSpecialFunction(JKQTPxFunctionLineGraph::Line);
// 7. finally JKQTPXFunctionLineGraph defines a small set of common functions
JKQTPXFunctionLineGraph* func6=new JKQTPXFunctionLineGraph(plot);
func6->setSpecialFunction(JKQTPXFunctionLineGraph::Line);
// here we set offset p0=-1 and slope p1=1.5 of the line p0+p1*x
func6->set_paramsV(-1,1.5);
func6->set_title("special function: linear p_0=-1, p_1=1.5");
plot->addGraph(func6);
// 7. finally JKQTPxFunctionLineGraph defines a small set of common functions
JKQTPxFunctionLineGraph* func7=new JKQTPxFunctionLineGraph(plot);
func7->setSpecialFunction(JKQTPxFunctionLineGraph::Line);
// 7. finally JKQTPXFunctionLineGraph defines a small set of common functions
JKQTPXFunctionLineGraph* func7=new JKQTPXFunctionLineGraph(plot);
func7->setSpecialFunction(JKQTPXFunctionLineGraph::Line);
// here we set offset p0=1 and slope p1=-1.5 of the line p0+p1*x by adding these into a column
// in the internal datastore and then set that column as parameterColumn for the function graph
QVector<double> params;
@ -109,7 +109,7 @@ int main(int argc, char* argv[])
// 8. set some axis properties (we use LaTeX for nice equation rendering)
plot->get_xAxis()->set_axisLabel(QObject::tr("x-axis"));
plot->get_yAxis()->set_axisLabel(QObject::tr("y-axis"));
plot->get_plotter()->set_keyPosition(JKQTPkeyOutsideBottomLeft);
plot->get_plotter()->set_keyPosition(JKQTPKeyOutsideBottomLeft);
// 4. scale the plot so the graph is contained

2
examples/simpletest_functionplot/jkqtplotter_simpletest_functionplot.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_functionplot
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

30
examples/simpletest_geometric/README.md
View File

@ -1,23 +1,23 @@
# Example (JKQtPlotter): Plotting Geometric Objects {#JKQtPlotterGeometricGraphs}
This project (see `./test/simpletest_geometric/`) shows the capabilities of JKQtPlotter to also draw geometric elements, like circles, ellipses, rectangles etc.
# Example (JKQTPLotter): Plotting Geometric Objects {#JKQTPLotterGeometricGraphs}
This project (see `./test/simpletest_geometric/`) shows the capabilities of JKQTPLotter to also draw geometric elements, like circles, ellipses, rectangles etc.
The source code of the main application can be found in [`jkqtplotter_simpletest_geometric.cpp`](../simpletest_geometric/jkqtplotter_simpletest_geometric.cpp). First a plot is generated and the axis aspect ration is set to 1, so an accurate plot is generated. Then several geometric graphs are added to the plot. Here are some examples, you can find more more examples in the source code of the example:
```.cpp
// a text element
plot.addGraph(new JKQTPgeoText(&plot, 0.1,0.6, "$x_{1/2}=\\frac{\\sqrt{b^2-4ac}}{2a}$", 10, QColor("red")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,0.6, "$x_{1/2}=\\frac{\\sqrt{b^2-4ac}}{2a}$", 10, QColor("red")));
// a single symbol
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.1,0.6, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.1,0.6, JKQTPCircle, 5, QColor("grey")));
// a line
plot.addGraph(new JKQTPgeoLine(&plot, 1, 0.05, 1.9, 0.9, QColor("red"), 2));
plot.addGraph(new JKQTPGeoLine(&plot, 1, 0.05, 1.9, 0.9, QColor("red"), 2));
// a one-sided infinite line with slope dy/dx=0.25/0.2
JKQTPgeoInfiniteLine* infLine=new JKQTPgeoInfiniteLine(&plot, 1.7, 0.2, 0.2, 0.25, QColor("green"), 1.5, Qt::PenStyle::DashLine);
JKQTPGeoInfiniteLine* infLine=new JKQTPGeoInfiniteLine(&plot, 1.7, 0.2, 0.2, 0.25, QColor("green"), 1.5, Qt::PenStyle::DashLine);
infLine->set_two_sided(false);
infLine->setAlpha(0.5);
plot.addGraph(infLine);
@ -26,23 +26,23 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
// a polyline
QVector<QPointF> p;
p<<QPointF(1, 0.1)<<QPointF(1.3, 0.9)<<QPointF(1.6, 0.3)<<QPointF(1.9, 0.8);
plot.addGraph(new JKQTPgeoPolyLines(&plot, p, QColor("darkgreen"), 4, Qt::PenStyle::DashDotLine));
plot.addGraph(new JKQTPGeoPolyLines(&plot, p, QColor("darkgreen"), 4, Qt::PenStyle::DashDotLine));
// rectangle:
plot.addGraph(new JKQTPgeoRectangle(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
plot.addGraph(new JKQTPGeoRectangle(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
// a rotated rectangle (rotated by 35 degrees):
plot.addGraph(new JKQTPgeoRectangle(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
// ellipse:
plot.addGraph(new JKQTPgeoEllipse(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
plot.addGraph(new JKQTPGeoEllipse(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
// a rotated ellipse (rotated by 35 degrees):
plot.addGraph(new JKQTPgeoEllipse(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
plot.addGraph(new JKQTPGeoEllipse(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
// a polygon
JKQTPgeoPolygon* polygraph=new JKQTPgeoPolygon(&plot, QColor("red"), 2, Qt::PenStyle::DashLine, QColor("salmon"));
JKQTPGeoPolygon* polygraph=new JKQTPGeoPolygon(&plot, QColor("red"), 2, Qt::PenStyle::DashLine, QColor("salmon"));
polygraph->appendPoint(2.1, 0.5);
polygraph->appendPoint(2.9, 0.9);
polygraph->appendPoint(2.2, 0.8);
@ -53,15 +53,15 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
// an arc from an ellipse from -10 degrees to 117 degrees, centered at 2.5,1.5 and full axes of 0.5 and 0.5
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.5,0.5, -10, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.5,0.5, -10, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine));
// a pie centered at 2.5,2.5 with ellipse axes 0.9 and 0.9 and from angle 0 degrees to 90 degrees
plot.addGraph(new JKQTPgeoPie(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(new JKQTPGeoPie(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
// a chord centered at 2.5,2.5 with ellipse axes 0.9 and 0.9 and from angle 0 degrees to 90 degrees
plot.addGraph(new JKQTPgeoChord(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(new JKQTPGeoChord(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
```

128
examples/simpletest_geometric/jkqtplotter_simpletest_geometric.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_geometric.cpp
* Shows how to plot several geometric forms with JKQtPlotter
* Shows how to plot several geometric forms with JKQTPLotter
*
* \ref JKQtPlotterGeometricGraphs
* \ref JKQTPLotterGeometricGraphs
*/
#include <QApplication>
@ -14,7 +14,7 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window
JKQtPlotter plot;
JKQTPLotter plot;
// 2. format graph:
// 2.1 set the graph scales manually
@ -31,75 +31,75 @@ int main(int argc, char* argv[])
// 3. add some geometric plots
// 3.1 some text elements, also with formatting by LaTeX expressions
plot.addGraph(new JKQTPgeoText(&plot, 0.1,0.95, "\\textbf{Text:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoText(&plot, 0.1,0.1, "A text object in 10pt", 10, QColor("red")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.1,0.1, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoText(&plot, 0.1,0.3, "A text object in 12pt", 12, QColor("red")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.1,0.3, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoText(&plot, 0.1,0.6, "$x_{1/2}=\\frac{\\sqrt{b^2-4ac}}{2a}$", 10, QColor("red")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.1,0.6, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,0.95, "\\textbf{Text:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,0.1, "A text object in 10pt", 10, QColor("red")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.1,0.1, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,0.3, "A text object in 12pt", 12, QColor("red")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.1,0.3, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,0.6, "$x_{1/2}=\\frac{\\sqrt{b^2-4ac}}{2a}$", 10, QColor("red")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.1,0.6, JKQTPCircle, 5, QColor("grey")));
// 3.2 some lines elements (single lines and polylines)
plot.addGraph(new JKQTPgeoText(&plot, 1.1,0.95, "\\textbf{Lines:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoLine(&plot, 1, 0.05, 1.9, 0.9, QColor("red"), 2));
plot.addGraph(new JKQTPgeoLine(&plot, 1, 0.1, 1.9, 0.8, QColor("blue"), 1, Qt::PenStyle::DashLine));
plot.addGraph(new JKQTPGeoText(&plot, 1.1,0.95, "\\textbf{Lines:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoLine(&plot, 1, 0.05, 1.9, 0.9, QColor("red"), 2));
plot.addGraph(new JKQTPGeoLine(&plot, 1, 0.1, 1.9, 0.8, QColor("blue"), 1, Qt::PenStyle::DashLine));
QVector<QPointF> p;
p<<QPointF(1, 0.1)<<QPointF(1.3, 0.9)<<QPointF(1.6, 0.3)<<QPointF(1.9, 0.8);
plot.addGraph(new JKQTPgeoPolyLines(&plot, p, QColor("darkgreen"), 4, Qt::PenStyle::DashDotLine));
JKQTPgeoInfiniteLine* infLine=new JKQTPgeoInfiniteLine(&plot, 1.7, 0.2, 0.2, 0.25, QColor("green"), 1.5, Qt::PenStyle::DashLine);
plot.addGraph(new JKQTPGeoPolyLines(&plot, p, QColor("darkgreen"), 4, Qt::PenStyle::DashDotLine));
JKQTPGeoInfiniteLine* infLine=new JKQTPGeoInfiniteLine(&plot, 1.7, 0.2, 0.2, 0.25, QColor("green"), 1.5, Qt::PenStyle::DashLine);
infLine->set_two_sided(false);
infLine->setAlpha(0.5);
plot.addGraph(infLine);
infLine=new JKQTPgeoInfiniteLine(&plot, 1.7, 0.2, 0.2, -0.15, QColor("blue"), 1.5, Qt::PenStyle::SolidLine);
infLine=new JKQTPGeoInfiniteLine(&plot, 1.7, 0.2, 0.2, -0.15, QColor("blue"), 1.5, Qt::PenStyle::SolidLine);
infLine->set_two_sided(true);
infLine->setAlpha(0.5);
plot.addGraph(infLine);
// 3.3 some rectangles (you give the center and width/height of the rectangle in the contructor)
plot.addGraph(new JKQTPgeoText(&plot, 0.1,1.95, "\\textbf{Rectangles:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoRectangle(&plot, 0.5,1.5,0.8,0.8, QColor("blue"), 1, Qt::SolidLine, QColor("lightblue")));
plot.addGraph(new JKQTPGeoText(&plot, 0.1,1.95, "\\textbf{Rectangles:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoRectangle(&plot, 0.5,1.5,0.8,0.8, QColor("blue"), 1, Qt::SolidLine, QColor("lightblue")));
QColor rfill("lightblue"); rfill.setAlphaF(0.5);
plot.addGraph(new JKQTPgeoRectangle(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
plot.addGraph(new JKQTPgeoRectangle(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
plot.addGraph(new JKQTPgeoRectangle(&plot, 0.5,1.5,0.6,0.6, -7, QColor("orange"), 2, Qt::DotLine, QColor("salmon"), Qt::FDiagPattern));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.5,1.5, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.4,1.3, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 0.9,1.6, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoRectangle(&plot, QPointF(0.4,1.3), QPointF(0.9,1.6), QColor("blue"), 1, Qt::SolidLine, rfill));
plot.addGraph(new JKQTPGeoRectangle(&plot, 0.5,1.5,0.8,0.5, 35, QColor("darkblue"), 2, Qt::DashLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, 0.5,1.5,0.6,0.6, -7, QColor("orange"), 2, Qt::DotLine, QColor("salmon"), Qt::FDiagPattern));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.5,1.5, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.4,1.3, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 0.9,1.6, JKQTPCircle, 5, QColor("grey")));
// 3.4 some circles and elllipses
plot.addGraph(new JKQTPgeoText(&plot, 1.1,1.95, "\\textbf{Circles/Ellipses:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoText(&plot, 1.1,1.95, "\\textbf{Circles/Ellipses:}", 14, QColor("red")));
QColor col=QColor("blue"); col.setAlphaF(0.2);
plot.addGraph(new JKQTPgeoRectangle(&plot, 1.5,1.5,0.8,0.8, col, 0.5, Qt::SolidLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, 1.5,1.5,0.8,0.8, col, 0.5, Qt::SolidLine));
col.setAlphaF(1);
plot.addGraph(new JKQTPgeoEllipse(&plot, 1.5,1.5,0.8,0.8, col, 1, Qt::SolidLine, QColor("lightblue")));
plot.addGraph(new JKQTPGeoEllipse(&plot, 1.5,1.5,0.8,0.8, col, 1, Qt::SolidLine, QColor("lightblue")));
col=QColor("blue"); col.setAlphaF(0.2);
plot.addGraph(new JKQTPgeoRectangle(&plot, QPointF(1.4,1.3), QPointF(1.9,1.6),col, 0.5, Qt::SolidLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, QPointF(1.4,1.3), QPointF(1.9,1.6),col, 0.5, Qt::SolidLine));
col.setAlphaF(1);
plot.addGraph(new JKQTPgeoEllipse(&plot, QPointF(1.4,1.3), QPointF(1.9,1.6), col, 1, Qt::SolidLine, rfill));
plot.addGraph(new JKQTPGeoEllipse(&plot, QPointF(1.4,1.3), QPointF(1.9,1.6), col, 1, Qt::SolidLine, rfill));
col=QColor("darkblue"); col.setAlphaF(0.2);
plot.addGraph(new JKQTPgeoRectangle(&plot, 1.5,1.5,0.8,0.5, 35, col, 0.5, Qt::DashLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, 1.5,1.5,0.8,0.5, 35, col, 0.5, Qt::DashLine));
col.setAlphaF(1);
plot.addGraph(new JKQTPgeoEllipse(&plot, 1.5,1.5,0.8,0.5, 35, col, 2, Qt::DashLine));
plot.addGraph(new JKQTPGeoEllipse(&plot, 1.5,1.5,0.8,0.5, 35, col, 2, Qt::DashLine));
col=QColor("orange"); col.setAlphaF(0.2);
plot.addGraph(new JKQTPgeoRectangle(&plot, 1.5,1.5,0.6,0.6, -7, col, 0.5, Qt::DotLine));
plot.addGraph(new JKQTPGeoRectangle(&plot, 1.5,1.5,0.6,0.6, -7, col, 0.5, Qt::DotLine));
col.setAlphaF(1);
plot.addGraph(new JKQTPgeoEllipse(&plot, 1.5,1.5,0.6,0.6, -7, col, 2, Qt::DotLine, QColor("salmon"), Qt::FDiagPattern));
plot.addGraph(new JKQTPgeoSymbol(&plot, 1.5,1.5, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 1.4,1.3, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPgeoSymbol(&plot, 1.9,1.6, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoEllipse(&plot, 1.5,1.5,0.6,0.6, -7, col, 2, Qt::DotLine, QColor("salmon"), Qt::FDiagPattern));
plot.addGraph(new JKQTPGeoSymbol(&plot, 1.5,1.5, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 1.4,1.3, JKQTPCircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 1.9,1.6, JKQTPCircle, 5, QColor("grey")));
// 3.5 some polygon elements
plot.addGraph(new JKQTPgeoText(&plot, 2.1,0.95, "\\textbf{PolyLines/Polygons:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoText(&plot, 2.1,0.95, "\\textbf{PolyLines/Polygons:}", 14, QColor("red")));
QVector<QPointF> polygon;
polygon<<QPointF(2, 0.1)<<QPointF(2.3, 0.9)<<QPointF(2.6, 0.3)<<QPointF(2, 0.8);
JKQTPgeoPolygon* polygraph=new JKQTPgeoPolygon(&plot, polygon, QColor("blue"), 2, Qt::PenStyle::DashLine, QColor("lightblue"));
JKQTPGeoPolygon* polygraph=new JKQTPGeoPolygon(&plot, polygon, QColor("blue"), 2, Qt::PenStyle::DashLine, QColor("lightblue"));
polygraph->setAlpha(0.75);
plot.addGraph(polygraph);
polygraph=new JKQTPgeoPolygon(&plot, QColor("red"), 2, Qt::PenStyle::DashLine, QColor("salmon"));
polygraph=new JKQTPGeoPolygon(&plot, QColor("red"), 2, Qt::PenStyle::DashLine, QColor("salmon"));
polygraph->appendPoint(2.1, 0.5);
polygraph->appendPoint(2.9, 0.9);
polygraph->appendPoint(2.2, 0.8);
@ -110,43 +110,43 @@ int main(int argc, char* argv[])
// 3.6 some arcs
plot.addGraph(new JKQTPgeoText(&plot, 2.1,1.95, "\\textbf{Arcs:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoRectangle(&plot, 2.5,1.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.8,0.8, 90,180 , QColor("red"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.6,0.6, 270,360 , QColor("maroon"), 4, Qt::PenStyle::DashDotLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.5,0.5, -10, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine));
plot.addGraph(new JKQTPgeoArc(&plot,2.5,1.5,0.4,0.4, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPgeoSymbol(&plot, 2.5,1.5, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoText(&plot, 2.1,1.95, "\\textbf{Arcs:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoRectangle(&plot, 2.5,1.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.8,0.8, 90,180 , QColor("red"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.6,0.6, 270,360 , QColor("maroon"), 4, Qt::PenStyle::DashDotLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.5,0.5, -10, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine));
plot.addGraph(new JKQTPGeoArc(&plot,2.5,1.5,0.4,0.4, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine));
plot.addGraph(new JKQTPGeoSymbol(&plot, 2.5,1.5, JKQTPCircle, 5, QColor("grey")));
// 3.7 some pies
plot.addGraph(new JKQTPgeoText(&plot, 2.1,2.95, "\\textbf{Pies:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoRectangle(&plot, 2.5,2.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
JKQTPgeoPie* pie;
plot.addGraph(pie=new JKQTPgeoPie(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(pie=new JKQTPgeoPie(&plot,2.5,2.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine,QColor("blue")));
plot.addGraph(new JKQTPGeoText(&plot, 2.1,2.95, "\\textbf{Pies:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoRectangle(&plot, 2.5,2.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
JKQTPGeoPie* pie;
plot.addGraph(pie=new JKQTPGeoPie(&plot,2.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(pie=new JKQTPGeoPie(&plot,2.5,2.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine,QColor("blue")));
pie->setAlpha(0.5);
plot.addGraph(pie=new JKQTPgeoPie(&plot,2.5,2.5,0.5,0.3, -25, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine,QColor("red")));
plot.addGraph(pie=new JKQTPGeoPie(&plot,2.5,2.5,0.5,0.3, -25, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine,QColor("red")));
pie->setAlpha(0.5);
plot.addGraph(pie=new JKQTPgeoPie(&plot,2.5,2.5,0.25,0.8, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine,QColor("green")));
plot.addGraph(pie=new JKQTPGeoPie(&plot,2.5,2.5,0.25,0.8, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine,QColor("green")));
pie->setAlpha(0.5);
plot.addGraph(new JKQTPgeoSymbol(&plot, 2.5,2.5, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 2.5,2.5, JKQTPCircle, 5, QColor("grey")));
// 3.8 some chords
plot.addGraph(new JKQTPgeoText(&plot, 1.1,2.95, "\\textbf{Chords:}", 14, QColor("red")));
plot.addGraph(new JKQTPgeoRectangle(&plot, 1.5,2.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
JKQTPgeoChord* chord;
plot.addGraph(chord=new JKQTPgeoChord(&plot,1.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(chord=new JKQTPgeoChord(&plot,1.5,2.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine,QColor("blue")));
plot.addGraph(new JKQTPGeoText(&plot, 1.1,2.95, "\\textbf{Chords:}", 14, QColor("red")));
plot.addGraph(new JKQTPGeoRectangle(&plot, 1.5,2.5,0.9,0.9, QColor("lightgrey"), 0.5, Qt::SolidLine));
JKQTPGeoChord* chord;
plot.addGraph(chord=new JKQTPGeoChord(&plot,1.5,2.5,0.9,0.9, 0, 90 , QColor("blue"), 4, Qt::PenStyle::SolidLine,QColor("lightblue")));
plot.addGraph(chord=new JKQTPGeoChord(&plot,1.5,2.5,0.7,0.7, 180,270 , QColor("darkblue"), 4, Qt::PenStyle::SolidLine,QColor("blue")));
chord->setAlpha(0.5);
plot.addGraph(chord=new JKQTPgeoChord(&plot,1.5,2.5,0.5,0.3, -25, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine,QColor("red")));
plot.addGraph(chord=new JKQTPGeoChord(&plot,1.5,2.5,0.5,0.3, -25, 117 , QColor("orange"), 4, Qt::PenStyle::DashLine,QColor("red")));
chord->setAlpha(0.5);
plot.addGraph(chord=new JKQTPgeoChord(&plot,1.5,2.5,0.25,0.8, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine,QColor("green")));
plot.addGraph(chord=new JKQTPGeoChord(&plot,1.5,2.5,0.25,0.8, 85, 347 , QColor("darkgreen"), 4, Qt::PenStyle::SolidLine,QColor("green")));
chord->setAlpha(0.5);
plot.addGraph(new JKQTPgeoSymbol(&plot, 1.5,2.5, JKQTPcircle, 5, QColor("grey")));
plot.addGraph(new JKQTPGeoSymbol(&plot, 1.5,2.5, JKQTPCircle, 5, QColor("grey")));
// 4. show plotter and make it a decent size

2
examples/simpletest_geometric/jkqtplotter_simpletest_geometric.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_geometric
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

10
examples/simpletest_imageplot/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple math image plot {#JKQtPlotterImagePlot}
This project (see `./examples/simpletest_imageplot/`) simply creates a JKQtPlotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is stored as a simple C-array in row-major ordering and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore). This very simple interface can also be used to interface with many common image processing libraries, like CImg or OpenCV.
# Example (JKQTPLotter): Simple math image plot {#JKQTPLotterImagePlot}
This project (see `./examples/simpletest_imageplot/`) simply creates a JKQTPLotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is stored as a simple C-array in row-major ordering and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore). This very simple interface can also be used to interface with many common image processing libraries, like CImg or OpenCV.
The soruce code of the main application is (see [`jkqtplotter_simpletest_imageplot.cpp`](../simpletest_imageplot/jkqtplotter_simpletest_imageplot.cpp):
```.cpp
@ -17,12 +17,12 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
const int NX=100; // image dimension in x-direction [pixels]
@ -52,7 +52,7 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of C-array airydisk is copied into a column
// of the datastore in row-major order
size_t cAiryDisk=ds->addCopiedImageAsColumn(airydisk, NX, NY, "imagedata");

10
examples/simpletest_imageplot/jkqtplotter_simpletest_imageplot.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_imageplot.cpp
* Shows how to plot colored math images/matrices with JKQtPlotter
* Shows how to plot colored math images/matrices with JKQTPLotter
*
* \ref JKQtPlotterImagePlot
* \ref JKQTPLotterImagePlot
*/
#include <QApplication>
@ -18,12 +18,12 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
const int NX=100; // image dimension in x-direction [pixels]
@ -53,7 +53,7 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of C-array airydisk is copied into a column
// of the datastore in row-major order
size_t cAiryDisk=ds->addCopiedImageAsColumn(airydisk, NX, NY, "imagedata");

2
examples/simpletest_imageplot/jkqtplotter_simpletest_imageplot.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_imageplot
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

10
examples/simpletest_imageplot_modifier/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple math image plot {#JKQtPlotterImagePlotModifier}
This project (see `./examples/simpletest_imageplot_modifier/`) creates a JKQtPlotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here `sin(r)`). Then a second image (linearly scaling from 1 in the center to 0 at the borders) is used to modify the first image. The modification can alter several properties of the original image, like its saturation, its transparency (alpha) ...
# Example (JKQTPLotter): Simple math image plot {#JKQTPLotterImagePlotModifier}
This project (see `./examples/simpletest_imageplot_modifier/`) creates a JKQTPLotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here `sin(r)`). Then a second image (linearly scaling from 1 in the center to 0 at the borders) is used to modify the first image. The modification can alter several properties of the original image, like its saturation, its transparency (alpha) ...
The soruce code of the main application is (see [`jkqtplotter_simpletest_imageplot_modifier.cpp`](../simpletest_imageplot_modifier/jkqtplotter_simpletest_imageplot_modifier.cpp):
```.cpp
@ -17,12 +17,12 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
const int NX=150; // image dimension in x-direction [pixels]
@ -45,7 +45,7 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of C-array airydisk is copied into a column
// of the datastore in row-major order
size_t cImage=ds->addCopiedImageAsColumn(image, NX, NY, "imagedata");

10
examples/simpletest_imageplot_modifier/jkqtplotter_simpletest_imageplot_modifier.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_imageplot_modifier.cpp
* Shows how to plot colored math images/matrices modified by a second data-column/image with JKQtPlotter
* Shows how to plot colored math images/matrices modified by a second data-column/image with JKQTPLotter
*
* \ref JKQtPlotterImagePlotModifier
* \ref JKQTPLotterImagePlotModifier
*/
#include <QApplication>
@ -18,12 +18,12 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
const int NX=150; // image dimension in x-direction [pixels]
@ -46,7 +46,7 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of C-array airydisk is copied into a column
// of the datastore in row-major order
size_t cImage=ds->addCopiedImageAsColumn(image, NX, NY, "imagedata");

2
examples/simpletest_imageplot_modifier/jkqtplotter_simpletest_imageplot_modifier.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_imageplot_modifier
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

6
examples/simpletest_imageplot_nodatastore/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple math image plot without use of central JKQTdatastore {#JKQtPlotterImagePlotNoDatastore}
This project (see `./examples/simpletest_imageplot_nodatastore/`) simply creates a JKQtPlotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is stored as a simple C-array in row-major ordering and then given to a JKQTPMathImage to visualize it. The data is stored as a pointer directly in the JKQTPMathImage object. There is also a variant JKQTPColumnMathImage of JKQTPMathImage, which references a column in the internal JKQTdatastore and uses the data there for plotting. In both cases data has to be organized as a row-major matrix of values. JKQTPMathImage supports different dataytpes ([u]nit8/16/32/64,float,double see `JKQTPMathImageBase::DataType`) that can be configured e.g. by `set_data()`.
# Example (JKQTPLotter): Simple math image plot without use of central JKQTdatastore {#JKQTPLotterImagePlotNoDatastore}
This project (see `./examples/simpletest_imageplot_nodatastore/`) simply creates a JKQTPLotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is stored as a simple C-array in row-major ordering and then given to a JKQTPMathImage to visualize it. The data is stored as a pointer directly in the JKQTPMathImage object. There is also a variant JKQTPColumnMathImage of JKQTPMathImage, which references a column in the internal JKQTdatastore and uses the data there for plotting. In both cases data has to be organized as a row-major matrix of values. JKQTPMathImage supports different dataytpes ([u]nit8/16/32/64,float,double see `JKQTPMathImageBase::DataType`) that can be configured e.g. by `set_data()`.
The soruce code of the main application is (see [`jkqtplotter_simpletest_imageplot_nodatastore.cpp`](../simpletest_imageplot_nodatastore/jkqtplotter_simpletest_imageplot_nodatastore.cpp):
```.cpp
@ -17,7 +17,7 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting

4
examples/simpletest_imageplot_nodatastore/jkqtplotter_simpletest_imageplot_nodatastore.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_imageplot_nodatastore.cpp
* Simple math image plot without use of central JKQTdatastore
*
* \ref JKQtPlotterImagePlotNoDatastore
* \ref JKQTPLotterImagePlotNoDatastore
*/
#include <QApplication>
@ -18,7 +18,7 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting

2
examples/simpletest_imageplot_nodatastore/jkqtplotter_simpletest_imageplot_nodatastore.pro
View File

@ -11,7 +11,7 @@ CONFIG += qt
QT += core gui xml svg
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

16
examples/simpletest_imageplot_opencv/README.md
View File

@ -1,8 +1,8 @@
# Example (JKQtPlotter): Simple math image plot, showin a 1-channel OpenCV cv::Mat {#JKQtPlotterImagePlotOpenCV}
This project (see `./examples/simpletest_imageplot_opencv/`) simply creates a JKQtPlotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is generated as an OpenCV cv::Mat image and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore).
To copy the data a special OpenCV Interface function `JKQTPcopyCvMatToColumn()` is used, that copies the data from a cv::Mat directly into a column.
# Example (JKQTPLotter): Simple math image plot, showin a 1-channel OpenCV cv::Mat {#JKQTPLotterImagePlotOpenCV}
This project (see `./examples/simpletest_imageplot_opencv/`) simply creates a JKQTPLotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is generated as an OpenCV cv::Mat image and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore).
To copy the data a special OpenCV Interface function `JKQTPCopyCvMatToColumn()` is used, that copies the data from a cv::Mat directly into a column.
The function `JKQTPcopyCvMatToColumn()` is available from the (non-default) header-only extension from `jkqtplotter/jkqtpopencvinterface.h`. This header provides facilities to interface JKQtPlotter with OPenCV.
The function `JKQTPCopyCvMatToColumn()` is available from the (non-default) header-only extension from `jkqtplotter/jkqtpopencvinterface.h`. This header provides facilities to interface JKQTPLotter with OPenCV.
The source code of the main application is (see [`jkqtplotter_simpletest_imageplot_opencv.cpp`](../simpletest_imageplot_opencv/jkqtplotter_simpletest_imageplot_opencv.cpp):
```.cpp
@ -22,14 +22,14 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
@ -57,10 +57,10 @@ int main(int argc, char* argv[])
}
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of one channel of the openCV cv::Mat is copied into a column
// of the datastore in row-major order
size_t cAiryDisk=JKQTPcopyCvMatToColumn(ds, airydisk, "imagedata");
size_t cAiryDisk=JKQTPCopyCvMatToColumn(ds, airydisk, "imagedata");
// 4. create a graph (JKQTPColumnMathImage) with the column created above as data

10
examples/simpletest_imageplot_opencv/jkqtplotter_simpletest_imageplot_opencv.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_imageplot_opencv.cpp
* Simple math image plot, showin a 1-channel OpenCV cv::Mat
*
* \ref JKQtPlotterImagePlotOpenCV
* \ref JKQTPLotterImagePlotOpenCV
*/
#include <QApplication>
@ -21,14 +21,14 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
@ -56,10 +56,10 @@ int main(int argc, char* argv[])
}
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of one channel of the openCV cv::Mat is copied into a column
// of the datastore in row-major order
size_t cAiryDisk=JKQTPcopyCvMatToColumn(ds, airydisk, "imagedata");
size_t cAiryDisk=JKQTPCopyCvMatToColumn(ds, airydisk, "imagedata");
// 4. create a graph (JKQTPColumnMathImage) with the column created above as data

2
examples/simpletest_imageplot_opencv/jkqtplotter_simpletest_imageplot_opencv.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_imageplot_opencv
# add OpenCV-interface to JKQTPdatastore
# add OpenCV-interface to JKQTPDatastore
DEFINES += JKQTPLOTTER_OPENCV_INTERFACE

10
examples/simpletest_impulsesplot/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple impulse plots {#JKQtPlotterImpulsePlots}
This project (see `./examples/simpletest_impulsesplot/`) simply creates a JKQtPlotter widget (as a new window) and adds a single impulse graph.
# Example (JKQTPLotter): Simple impulse plots {#JKQTPLotterImpulsePlots}
This project (see `./examples/simpletest_impulsesplot/`) simply creates a JKQTPLotter widget (as a new window) and adds a single impulse graph.
The soruce code of the main application is (see [`jkqtplotter_simpletest_impulsesplot.cpp`](../simpletest_impulsesplot/jkqtplotter_simpletest_impulsesplot.cpp).
@ -22,7 +22,7 @@ First data for a curve is calculated and stored in `QVector<double>`:
Now an impulse graph object is generated and added to the plot:
```.cpp
JKQTPimpulsesVerticalGraph* graph=new JKQTPimpulsesVerticalGraph(&plot);
JKQTPImpulsesVerticalGraph* graph=new JKQTPImpulsesVerticalGraph(&plot);
graph->set_xColumn(columnX);
graph->set_yColumn(columnY);
graph->set_lineWidth(2);
@ -36,9 +36,9 @@ The result looks like this:
![jkqtplotter_simpletest_impulsesplot](../../screenshots/jkqtplotter_simpletest_impulsesplot.png)
There is an alternative class `JKQTPimpulsesHorizontalGraph` which draws horizontal impulse plots:
There is an alternative class `JKQTPImpulsesHorizontalGraph` which draws horizontal impulse plots:
```.cpp
JKQTPimpulsesHorizontalGraph* graph=new JKQTPimpulsesHorizontalGraph(&plot);
JKQTPImpulsesHorizontalGraph* graph=new JKQTPImpulsesHorizontalGraph(&plot);
graph->set_yColumn(columnX);
graph->set_xColumn(columnY);
graph->set_lineWidth(2);

10
examples/simpletest_impulsesplot/jkqtplotter_simpletest_impulsesplot.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_impulsesplot.cpp
* Shows how to plot impulse graphs with JKQtPlotter
* Shows how to plot impulse graphs with JKQTPLotter
*
* \ref JKQtPlotterImpulsePlots
* \ref JKQTPLotterImpulsePlots
*/
#include <QApplication>
@ -16,8 +16,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for a simple plot (a sine curve with lin. increasing errors)
QVector<double> X, Y;
@ -32,7 +32,7 @@ int main(int argc, char* argv[])
size_t columnY=ds->addCopiedColumn(Y, "y");
// 4. create a vertical impulse graph in the plot, which plots the dataset X/Y:
JKQTPimpulsesVerticalGraph* graph=new JKQTPimpulsesVerticalGraph(&plot);
JKQTPImpulsesVerticalGraph* graph=new JKQTPImpulsesVerticalGraph(&plot);
graph->set_xColumn(columnX);
graph->set_yColumn(columnY);
graph->set_lineWidth(2);

2
examples/simpletest_impulsesplot/jkqtplotter_simpletest_impulsesplot.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_impulsesplot
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

14
examples/simpletest_logaxes/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Line Graph with Logarithmic y-axis {#JKQtPlotterLogAxes}
This project (see `./examples/simpletest_logaxes/`) simply creates a JKQtPlotter widget (as a new window) and several line-graphs of different resonance curves.
# Example (JKQTPLotter): Line Graph with Logarithmic y-axis {#JKQTPLotterLogAxes}
This project (see `./examples/simpletest_logaxes/`) simply creates a JKQTPLotter widget (as a new window) and several line-graphs of different resonance curves.
The source code of the main application can be found in [`jkqtplotter_simpletest_logaxes.cpp`](../simpletest_logaxes/jkqtplotter_simpletest_logaxes.cpp). Mainly several graphs are generated in a loop and then different line styles are applied to the graphs (set by ``graph->set_style()`). The colors are set automtically from an internal default palette. The main loop looks like this:
@ -12,14 +12,14 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
Y<<1.0/sqrt(sqr(1-sqr(xx))+sqr(2*xx*D[id]));
}
JKQTPxyLineGraph* graph=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph=new JKQTPXYLineGraph(&plot);
// copy data into datastore and immediately set the yColumn
graph->set_xColumn(columnX);
graph->set_yColumn(ds->addCopiedColumn(Y, "y"+QString::number(id)));
// don't use symbols
graph->set_symbol(JKQTPnoSymbol);
graph->set_symbol(JKQTPNoSymbol);
// use one of different pens
graph->set_style(pens[id%pens.size()]);
// set width of graph line
@ -33,10 +33,10 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
}
```
Then a `JKQTPgeoText` is added to the graph, which shows the function plotted in the plot:
Then a `JKQTPGeoText` is added to the graph, which shows the function plotted in the plot:
```.cpp
// 4. Also we add a text-element in the plot to show the plotted function
// This element (JKQTPgeoText) is taken from the set of geometric elements
// This element (JKQTPGeoText) is taken from the set of geometric elements
// and is simply parametrized by a position (1.25/10) and the text to display.
// In addition you can also set the font size (here to 15)
// Use '$...$' around the actual math string to ensure rendering with a math font
@ -44,7 +44,7 @@ Then a `JKQTPgeoText` is added to the graph, which shows the function plotted in
// and loaded in the library). If you don't use the math-mode modifiers, the default
// font of the other rendering text is used, which might not be suitable for
// high-quality math rendering.
plot.addGraph(new JKQTPgeoText(&plot, 1.25, 10, "$\\frac{A}{A_{stat}}=\\frac{1}{\\sqrt{\\left(1-\\eta^2\\right)^2+\\left(2{\\eta}D\\right)^2}}$", 15));
plot.addGraph(new JKQTPGeoText(&plot, 1.25, 10, "$\\frac{A}{A_{stat}}=\\frac{1}{\\sqrt{\\left(1-\\eta^2\\right)^2+\\left(2{\\eta}D\\right)^2}}$", 15));
```
The difference between not using and using `$...$` for the equation can be seen here:
- no $-math-mode: ![](../../screenshots/jkqtplotter_simpletest_logaxes_lowqmathrendering.png)

16
examples/simpletest_logaxes/jkqtplotter_simpletest_logaxes.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_logaxes.cpp
* Shows how to use logarithmic axes with JKQtPlotter
* Shows how to use logarithmic axes with JKQTPLotter
*
* \ref JKQtPlotterLogAxes
* \ref JKQTPLotterLogAxes
*/
#include <QApplication>
@ -17,8 +17,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data a vector of x-values for a simple plot (resonance curve with different damping value D)
// see https://en.wikipedia.org/wiki/Resonance
@ -42,14 +42,14 @@ int main(int argc, char* argv[])
Y<<1.0/sqrt(sqr(1-sqr(xx))+sqr(2*xx*D[id]));
}
JKQTPxyLineGraph* graph=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph=new JKQTPXYLineGraph(&plot);
// copy data into datastore and immediately set the yColumn
graph->set_xColumn(columnX);
graph->set_yColumn(ds->addCopiedColumn(Y, "y"+QString::number(id)));
// don't use symbols
graph->set_symbol(JKQTPnoSymbol);
graph->set_symbol(JKQTPNoSymbol);
// use one of different pens
graph->set_style(pens[id%pens.size()]);
// set width of graph line
@ -63,7 +63,7 @@ int main(int argc, char* argv[])
}
// 4. Also we add a text-element in the plot to show the plotted function
// This element (JKQTPgeoText) is taken from the set of geometric elements
// This element (JKQTPGeoText) is taken from the set of geometric elements
// and is simply parametrized by a position (1.25/10) and the text to display.
// In addition you can also set the font size (here to 15)
// Use '$...$' around the actual math string to ensure rendering with a math font
@ -71,7 +71,7 @@ int main(int argc, char* argv[])
// and loaded in the library). If you don't use the math-mode modifiers, the default
// font of the other rendering text is used, which might not be suitable for
// high-quality math rendering.
plot.addGraph(new JKQTPgeoText(&plot, 1.25, 10, "$\\frac{A}{A_{stat}}=\\frac{1}{\\sqrt{\\left(1-\\eta^2\\right)^2+\\left(2{\\eta}D\\right)^2}}$", 15));
plot.addGraph(new JKQTPGeoText(&plot, 1.25, 10, "$\\frac{A}{A_{stat}}=\\frac{1}{\\sqrt{\\left(1-\\eta^2\\right)^2+\\left(2{\\eta}D\\right)^2}}$", 15));
// 5. set y-axis to logarithmic (x-axis would be analogous, but using `plot.get_xAxis()`)
plot.get_yAxis()->set_logAxis(true);

2
examples/simpletest_logaxes/jkqtplotter_simpletest_logaxes.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_logaxes
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

14
examples/simpletest_parametriccurve/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Plotting Parametric Curves {#JKQtPlotterParametricCurves}
This project (see `./examples/simpletest_parametriccurve/`) demonstrates how to draw parametric curves, using [`JKQTPxyLineGraph`}(../simpletest) and [`JKQTPxyParametrizedScatterGraph`](../simpletest_paramscatterplot).
# Example (JKQTPLotter): Plotting Parametric Curves {#JKQTPLotterParametricCurves}
This project (see `./examples/simpletest_parametriccurve/`) demonstrates how to draw parametric curves, using [`JKQTPXYLineGraph`}(../simpletest) and [`JKQTPXYParametrizedScatterGraph`](../simpletest_paramscatterplot).
The source code of the main application can be found in [`jkqtplotter_simpletest_parametriccurve.cpp`](../simpletest_parametriccurve/jkqtplotter_simpletest_parametriccurve.cpp). First, the parametric curve (here a [logarithic spiral](https://en.wikipedia.org/wiki/Logarithmic_spiral)) is sampled into two columns containing the x- and y-values along the curve. In addition the radial distance from x=y=0 is added into a third column:
```.cpp
@ -24,23 +24,23 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
Then simples graph just uses the columns X and Y to plot the curve:
```.cpp
JKQTPxyLineGraph* graph1=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph1=new JKQTPXYLineGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_drawLine(true);
graph1->set_symbol(JKQTPnoSymbol);
graph1->set_symbol(JKQTPNoSymbol);
graph1->set_title("one-colored spiral");
plot.addGraph(graph1);
```
If you use `JKQTPxyParametrizedScatterGraph` instead of `JKQTPxyLineGraph`, you can also modify the color of the line-segments, connecting the datapoints:
If you use `JKQTPXYParametrizedScatterGraph` instead of `JKQTPXYLineGraph`, you can also modify the color of the line-segments, connecting the datapoints:
```.cpp
JKQTPxyParametrizedScatterGraph* graph2=new JKQTPxyParametrizedScatterGraph(&plot2);
JKQTPXYParametrizedScatterGraph* graph2=new JKQTPXYParametrizedScatterGraph(&plot2);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY);
graph2->set_colorColumn(columnR);
graph2->set_palette(JKQTPMathImageMATLAB);
graph2->set_symbol(JKQTPnoSymbol);
graph2->set_symbol(JKQTPNoSymbol);
graph2->set_drawLine(true);
graph2->set_title("colored spiral");
graph2->get_colorBarRightAxis()->set_axisLabel("color scale radius $r(\\phi)$");

16
examples/simpletest_parametriccurve/jkqtplotter_simpletest_parametriccurve.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_parametriccurve.cpp
* Shows how to plot parametric curves from datapoints with JKQtPlotter
* Shows how to plot parametric curves from datapoints with JKQTPLotter
*
* \ref JKQtPlotterParametricCurves
* \ref JKQTPLotterParametricCurves
*/
#include <QApplication>
@ -14,8 +14,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create two plotter windows that share the same internal datastore (for convenience)
JKQtPlotter plot, plot2;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot, plot2;
JKQTPDatastore* ds=plot.getDatastore();
plot2.useExternalDatastore(ds);
// 2. now we create a vector of x- and y-values of the logarithmic spiral
@ -42,22 +42,22 @@ int main(int argc, char* argv[])
// a datacolumn
// 3.1 the basic graph
JKQTPxyLineGraph* graph1=new JKQTPxyLineGraph(&plot);
JKQTPXYLineGraph* graph1=new JKQTPXYLineGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_drawLine(true);
graph1->set_symbol(JKQTPnoSymbol);
graph1->set_symbol(JKQTPNoSymbol);
graph1->set_title("one-colored spiral");
plot.addGraph(graph1);
// 3.2 for graph2 is the same as graph 1, but in addition, the color of the lines
// is set, based on the contents of column R, via the color-palette JKQTPMathImageMATLAB
JKQTPxyParametrizedScatterGraph* graph2=new JKQTPxyParametrizedScatterGraph(&plot2);
JKQTPXYParametrizedScatterGraph* graph2=new JKQTPXYParametrizedScatterGraph(&plot2);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY);
graph2->set_colorColumn(columnR);
graph2->set_palette(JKQTPMathImageMATLAB);
graph2->set_symbol(JKQTPnoSymbol);
graph2->set_symbol(JKQTPNoSymbol);
graph2->set_drawLine(true);
graph2->set_title("colored spiral");
graph2->get_colorBarRightAxis()->set_axisLabel("color scale radius $r(\\phi)$");

2
examples/simpletest_parametriccurve/jkqtplotter_simpletest_parametriccurve.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_parametriccurve
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

26
examples/simpletest_paramscatterplot/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Scatter Graph with Parametrized Symbols/Colors {#JKQtPlotterParamScatter}
This project (see `./examples/simpletest_paramscatterplot/`) demonstrates the capabilities of `JKQTPxyParametrizedScatterGraph`. This graph class plots symbol&line-graphs, juts like [`JKQTPxyLineGraph`](../simpletest_symbols_and_styles/) and in addition modifies several properties of each plot point by data from an additional column. These properties can be modified:
# Example (JKQTPLotter): Scatter Graph with Parametrized Symbols/Colors {#JKQTPLotterParamScatter}
This project (see `./examples/simpletest_paramscatterplot/`) demonstrates the capabilities of `JKQTPXYParametrizedScatterGraph`. This graph class plots symbol&line-graphs, juts like [`JKQTPXYLineGraph`](../simpletest_symbols_and_styles/) and in addition modifies several properties of each plot point by data from an additional column. These properties can be modified:
- symbol size
- symbol type
- symbol/line color
@ -11,9 +11,9 @@ The source code of the main application can be found in [`jkqtplotter_simpletes
Then several plots are added that modify different properties.
The simplest case is to modify the symbol type. Simply set the property `symbolColumn` with `graph1->set_symbolColumn(columnP)` to a data column. The values in the data column will be cast to an integer and then will be translated to `JKQTPgraphSymbols`. If the numbers are larger than the available symbol types in `JKQTPgraphSymbols`, the graph will cycle through the available symbols (via a modulo-operation with the max. symbol count!).
The simplest case is to modify the symbol type. Simply set the property `symbolColumn` with `graph1->set_symbolColumn(columnP)` to a data column. The values in the data column will be cast to an integer and then will be translated to `JKQTPGraphSymbols`. If the numbers are larger than the available symbol types in `JKQTPGraphSymbols`, the graph will cycle through the available symbols (via a modulo-operation with the max. symbol count!).
```.cpp
JKQTPxyParametrizedScatterGraph* graph1=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph1=new JKQTPXYParametrizedScatterGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY1);
graph1->set_symbolColumn(columnP);
@ -27,22 +27,22 @@ The simplest case is to modify the symbol type. Simply set the property `symbolC
The next two code snippets show how to modify the size of the symbols and the line width of the lines, connecting the symbols (ensure to set `graph6->set_drawLine(true)`, because otherwise no line will be drawn). The principle is the same as above, but here you need to set the properties `sizeColumn` for the symbol size and `linewidthColumn` for the line width. All values in the line width or symbol size columns are interpreted as sizes in dtp points (pt)!
```.cpp
// symbol size
JKQTPxyParametrizedScatterGraph* graph3=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph3=new JKQTPXYParametrizedScatterGraph(&plot);
graph3->set_xColumn(columnX);
graph3->set_yColumn(columnY3);
graph3->set_sizeColumn(columnS);
graph3->set_symbol(JKQTPfilledCircle);
graph3->set_symbol(JKQTPFilledCircle);
graph3->set_drawLine(true);
graph3->set_title("3: symbol size");
plot.addGraph(graph3);
// line width
JKQTPxyParametrizedScatterGraph* graph6=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph6=new JKQTPXYParametrizedScatterGraph(&plot);
graph6->set_xColumn(columnX);
graph6->set_yColumn(columnY6);
graph6->set_linewidthColumn(columnLW);
graph6->set_drawLine(true);
graph6->set_symbol(JKQTPnoSymbol);
graph6->set_symbol(JKQTPNoSymbol);
graph6->set_title("6: line width");
plot.addGraph(graph6);
```
@ -62,25 +62,25 @@ Basically the data points in a RGB(A)-column will be interpreted by castig them
Now you can add the graph. In order to interpret the color column as RGB(A)-values, ensure to set `graph4->set_colorColumnContainsRGB(true)`:
```.cpp
JKQTPxyParametrizedScatterGraph* graph4=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph4=new JKQTPXYParametrizedScatterGraph(&plot);
graph4->set_xColumn(columnX);
graph4->set_yColumn(columnY4);
graph4->set_colorColumn(columnRGB);
graph4->set_colorColumnContainsRGB(true);
graph4->set_drawLine(true);
graph4->set_symbol(JKQTPfilledDownTriangle);
graph4->set_symbol(JKQTPFilledDownTriangle);
graph4->set_title("4: RGB-color");
plot.addGraph(graph4);
```
The second variant for setting the color of each datapoint is by mapping the values in the column to a color palette (`JKQTPMathImageRYGB` in this example). For this you simply need to define the color coumn and the palette to use. By default, the color palette spans the full range of values in `colorColumn`:
```.cpp
JKQTPxyParametrizedScatterGraph* graph2=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph2=new JKQTPXYParametrizedScatterGraph(&plot);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY2);
graph2->set_colorColumn(columnC);
graph2->set_palette(JKQTPMathImageRYGB);
graph2->set_symbol(JKQTPfilledRect);
graph2->set_symbol(JKQTPFilledRect);
graph2->set_drawLine(true);
graph2->set_title("2: color");
graph2->get_colorBarRightAxis()->set_axisLabel("color scale for graph2");
@ -91,7 +91,7 @@ Note: If you want to set the range manually, use `ste_imageMin()` and `set_image
Note also that it is possible to combine any of parametrizations above in a single graph, by setting two or more columns:
```.cpp
JKQTPxyParametrizedScatterGraph* graph5=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph5=new JKQTPXYParametrizedScatterGraph(&plot);
graph5->set_xColumn(columnX);
graph5->set_yColumn(columnY5);
graph5->set_colorColumn(columnC);

36
examples/simpletest_paramscatterplot/jkqtplotter_simpletest_paramscatterplot.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_paramscatterplot.cpp
* JKQtPlotter: Examples: Scatter Graph with Parametrized Symbols/Colors
* JKQTPLotter: Examples: Scatter Graph with Parametrized Symbols/Colors
*
* \ref JKQtPlotterParamScatter
* \ref JKQTPLotterParamScatter
*/
#include <QApplication>
@ -14,8 +14,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create a vector of x- and y-values for a simple plot (a sine curve)
// in addition, a vector P will hold values that will be mapped onto different plot styles
@ -59,7 +59,7 @@ int main(int argc, char* argv[])
// 3.1 for graph1, we use dataset X/Y1
// and the symbol type is choose according to the contents of column P:
JKQTPxyParametrizedScatterGraph* graph1=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph1=new JKQTPXYParametrizedScatterGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY1);
graph1->set_symbolColumn(columnP);
@ -71,12 +71,12 @@ int main(int argc, char* argv[])
// 3.2 for graph2, we use dataset X/Y2
// and the symbol color is choose according to the contents of column C
// and the actual colors are chose from palette JKQTPMathImageRYGB:
JKQTPxyParametrizedScatterGraph* graph2=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph2=new JKQTPXYParametrizedScatterGraph(&plot);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY2);
graph2->set_colorColumn(columnC);
graph2->set_palette(JKQTPMathImageRYGB);
graph2->set_symbol(JKQTPfilledRect);
graph2->set_symbol(JKQTPFilledRect);
graph2->set_drawLine(true);
graph2->set_title("2: color");
graph2->get_colorBarRightAxis()->set_axisLabel("color scale for graph2");
@ -84,11 +84,11 @@ int main(int argc, char* argv[])
// 3.3 for graph3, we use dataset X/Y3
// and the symbol size is choose according to the contents of column S:
JKQTPxyParametrizedScatterGraph* graph3=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph3=new JKQTPXYParametrizedScatterGraph(&plot);
graph3->set_xColumn(columnX);
graph3->set_yColumn(columnY3);
graph3->set_sizeColumn(columnS);
graph3->set_symbol(JKQTPfilledCircle);
graph3->set_symbol(JKQTPFilledCircle);
graph3->set_drawLine(true);
graph3->set_title("3: symbol size");
plot.addGraph(graph3);
@ -96,13 +96,13 @@ int main(int argc, char* argv[])
// 3.4 for graph4, we use X/Y4
// and the symbol color is choose according to the contents of column RGB,
// which directly contains the RGB values, as set with qRgb():
JKQTPxyParametrizedScatterGraph* graph4=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph4=new JKQTPXYParametrizedScatterGraph(&plot);
graph4->set_xColumn(columnX);
graph4->set_yColumn(columnY4);
graph4->set_colorColumn(columnRGB);
graph4->set_colorColumnContainsRGB(true);
graph4->set_drawLine(true);
graph4->set_symbol(JKQTPfilledDownTriangle);
graph4->set_symbol(JKQTPFilledDownTriangle);
graph4->set_title("4: RGB-color");
plot.addGraph(graph4);
@ -110,7 +110,7 @@ int main(int argc, char* argv[])
// and the symbol color and size are choose according to the contents
// of columns C and S respectively.
// The actual colors are chose from palette JKQTPMathImageBLUEYELLOW:
JKQTPxyParametrizedScatterGraph* graph5=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph5=new JKQTPXYParametrizedScatterGraph(&plot);
graph5->set_xColumn(columnX);
graph5->set_yColumn(columnY5);
graph5->set_colorColumn(columnC);
@ -123,33 +123,33 @@ int main(int argc, char* argv[])
// 3.6 for graph2, we use dataset X/Y6
// and the line width is set by column LW:
JKQTPxyParametrizedScatterGraph* graph6=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph6=new JKQTPXYParametrizedScatterGraph(&plot);
graph6->set_xColumn(columnX);
graph6->set_yColumn(columnY6);
graph6->set_linewidthColumn(columnLW);
graph6->set_drawLine(true);
graph6->set_symbol(JKQTPnoSymbol);
graph6->set_symbol(JKQTPNoSymbol);
graph6->set_title("6: line width");
plot.addGraph(graph6);
// 3.7 for graph2, we use dataset X/Y7
// and the line width is set by column LW and the color from palette JKQTPMathImageBLUEYELLOW via column C:
JKQTPxyParametrizedScatterGraph* graph7=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph7=new JKQTPXYParametrizedScatterGraph(&plot);
graph7->set_xColumn(columnX);
graph7->set_yColumn(columnY7);
graph7->set_linewidthColumn(columnLW);
graph7->set_drawLine(true);
graph7->set_colorColumn(columnC);
graph7->set_palette(JKQTPMathImageBLUEYELLOW);
graph7->set_symbol(JKQTPnoSymbol);
graph7->set_symbol(JKQTPNoSymbol);
graph7->set_colorBarRightVisible(false);
graph7->set_colorBarTopVisible(false);
graph7->set_title("7: color+line width");
plot.addGraph(graph7);
// 4. autoscale the plot so the graph is contained and format the coordinate system and key
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideBottomLeft);
plot.get_plotter()->set_keyLayout(JKQTPkeyLayoutOneRow);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideBottomLeft);
plot.get_plotter()->set_keyLayout(JKQTPKeyLayoutOneRow);
plot.get_xAxis()->set_axisLabel("x-axis");
plot.get_yAxis()->set_axisLabel("y-axis");
plot.get_xAxis()->set_drawGrid(false);

2
examples/simpletest_paramscatterplot/jkqtplotter_simpletest_paramscatterplot.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_paramscatterplot
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

12
examples/simpletest_paramscatterplot_image/README.md
View File

@ -1,7 +1,7 @@
# Example (JKQtPlotter): Draw an Artistic Image with a Parametrized Scatter Graph {#JKQtPlotterParamScatterImage}
This project (see `./examples/simpletest_paramscatterplot_image/`) demonstrates the capabilities of `JKQTPxyParametrizedScatterGraph` to display parametrized scatters in a rectangular arrangement. See the test program in [`test/simpletest_paramscatterplot`](../simpletest_paramscatterplot) for a basic example of the capabilities of `JKQTPxyParametrizedScatterGraph`.
# Example (JKQTPLotter): Draw an Artistic Image with a Parametrized Scatter Graph {#JKQTPLotterParamScatterImage}
This project (see `./examples/simpletest_paramscatterplot_image/`) demonstrates the capabilities of `JKQTPXYParametrizedScatterGraph` to display parametrized scatters in a rectangular arrangement. See the test program in [`test/simpletest_paramscatterplot`](../simpletest_paramscatterplot) for a basic example of the capabilities of `JKQTPXYParametrizedScatterGraph`.
In this example, we load an image, convert it to greyscale and store it, together with x/y-coordinate-vectors in the datastore. Then a `JKQTPxyParametrizedScatterGraph` is used to draw the image as a pointilistic artwork, where each pixel is represented by a disk. The color of the disk is chosen from a color-palette, based on the grey-value. The size of each disk is chosen from the inverse grey value.
In this example, we load an image, convert it to greyscale and store it, together with x/y-coordinate-vectors in the datastore. Then a `JKQTPXYParametrizedScatterGraph` is used to draw the image as a pointilistic artwork, where each pixel is represented by a disk. The color of the disk is chosen from a color-palette, based on the grey-value. The size of each disk is chosen from the inverse grey value.
First we prepare the data, as described above. The image is loaded and then converted to the required data vectors.
```.cpp
@ -31,13 +31,13 @@ First we prepare the data, as described above. The image is loaded and then conv
size_t columnS=ds->addCopiedColumn(pointSizes, "pointSizes");
```
Now we can use th datavectors to add a `JKQTPxyParametrizedScatterGraph`:
Now we can use th datavectors to add a `JKQTPXYParametrizedScatterGraph`:
```.cpp
JKQTPxyParametrizedScatterGraph* graph1=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph1=new JKQTPXYParametrizedScatterGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_sizeColumn(columnS);
graph1->set_symbol(JKQTPfilledCircle);
graph1->set_symbol(JKQTPFilledCircle);
graph1->set_colorColumn(columnG);
graph1->set_palette(JKQTPMathImageMATLAB);
graph1->set_drawLine(false);

12
examples/simpletest_paramscatterplot_image/jkqtplotter_simpletest_paramscatterplot_image.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_paramscatterplot_image.cpp
* JKQtPlotter: Examples: Draw an Artistic Image with a Parametrized Scatter Graph
* JKQTPLotter: Examples: Draw an Artistic Image with a Parametrized Scatter Graph
*
* \ref JKQtPlotterParamScatterImage
* \ref JKQTPLotterParamScatterImage
*/
#include <QApplication>
@ -15,8 +15,8 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPdatastore* ds=plot.getDatastore();
JKQTPLotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. Prepare Data
// 2.1 load image
@ -48,12 +48,12 @@ int main(int argc, char* argv[])
// 3.1 Now add a parametrized scatter graph with columnX, columnY for the positions of the
// scatter points, where the symbol size is given by column columnS and the color of
// each symbol is set from column columnG, via a color palette JKQTPMathImageMATLAB
JKQTPxyParametrizedScatterGraph* graph1=new JKQTPxyParametrizedScatterGraph(&plot);
JKQTPXYParametrizedScatterGraph* graph1=new JKQTPXYParametrizedScatterGraph(&plot);
graph1->set_xColumn(columnX);
graph1->set_yColumn(columnY);
graph1->set_sizeColumn(columnS);
graph1->set_symbolColumn(columnS);
graph1->set_symbol(JKQTPfilledTriangle);
graph1->set_symbol(JKQTPFilledTriangle);
graph1->set_colorColumn(columnG);
graph1->set_palette(JKQTPMathImageOCEAN);
graph1->set_drawLine(false);

2
examples/simpletest_paramscatterplot_image/jkqtplotter_simpletest_paramscatterplot_image.pro
View File

@ -12,7 +12,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_paramscatterplot_image
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

18
examples/simpletest_parsedfunctionplot/README.md
View File

@ -1,29 +1,29 @@
# Example (JKQtPlotter): Plotting Parsed Mathematical Functions as Line Graphs {#JKQtPlotterParsedFunctionPlot}
# Example (JKQTPLotter): Plotting Parsed Mathematical Functions as Line Graphs {#JKQTPLotterParsedFunctionPlot}
## Plot Function f(x)
This project (see `./examples/simpletest_parsedfunctionplot/`) demonstrates how to plot mathematical functions as line graphs. The functions are defined as strings that will be evaluated with the equation parser, integrated into JKQtPlotter.
This project (see `./examples/simpletest_parsedfunctionplot/`) demonstrates how to plot mathematical functions as line graphs. The functions are defined as strings that will be evaluated with the equation parser, integrated into JKQTPLotter.
Note: See the example [Plotting Mathematical Functions as Line Graphs](../simpletest_functionplot) if you don't want to draw parsed functions, but want to provide a C function, or C++ functor!
Adding an evaluated funtion to a graph is very simple:
```.cpp
JKQTPxParsedFunctionLineGraph* parsedFunc=new JKQTPxParsedFunctionLineGraph(plot);
JKQTPXParsedFunctionLineGraph* parsedFunc=new JKQTPXParsedFunctionLineGraph(plot);
parsedFunc->set_function("sin(x*8)*exp(-x/4)");
parsedFunc->set_title("user function");
```
As you can see a graph of the type `JKQTPxParsedFunctionLineGraph` is used, which plots a function that depends on the variable `x`. The given function is parsed and evaluated (see [`lib/jkqtplottertools/jkqtpmathparser.h`](https://github.com/jkriege2/JKQtPlotter/blob/master/lib/jkqtplottertools/jkqtpmathparser.h) for details on the features of the math parser). An intelligent drawing algorithm chooses the number of control points for drawing a smooth graph, with sufficient amount of details, by evaluating locally the slope of the function.
As you can see a graph of the type `JKQTPXParsedFunctionLineGraph` is used, which plots a function that depends on the variable `x`. The given function is parsed and evaluated (see [`lib/jkqtplottertools/jkqtpmathparser.h`](https://github.com/jkriege2/JKQTPLotter/blob/master/lib/jkqtplottertools/jkqtpmathparser.h) for details on the features of the math parser). An intelligent drawing algorithm chooses the number of control points for drawing a smooth graph, with sufficient amount of details, by evaluating locally the slope of the function.
In the example in [`test/simpletest_parsedfunctionplot/simpletest_parsedfunctionplot.cpp`](../simpletest_parsedfunctionplot/simpletest_parsedfunctionplot.cpp) we do not simply set a fixed function, but add a `QLineEdit` which allows to edit the function and redraws it, once ENTER is pressed:
```.cpp
JKQtPlotter* plot=new JKQtPlotter(&mainWin);
JKQTPLotter* plot=new JKQTPLotter(&mainWin);
QLineEdit* edit=new QLineEdit(&mainWin);
edit->setToolTip("enter a function in dependence of the variable <tt>x</tt> and press ENTER to update the graph");
// ...
// 2. now we add a JKQTPxParsedFunctionLineGraph object, which will draw the function from
// 2. now we add a JKQTPXParsedFunctionLineGraph object, which will draw the function from
// the line edit
JKQTPxParsedFunctionLineGraph* parsedFunc=new JKQTPxParsedFunctionLineGraph(plot);
JKQTPXParsedFunctionLineGraph* parsedFunc=new JKQTPXParsedFunctionLineGraph(plot);
plot->addGraph(parsedFunc);
// finally we connect the line edit with the graph, whenever RETURN is pressed,
// the graph is updated:
@ -48,14 +48,14 @@ This code snippet results in a plot like this:
As shown in [Plotting Mathematical Functions as Line Graphs](../simpletest_functionplot) you can also use externally set parameters in a plot function. These parameters can be double numbers and may be set with either as an internal parameter vector, or may be read from a parameter column (as shown in the [linked example](../simpletest_functionplot)). These parameters are available as variables `p1`, `p2`, ... in the function string. Here is a small example:
```.cpp
JKQTPxParsedFunctionLineGraph* parsedFunc=new JKQTPxParsedFunctionLineGraph(plot);
JKQTPXParsedFunctionLineGraph* parsedFunc=new JKQTPXParsedFunctionLineGraph(plot);
parsedFunc->set_function("sin(x*p1)*exp(-x/p2)");
parsedFunc->set_paramV(/*p1=*/8, /*p2=*/4);
parsedFunc->set_title("user function");
```
## Plot Function f(y)
If you use the graph class `JKQTPyParsedFunctionLineGraph` instead of `JKQTPxParsedFunctionLineGraph`, you can plot functions `x=f(y)` (instead of `y=f(x)`). The function from the example above will then ahve to be changed to `sin(y*8)*exp(-y/4)` and the result will look like this:
If you use the graph class `JKQTPYParsedFunctionLineGraph` instead of `JKQTPXParsedFunctionLineGraph`, you can plot functions `x=f(y)` (instead of `y=f(x)`). The function from the example above will then ahve to be changed to `sin(y*8)*exp(-y/4)` and the result will look like this:
![jkqtplotter_simpletest_parsedfunctionplot_fy](../../screenshots/jkqtplotter_simpletest_parsedfunctionplot_fy.png)

12
examples/simpletest_parsedfunctionplot/jkqtplotter_simpletest_parsedfunctionplot.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_parsedfunctionplot.cpp
* JKQtPlotter: Examples: Plotting Parsed Mathematical Functions as Line Graphs
* JKQTPLotter: Examples: Plotting Parsed Mathematical Functions as Line Graphs
*
* \ref JKQtPlotterParsedFunctionPlot
* \ref JKQTPLotterParsedFunctionPlot
*/
#include <QApplication>
@ -20,7 +20,7 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a window that conatins a line-edit to edit a function
// and a JKQtPlotter to display the function, combine everything in a layout
// and a JKQTPLotter to display the function, combine everything in a layout
QWidget mainWin;
QLineEdit* edit=new QLineEdit(&mainWin);
edit->setToolTip("enter a function in dependence of the variable <tt>x</tt> and press ENTER to update the graph");
@ -33,7 +33,7 @@ int main(int argc, char* argv[])
spinP2->setValue(4);
spinP2->setRange(-10000,10000);
spinP2->setToolTip("enter a Value for parameter <tt>p1</tt> and press ENTER to update the graph");
JKQtPlotter* plot=new JKQtPlotter(&mainWin);
JKQTPLotter* plot=new JKQTPLotter(&mainWin);
QFormLayout* flayout=new QFormLayout;
QVBoxLayout* layout=new QVBoxLayout;
mainWin.setLayout(layout);
@ -44,9 +44,9 @@ int main(int argc, char* argv[])
layout->addLayout(flayout);
layout->addWidget(plot);
// 2. now we add a JKQTPxParsedFunctionLineGraph object, which will draw the function from
// 2. now we add a JKQTPXParsedFunctionLineGraph object, which will draw the function from
// the line edit
JKQTPxParsedFunctionLineGraph* parsedFunc=new JKQTPxParsedFunctionLineGraph(plot);
JKQTPXParsedFunctionLineGraph* parsedFunc=new JKQTPXParsedFunctionLineGraph(plot);
plot->addGraph(parsedFunc);
// finally we connect the line edit with the graph, whenever RETURN is pressed,
// the graph is updated:

2
examples/simpletest_parsedfunctionplot/jkqtplotter_simpletest_parsedfunctionplot.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
TARGET = jkqtplotter_simpletest_parsedfunctionplot
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

22
examples/simpletest_rgbimageplot_opencv/README.md
View File

@ -1,8 +1,8 @@
# Example (JKQtPlotter): Simple RGB image plot, showing a 3-channel OpenCV cv::Mat {#JKQtPlotterImagePlotRGBOpenCV}
This project (see `./examples/simpletest_imageplot_opencv/`) simply creates a JKQtPlotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is generated as an OpenCV cv::Mat image and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore).
To copy the data a special OpenCV Interface function `JKQTPcopyCvMatToColumn()` is used, that copies the data from a cv::Mat directly into a column.
# Example (JKQTPLotter): Simple RGB image plot, showing a 3-channel OpenCV cv::Mat {#JKQTPLotterImagePlotRGBOpenCV}
This project (see `./examples/simpletest_imageplot_opencv/`) simply creates a JKQTPLotter widget (as a new window) and adds a color-coded image plot of a mathematical function (here the Airy disk). The image is generated as an OpenCV cv::Mat image and then copied into a single column of the internal datasdtore (JKQTPMathImage could be directly used without the internal datastore).
To copy the data a special OpenCV Interface function `JKQTPCopyCvMatToColumn()` is used, that copies the data from a cv::Mat directly into a column.
The function `JKQTPcopyCvMatToColumn()` is available from the (non-default) header-only extension from `jkqtplotter/jkqtpopencvinterface.h`. This header provides facilities to interface JKQtPlotter with OPenCV.
The function `JKQTPCopyCvMatToColumn()` is available from the (non-default) header-only extension from `jkqtplotter/jkqtpopencvinterface.h`. This header provides facilities to interface JKQTPLotter with OPenCV.
The source code of the main application is (see [`jkqtplotter_simpletest_imageplot_opencv.cpp`](../simpletest_imageplot_opencv/jkqtplotter_simpletest_imageplot_opencv.cpp):
```.cpp
@ -20,14 +20,14 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we open a BMP-file and load it into an OpenCV cv::Mat
@ -35,12 +35,12 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of each channel of the openCV cv::Mat is copied into a column
// of the datastore in row-major order
size_t cPictureR=JKQTPcopyCvMatToColumn(ds, picture, "R-channel", 2);
size_t cPictureG=JKQTPcopyCvMatToColumn(ds, picture, "G-channel", 1);
size_t cPictureB=JKQTPcopyCvMatToColumn(ds, picture, "B-channel", 0);
size_t cPictureR=JKQTPCopyCvMatToColumn(ds, picture, "R-channel", 2);
size_t cPictureG=JKQTPCopyCvMatToColumn(ds, picture, "G-channel", 1);
size_t cPictureB=JKQTPCopyCvMatToColumn(ds, picture, "B-channel", 0);
// 4. create a graph (JKQTPColumnRGBMathImage) with the columns created above as data
@ -97,6 +97,6 @@ The result looks like this:
![jkqtplotter_simpletest_imageplot](../../screenshots/jkqtplotter_simpletest_rgbimageplot_opencv.png)
The image is upside-down, because computer images use a coordinate system with 0 at the top-left (left-handed coordinate system) and the JKQtPlotter has its 0 at the bottom-left (right-handed coordinate system).
The image is upside-down, because computer images use a coordinate system with 0 at the top-left (left-handed coordinate system) and the JKQTPLotter has its 0 at the bottom-left (right-handed coordinate system).

16
examples/simpletest_rgbimageplot_opencv/jkqtplotter_simpletest_rgbimageplot_opencv.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_rgbimageplot_opencv.cpp
* JKQtPlotter: Examples: Simple RGB image plot, showing a 3-channel OpenCV cv::Mat
* JKQTPLotter: Examples: Simple RGB image plot, showing a 3-channel OpenCV cv::Mat
*
* \ref JKQtPlotterImagePlotRGBOpenCV
* \ref JKQTPLotterImagePlotRGBOpenCV
*/
#include <QApplication>
@ -18,14 +18,14 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we open a BMP-file and load it into an OpenCV cv::Mat
@ -33,12 +33,12 @@ int main(int argc, char* argv[])
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// In this step the contents of each channel of the openCV cv::Mat is copied into a column
// of the datastore in row-major order
size_t cPictureR=JKQTPcopyCvMatToColumn(ds, picture, "R-channel", 2);
size_t cPictureG=JKQTPcopyCvMatToColumn(ds, picture, "G-channel", 1);
size_t cPictureB=JKQTPcopyCvMatToColumn(ds, picture, "B-channel", 0);
size_t cPictureR=JKQTPCopyCvMatToColumn(ds, picture, "R-channel", 2);
size_t cPictureG=JKQTPCopyCvMatToColumn(ds, picture, "G-channel", 1);
size_t cPictureB=JKQTPCopyCvMatToColumn(ds, picture, "B-channel", 0);
// 4. create a graph (JKQTPColumnRGBMathImage) with the columns created above as data

2
examples/simpletest_rgbimageplot_opencv/jkqtplotter_simpletest_rgbimageplot_opencv.pro
View File

@ -9,7 +9,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_rgbimageplot_opencv
# add OpenCV-interface to JKQTPdatastore
# add OpenCV-interface to JKQTPDatastore
DEFINES += JKQTPLOTTER_OPENCV_INTERFACE

4
examples/simpletest_rgbimageplot_qt/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): QImage as a Graph {#JKQtPlotterImagePlotQImageRGB}
This project (see `./examples/simpletest_rgbimageplot_qt/`) simply creates a JKQtPlotter widget (as a new window) and adds an image plot with an image taken from a [QImage](http://doc.qt.io/qt-5/qimage.html) object.
# Example (JKQTPLotter): QImage as a Graph {#JKQTPLotterImagePlotQImageRGB}
This project (see `./examples/simpletest_rgbimageplot_qt/`) simply creates a JKQTPLotter widget (as a new window) and adds an image plot with an image taken from a [QImage](http://doc.qt.io/qt-5/qimage.html) object.
The source code of the main application is (see [`jkqtplotter_simpletest_rgbimageplot_qt.cpp`](../simpletest_rgbimageplot_qt/jkqtplotter_simpletest_rgbimageplot_qt.cpp). the main parts are:
```.cpp

6
examples/simpletest_rgbimageplot_qt/jkqtplotter_simpletest_rgbimageplot_qt.cpp
View File

@ -1,7 +1,7 @@
/** \example jkqtplotter_simpletest_rgbimageplot_qt.cpp
* JKQtPlotter: Examples: `QImage` as a Graph
* JKQTPLotter: Examples: `QImage` as a Graph
*
* \ref JKQtPlotterImagePlotQImageRGB
* \ref JKQTPLotterImagePlotQImageRGB
*/
#include <QApplication>
@ -16,7 +16,7 @@ int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQtPlotter plot;
JKQTPLotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)

2
examples/simpletest_rgbimageplot_qt/jkqtplotter_simpletest_rgbimageplot_qt.pro
View File

@ -12,7 +12,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_rgbimageplot_qt
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

10
examples/simpletest_speed/README.md
View File

@ -1,12 +1,12 @@
# Example (JKQtPlotter): Simple line-graph with live-data (speed test) {#JKQtPlotterSpeedTest}
This project (see `./examples/simpletest_speed/`) simply creates a JKQtPlotter widget (as a new window) and adds two line-graph (a sine and a cosine wave).
# Example (JKQTPLotter): Simple line-graph with live-data (speed test) {#JKQTPLotterSpeedTest}
This project (see `./examples/simpletest_speed/`) simply creates a JKQTPLotter widget (as a new window) and adds two line-graph (a sine and a cosine wave).
Data is stored in two [`std::array<double, NDATA>`](https://en.cppreference.com/w/cpp/container/array) objects (`X`, `Y`, and `Y2`) and the data is added as external pointer to the datastore:
```.cpp
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Here the data from the std::array's is not copied, but only the pointer to
// the array is added to the datastore. therefore the datastore does not manage
// the memory, oly uses the data stored in it!
JKQTPdatastore* ds=getDatastore();
JKQTPDatastore* ds=getDatastore();
size_t columnX=ds->addColumn(X.data(), X.size(), "x");
size_t columnY=ds->addColumn(Y.data(), Y.size(), "y");
size_t columnY2=ds->addColumn(Y2.data(), Y2.size(), "y2");
@ -54,7 +54,7 @@ The result looks like this:
![jkqtplotter_simpletest_speed1](../../screenshots/jkqtplotter_simpletest_speed.png)
There are different facor affecting the replot speed:
1. *Anti-Aliasing:* If `JKQtPlotter` uses Anti-Aliasing for plotting, the plots are much nicer, but also about a factor of 3-4 slower. This is due to the increased amount of calculations, necessary in the drawing sub-system of Qt.
1. *Anti-Aliasing:* If `JKQTPLotter` uses Anti-Aliasing for plotting, the plots are much nicer, but also about a factor of 3-4 slower. This is due to the increased amount of calculations, necessary in the drawing sub-system of Qt.
You can configrue anti-aliasing with these calls:
```.cpp
plot.get_plotter()->set_useAntiAliasingForGraphs(false);

2
examples/simpletest_speed/jkqtplotter_simpletest_speed.pro
View File

@ -10,7 +10,7 @@ greaterThan(QT_MAJOR_VERSION, 4): QT += widgets printsupport
# output executable name
TARGET = jkqtplotter_simpletest_speed
# include JKQtPlotter source code
# include JKQTPLotter source code
DEPENDPATH += . ../../lib
INCLUDEPATH += ../../lib
CONFIG (debug, debug|release) {

16
examples/simpletest_speed/speedtestplot.cpp
View File

@ -1,7 +1,7 @@
/** \example speedtestplot.cpp
* JKQtPlotter: Examples: Simple line-graph with live-data (speed test)
* JKQTPLotter: Examples: Simple line-graph with live-data (speed test)
*
* \ref JKQtPlotterSpeedTest
* \ref JKQTPLotterSpeedTest
*/
#include "speedtestplot.h"
@ -9,10 +9,10 @@
SpeedTestPlot::SpeedTestPlot():
JKQtPlotter(), dx(1.0/double(NDATA)*4.0*M_PI), x0(0)
JKQTPLotter(), dx(1.0/double(NDATA)*4.0*M_PI), x0(0)
{
// 1. optimize JKQtPlotter for speed (by switching off anti-aliasing)
// 1. optimize JKQTPLotter for speed (by switching off anti-aliasing)
get_plotter()->set_useAntiAliasingForGraphs(false);
get_plotter()->set_useAntiAliasingForSystem(false);
get_plotter()->set_useAntiAliasingForText(false);
@ -26,24 +26,24 @@ SpeedTestPlot::SpeedTestPlot():
Y2[i]=cos(x)+static_cast<double>(std::rand())/static_cast<double>(RAND_MAX + 1u)-0.5;
}
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Here the data from the std::array's is not copied, but only the pointer to
// the array is added to the datastore. therefore the datastore does not manage
// the memory, oly uses the data stored in it!
JKQTPdatastore* ds=getDatastore();
JKQTPDatastore* ds=getDatastore();
size_t columnX=ds->addColumn(X.data(), X.size(), "x");
size_t columnY=ds->addColumn(Y.data(), Y.size(), "y");
size_t columnY2=ds->addColumn(Y2.data(), Y2.size(), "y2");
// 4. create two graphs in the plot, which plots the dataset X/Y:
JKQTPxyLineGraph* graph=new JKQTPxyLineGraph(this);
JKQTPXYLineGraph* graph=new JKQTPXYLineGraph(this);
graph->set_xColumn(columnX);
graph->set_yColumn(columnY);
graph->set_title(QObject::tr("live sin() graph"));
graph->set_lineWidth(1);
addGraph(graph);
JKQTPxyLineGraph* graph2=new JKQTPxyLineGraph(this);
JKQTPXYLineGraph* graph2=new JKQTPXYLineGraph(this);
graph2->set_xColumn(columnX);
graph2->set_yColumn(columnY2);
graph2->set_title(QObject::tr("live cos() graph"));

2
examples/simpletest_speed/speedtestplot.h
View File

@ -8,7 +8,7 @@
#define NDATA 500
class SpeedTestPlot: public JKQtPlotter {
class SpeedTestPlot: public JKQTPLotter {
Q_OBJECT
protected:
std::array<double, NDATA> X, Y, Y2;

32
examples/simpletest_stackedbars/README.md
View File

@ -1,5 +1,5 @@
# Example (JKQtPlotter): Simple stacked barchart {#JKQtPlotterStackedBarChart}
This project (see `./examples/simpletest_stackedbars/`) simply creates a JKQtPlotter widget (as a new window) and adds several stacked barcharts.
# Example (JKQTPLotter): Simple stacked barchart {#JKQTPLotterStackedBarChart}
This project (see `./examples/simpletest_stackedbars/`) simply creates a JKQTPLotter widget (as a new window) and adds several stacked barcharts.
The soruce code of the main application is (see [`jkqtplotter_simpletest_stackedbars.cpp`](../simpletest_stackedbars/jkqtplotter_simpletest_stackedbars.cpp):
```.cpp
@ -13,11 +13,11 @@ int main(int argc, char* argv[])
QApplication app(argc, argv);
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
JKQtPlotter plot;
JKQTPLotter plot;
plot.get_plotter()->set_useAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.get_plotter()->set_useAntiAliasingForText(true); // nicer (but slower) text rendering
JKQTPdatastore* ds=plot.getDatastore();
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create data for the charts (taken from https://commons.wikimedia.org/wiki/File:Energiemix_Deutschland.svg)
QVector<double> year, percentage_other, percentage_coaloil, percentage_gas, percentage_nuclear, percentage_green;
@ -29,7 +29,7 @@ int main(int argc, char* argv[])
percentage_green << 3.6 << 4.4 << 6.2 << 9.5 << 15.8 << 28.1;
// 3. make data available to JKQtPlotter by adding it to the internal datastore.
// 3. make data available to JKQTPLotter by adding it to the internal datastore.
// Note: In this step the data is copied (of not specified otherwise)
// the variables cYear, cOther ... will contain the internal column ID of the
// newly created columns with names "year" and "other" ... and the (copied) data
@ -44,31 +44,31 @@ int main(int argc, char* argv[])
// The color of the graphs is set by calling set_fillColor_and_darkenedColor(), which sets the
// fillColor to the given color and makes the outline of the bars (i.e. their "color") a darker
// shade of the given color.
QVector<JKQTPbarVerticalStackableGraph*> graphs;
graphs.push_back(new JKQTPbarVerticalStackableGraph(&plot));
QVector<JKQTPBarVerticalStackableGraph*> graphs;
graphs.push_back(new JKQTPBarVerticalStackableGraph(&plot));
graphs.back()->set_xColumn(cYear);
graphs.back()->set_yColumn(cOther);
graphs.back()->set_title(QObject::tr("other sources"));
graphs.back()->set_fillColor_and_darkenedColor(QColor("red"));
graphs.push_back(new JKQTPbarVerticalStackableGraph(&plot));
graphs.push_back(new JKQTPBarVerticalStackableGraph(&plot));
graphs.back()->set_xColumn(cYear);
graphs.back()->set_yColumn(cCoalOil);
graphs.back()->set_title(QObject::tr("coal & oil"));
graphs.back()->set_fillColor_and_darkenedColor(QColor("darkgrey"));
graphs.back()->stackUpon(graphs[graphs.size()-2]);
graphs.push_back(new JKQTPbarVerticalStackableGraph(&plot));
graphs.push_back(new JKQTPBarVerticalStackableGraph(&plot));
graphs.back()->set_xColumn(cYear);
graphs.back()->set_yColumn(cGas);
graphs.back()->set_title(QObject::tr("natural gas"));
graphs.back()->set_fillColor_and_darkenedColor(QColor("blue"));
graphs.back()->stackUpon(graphs[graphs.size()-2]);
graphs.push_back(new JKQTPbarVerticalStackableGraph(&plot));
graphs.push_back(new JKQTPBarVerticalStackableGraph(&plot));
graphs.back()->set_xColumn(cYear);
graphs.back()->set_yColumn(cNuclear);
graphs.back()->set_title(QObject::tr("nuclear energy"));
graphs.back()->set_fillColor_and_darkenedColor(QColor("gold"));
graphs.back()->stackUpon(graphs[graphs.size()-2]);
graphs.push_back(new JKQTPbarVerticalStackableGraph(&plot));
graphs.push_back(new JKQTPBarVerticalStackableGraph(&plot));
graphs.back()->set_xColumn(cYear);
graphs.back()->set_yColumn(cGreen);
graphs.back()->set_title(QObject::tr("green energy"));
@ -89,8 +89,8 @@ int main(int argc, char* argv[])
// type JKQTBasePlotter, which does the actual plotting.
// So many properties of the plot are only available in this internal
// object, which you can access by plot.get_plotter().
plot.get_plotter()->set_keyPosition(JKQTPkeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPkeyLayoutOneRow);
plot.get_plotter()->set_keyPosition(JKQTPKeyOutsideTopRight);
plot.get_plotter()->set_keyLayout(JKQTPKeyLayoutOneRow);
// 8 autoscale the plot so the graph is contained
plot.zoomToFit();
@ -104,8 +104,8 @@ int main(int argc, char* argv[])
```
The result looks like this:
![JKQTPbarVerticalGraphStacked](https://raw.githubusercontent.com/jkriege2/JKQtPlotter/master/doc/images/JKQTPbarVerticalGraphStacked.png)
![JKQTPBarVerticalGraphStacked](https://raw.githubusercontent.com/jkriege2/JKQTPLotter/master/doc/images/JKQTPBarVerticalGraphStacked.png)
If you use `JKQTPbarHorizontalGraphStacked` instead of `JKQTPbarVerticalStackableGraph`, you'll get a result like this:
![JKQTPbarHorizontalGraphStacked](https://raw.githubusercontent.com/jkriege2/JKQtPlotter/master/doc/images/JKQTPbarHorizontalGraphStacked.png)
If you use `JKQTPBarHorizontalGraphStacked` instead of `JKQTPBarVerticalStackableGraph`, you'll get a result like this:
![JKQTPBarHorizontalGraphStacked](https://raw.githubusercontent.com/jkriege2/JKQTPLotter/master/doc/images/JKQTPBarHorizontalGraphStacked.png)

Some files were not shown because too many files have changed in this diff Show More