JKQTPlotter

https://jkriege2.github.io/JKQtPlotter/
Admin
JKQTPlotter is an extensive C/C++ library providing a feature-rich 2D scientific plotting framework...
Tokens:2,148,799
Snippets:20,979
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### jkqtpstatAddRobustIRLSRegression Usage Example

Source: https://jkriege2.github.io/JKQtPlotter/group__jkqtptools__math__statistics__adaptors.html

An example showing how to call the function to perform regression on data stored in a datastore.

```cpp
jkqtpstatAddRobustIRLSRegression(plot1->getPlotter(), JKQTPStatRegressionModelType::Exponential, datastore1->begin(colLinX), datastore1->end(colLinX), datastore1->begin(colLinY), datastore1->end(colLinY));
```

--------------------------------

### Build and Install via CMake

Source: https://jkriege2.github.io/JKQtPlotter/page_buildinstructions__c_m_a_k_e.html

Run the build process and install the target using the generated build files.

```bash
$ cmake --build . --config "Debug" --target install
```

--------------------------------

### Install JKQTPlotter binaries using CMake

Source: https://jkriege2.github.io/JKQtPlotter/page_buildinstructions__c_m_a_k_e.html

Commands to install built binaries and headers into the directory specified by CMAKE_INSTALL_PREFIX.

```bash
$ cmake --build . --config "Debug" --target install
```

```bash
$ cmake --install . --config "Debug"
```

--------------------------------

### JKQTPMathImage C++ Example

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_image_plot_no_datastore.html

This example shows the main application code for creating a JKQTPlotter widget, generating Airy disk data in a row-major C-array, and rendering it using JKQTPMathImage.

```cpp
#include <QApplication>
#include <cmath>
#include "jkqtplotter/jkqtplotter.h"
#include "jkqtplotter/graphs/jkqtpimage.h"
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
JKQTPlotter plot;
// 1. create a plotter window and get a pointer to the internal datastore (for convenience)
plot.getPlotter()->setUseAntiAliasingForGraphs(true); // nicer (but slower) plotting
plot.getPlotter()->setUseAntiAliasingForSystem(true); // nicer (but slower) plotting
plot.getPlotter()->setUseAntiAliasingForText(true); // nicer (but slower) text rendering
// 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]
const int NY=100; // image dimension in x-direction [pixels]
const double dx=1e-2; // size of a pixel in x-direction [micrometers]
const double dy=1e-2; // size of a pixel in x-direction [micrometers]
const double w=static_cast<double>(NX)*dx;
const double h=static_cast<double>(NY)*dy;
double airydisk[NX*NY]; // row-major image
// 2.1 Parameters for airy disk plot (see https://en.wikipedia.org/wiki/Airy_disk)
double NA=1.1; // numerical aperture of lens
double wavelength=488e-3; // wavelength of the light [micrometers]
// 2.2 calculate image of airy disk in a row-major array
double x, y=-h/2.0;
for (int iy=0; iy<NY; iy++ ) {
x=-w/2.0;
for (int ix=0; ix<NX; ix++ ) {
const double r=sqrt(x*x+y*y);
const double v=2.0*M_PI*NA*r/wavelength;
airydisk[iy*NX+ix] = pow(2.0*j1(v)/v, 2);
x+=dx;
}
y+=dy;
}
// 3. create a graph (JKQTPMathImage) with referencing the data created above as data
// The data is color-coded with the color-palette JKQTPMathImageBLUEYELLOW
// the converted range of data is determined automatically because setAutoImageRange(true)
JKQTPMathImage* graph=new JKQTPMathImage(&plot);
graph->setTitle("");
// set array as datasource, with correct size NX*NY and datatype JKQTPMathImageBase::DataType::DoubleArray
graph->setData(airydisk, NX, NY, JKQTPMathImageBase::DataType::DoubleArray);
// where does the image start in the plot, given in plot-axis-coordinates (bottom-left corner)
graph->setX(-w/2.0);
graph->setY(-h/2.0);
// width and height of the image in plot-axis-coordinates
graph->setWidth(w);
graph->setHeight(h);
// color-map is "BLUEYELLOW"
graph->setColorPalette(JKQTPMathImageBLUEYELLOW);
// get coordinate axis of color-bar and set its label
graph->getColorBarRightAxis()->setAxisLabel("light intensity [A.U.]");
// determine min/max of data automatically and use it to set the range of the color-scale
graph->setAutoImageRange(true);
// you can set the color-scale range manually by using:
// graph->setAutoImageRange(false);
// graph->setImageMin(0);
// graph->setImageMax(10);
// 4. add the graphs to the plot, so it is actually displayed
plot.addGraph(graph);
// 5. set axis labels
plot.getXAxis()->setAxisLabel("x [{\\mu}m]");
plot.getYAxis()->setAxisLabel("y [{\\mu}m]");
// 6. fix axis and plot aspect ratio to 1
plot.getPlotter()->setMaintainAspectRatio(true);
plot.getPlotter()->setMaintainAxisAspectRatio(true);
// 7. autoscale the plot so the graph is contained
plot.zoomToFit();
// show plotter and make it a decent size
plot.show();
plot.resize(600,600);
plot.setWindowTitle("JKQTPMathImage");
```

--------------------------------

### jkqtpstatAddHKDE1DAutoranged Usage Example

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpstatisticsadaptors_8h_source.html

Example usage of the jkqtpstatAddHKDE1DAutoranged function to add a KDE graph to a plotter.

```cpp
jkqtpstatAddHKDE1DAutoranged(plot1->getPlotter(), datastore1->begin(randomdatacol1), datastore1->end(randomdatacol1), 200);
```

--------------------------------

### JKQTMathText Simple Application Example

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_math_text_simple_example.html

This example demonstrates creating a QLabel that displays a rendered LaTeX equation, specifically the time-dependent Schrödinger equation, using the JKQTMathText class.

```cpp
#include <QApplication>
#include <QLabel>
#include <QPixmap>
#include "jkqtmathtext/jkqtmathtextlabel.h"
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
// we use a simple label to display the math text
QLabel lab;
// 1. we will paint into a QPixmap
QPixmap pix(600,400);
pix.fill(QColor("white"));
QPainter painter;
// 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;
mathText.useXITS();
mathText.setFontSize(20);
// 3. now we parse some LaTeX code (the Schroedinger's equation), so
// we can draw it onto the QPixmap in the next step
mathText.parse("$\\left[-\\frac{\\hbar^2}{2m}\\frac{\\partial^2}{\\partial x^2}+V(x)\\right]\\Psi(x)=\\mathrm{i}\\hbar\\frac{\\partial}{\\partial t}\\Psi(x)$");
// 3. here we do the painting
painter.begin(&pix);
mathText.draw(painter, Qt::AlignCenter, QRectF(0,0,pix.width(), pix.height()), false);
painter.end();
// now we display and resize the label as a window
lab.setPixmap(pix);
lab.show();
lab.resize(600,400);
return app.exec();
}
```

--------------------------------

### Add Regression Line to Plot

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpstatisticsadaptors_8h_source.html

Example showing how to add a regression line to a JKQTPXYLineGraph using the jkqtpstatRegression function.

```cpp
JKQTPXYLineGraph* graphD;
plot1->addGraph(graphD=new JKQTPXYLineGraph(plot1));
graphD->setXYColumns(colLinX, colLinY);
jkqtpstatRegression(graphD, JKQTPStatRegressionModelType::Exponential);
```

--------------------------------

### jkqtpstatAddHKDE1D (Range-based)

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpstatisticsadaptors_8h_source.html

Calculates a 1D Kernel Density Estimation from a dataset defined by iterators and adds it to a plotter using a range defined by start, delta, and end values.

```APIDOC
## jkqtpstatAddHKDE1D(plotter, first, last, binXLeft, binXDelta, binXRight, kernel, bandwidth, cummulative, KDEcolumnBaseName)

### Description
Calculates a 1D KDE from the data range [first, last) and evaluates it at positions defined by binXLeft, binXDelta, and binXRight. The result is added as a new JKQTPXYLineGraph to the provided plotter.

### Parameters
- **plotter** (JKQTBasePlotter*) - Required - The plotter to which to add the resulting graph.
- **first** (InputIt) - Required - Iterator pointing to the first item in the dataset.
- **last** (InputIt) - Required - Iterator pointing behind the last item in the dataset.
- **binXLeft** (double) - Required - First x-position for evaluation.
- **binXDelta** (double) - Required - Distance between two x-positions.
- **binXRight** (double) - Required - Last x-position for evaluation.
- **kernel** (std::function<double(double)>) - Optional - The kernel function to use (default: jkqtpstatKernel1DGaussian).
- **bandwidth** (double) - Optional - Bandwidth used for the KDE (default: 1.0).
- **cummulative** (bool) - Optional - If true, a cumulative KDE is calculated (default: false).
- **KDEcolumnBaseName** (QString) - Optional - Base name for the generated data columns (default: "KDE").

### Returns
- **JKQTPXYLineGraph*** - A pointer to the graph object displaying the KDE data.
```

--------------------------------

### JKQTFastPlotter::getYZeroTick

Source: https://jkriege2.github.io/JKQtPlotter/jkqtfastplotter_8h_source.html

Gets the y-axis label position from which axis label plotting starts.

```cpp
double getYZeroTick() const
```

--------------------------------

### Build Example via CLI

Source: https://jkriege2.github.io/JKQtPlotter/page_buildinstructions__c_m_a_k_e.html

Commands to create a build directory and configure the project using CMake.

```bash
$ mkdir build
$ cd build
$ cmake .. -G "<GENERATOR>" "-DCMAKE_PREFIX_PATH=<path_to_your_qt_sources>;<JKQTPLOTTER_INSTALL_DIR>"
```

--------------------------------

### JKQTPlotterUpdateGuard Usage

Source: https://jkriege2.github.io/JKQtPlotter/jkqtplotter_8h_source.html

Example of using the RAII guard class to disable replotting during setup.

```cpp
{
JKQTPlotterUpdateGuard guard(plotter);
```

--------------------------------

### Basic JKQTMathText Usage Example

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_math_text.html

Demonstrates initializing a JKQTMathText object, configuring font properties, parsing a LaTeX string, and rendering the output into a QPixmap.

```cpp
// create a JKQTMathText object.
JKQTMathText mathText;
// configure its properties to influence the rendering (e.g. fonts to use, font size, ...)
mathText.useXITS();
mathText.setFontSize(20);
// parse some LaTeX code (the Schroedinger's equation)
mathText.parse("$\\left[-\\frac{\\hbar^2}{2m}\\frac{\\partial^2}{\\partial x^2}+V(x)\\right]\\Psi(x)=\\mathrm{i}\\hbar\\frac{\\partial}{\\partial t}\\Psi(x)$");
// draw the result into a QPixmap
QPixmap result=mathText.drawIntoPixmap();
```

--------------------------------

### Setup Plotter and Simulate Financial Data

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_financial_chart_example.html

Initializes a JKQTPlotter, creates data columns in the datastore, and populates them with simulated stock price data using a random walk.

```cpp
// 1. setup a plotter window and get a pointer to the internal datastore (for convenience)
JKQTPlotter plot;
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create 5 datacolumns with length Ndays entries in the datastore
// these will later hold the time-step and simulated market data of two stocks
const size_t NDays=31;
const size_t columnT=ds->addColumn("time");
const size_t columnO1=ds->addColumn("open(stock 1)");
const size_t columnC1=ds->addColumn("close(stock 1)");
const size_t columnL1=ds->addColumn("low(stock 1)");
const size_t columnH1=ds->addColumn("high(stock 1)");
const size_t columnO2=ds->addColumn("open(stock 2)");
const size_t columnC2=ds->addColumn("close(stock 2)");
const size_t columnL2=ds->addColumn("low(stock 2)");
const size_t columnH2=ds->addColumn("high(stock 2)");
const QDate t0(2024,1,8); // start date
// 3. now we simulate stock market data with a simple random walk
// with a few steps per day that are summmarized into the four
// properties Open,Close,Low,High for each day
double price1=30; // start price of stock 1
double price2=25; // start price of stock 2
const size_t stepsPerDay=20;
std::random_device rd; // random number generators:
std::mt19937 gen{rd()};
gen.seed(12352);
std::normal_distribution<double> dist1(0.001, 0.6);
std::normal_distribution<double> dist2(-0.0001, 0.4);
for (size_t t=0; t<NDays; t+=1) {// iterate over all simulated days (we don't care for weekends)
// step time from noon to noon in steps of days
const QDate d=t0.addDays(t);
ds->appendToColumn(columnT, QDateTime(d,QTime(12,0,0)).toMSecsSinceEpoch());
// the open-Value is the start-price of each day:
ds->appendToColumn(columnO1, price1);
ds->appendToColumn(columnO2, price2);
// now we iterate the market over the day
double L1=price1, L2=price2, H1=price1, H2=price2;
for (size_t i=0; i<stepsPerDay; i++) { // iterate over week days (Mon-Fri)
// prices are calculated from a sinple random walk (the while-loops ensure that we have positive prices only
double np;
while ((np=price1+dist1(gen))<=0.0); price1=np;
while ((np=price2+dist2(gen))<=0.0); price2=np;
// now we track the highest/lowest prices
L1=qMin(L1, price1);
L2=qMin(L2, price2);
H1=qMax(H1, price1);
H2=qMax(H2, price2);
}
// the close-Value is the final price of each day:
ds->appendToColumn(columnC1, price1);
ds->appendToColumn(columnC2, price2);
// finally we just have to add the highest and lowest prices of each day:
ds->appendToColumn(columnL1, L1);
ds->appendToColumn(columnL2, L2);
ds->appendToColumn(columnH1, H1);
ds->appendToColumn(columnH2, H2);
}
```

--------------------------------

### JKQTPGeoPie Angle Accessors

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpgeoshapes_8h_source.html

Methods to get and set the start and stop angles for the pie element.

```APIDOC
void setAngleStart(double __value);
double getAngleStart() const;
void setAngleStop(double __value);
double getAngleStop() const;
```

--------------------------------

### Initialize Datastore and Columns

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_wiggle_plots.html

Obtain a pointer to the JKQTPDatastore and add columns for time and position data.

```cpp
// 1. get a pointer to the internal datastore (for convenience)
JKQTPDatastore* ds=plot.getDatastore();
// 2. now we create 2 datacolumns with length 1000 (NSteps) entries in the datastore
// these will later hold the time-step and position of a random walker
const size_t NSteps=400;
const size_t columnT=ds->addLinearColumn(NSteps, 0, NSteps-1, "time");
const size_t columnX=ds->addColumn(NSteps, "position");
```

--------------------------------

### Manual Boxplot Element Setup

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_basic_j_k_q_t_p_datastore_statistics.html

Example of manually calculating 5-number statistics and configuring a JKQTPBoxplotVerticalElement.

```cpp
JKQTPStat5NumberStatistics stat=jkqtpstat5NumberStatistics(data.begin(), data.end(), 0.25, .5);
JKQTPBoxplotVerticalElement* res=new JKQTPBoxplotVerticalElement(plotter);
res->setMin(stat.minimum);
res->setMax(stat.maximum);
res->setMedian(stat.median);
res->setMean(jkqtpstatAverage(first, last));
res->setPercentile25(stat.quantile1);
res->setPercentile75(stat.quantile2);
res->setMedianConfidenceIntervalWidth(stat.IQRSignificanceEstimate());
res->setDrawMean(true);
res->setDrawNotch(true);
res->setDrawMedian(true);
res->setDrawMinMax(true);
res->setDrawBox(true);
res->setPos(boxposX);
plotter->addGraph(res);
```

--------------------------------

### Integrate library as subdirs in QMake

Source: https://jkriege2.github.io/JKQtPlotter/page_buildinstructions__q_m_a_k_e.html

Example of a .PRO file that integrates the static library as a subdirectory.

```qmake
TEMPLATE = subdirs
# the (static library version) of JKQTPlotter
jkqtplotterlib_static.file = ../../qmake/staticlib/jkqtplotterlib/jkqtplotterlib.pro
```

--------------------------------

### Using JKQTPlotterUpdateGuard for RAII Plot Updates

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_plotter_update_guard.html

This example demonstrates how to use the guard to encapsulate plot setup. Replotting is disabled upon construction and automatically reenabled with a redraw call when the block ends.

```cpp
{
JKQTPlotterUpdateGuard guard(plotter);
// set up plot here, e.g.
plotter->setX();
plotter->setY(); ...
} // Block ends and immediate plot updates are reenabled. Also JKQTPlotter::redrawPlot() is called.
```

--------------------------------

### Initialize and Display Plotter

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_image_plot_r_g_b_c_img.html

Basic setup for initializing the plotter, setting window dimensions, and executing the application loop.

```cpp
plot.zoomToFit();
// show plotter and make it a decent size
plot.show();
plot.resize(800,600);
plot.setWindowTitle("JKQTPColumnRGBMathImage");
return app.exec();
}
```

--------------------------------

### start()

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_p_high_res_timer.html

Starts or resets the timer.

```APIDOC
## void start()

### Description
Starts the timer by setting the reference time to zero.
```

--------------------------------

### saveAsCSV Output Example

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpbaseplotter_8h_source.html

Example output format for the saveAsCSV method.

```text
# x, y
0, 0
0.251327, 0.24869
0.502655, 0.481754
...
```

--------------------------------

### Initialize QPixmap for Rendering

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_math_text_render_cmd_line_tool.html

Create a dummy QPixmap to initialize the QPainter required for calculating the rendering size.

```cpp
QPixmap pix(10,10);
```

--------------------------------

### Install Target in CMake

Source: https://jkriege2.github.io/JKQtPlotter/page_buildinstructions__c_m_a_k_e.html

Configure the installation of your project's runtime target.

```cmake
install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
```

--------------------------------

### Initialize Plotter and Datastore

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotterparamscatter_custom_symbol.html

Create a plotter window and prepare the datastore by adding columns for x, y, and symbol data.

```cpp
JKQTPlotter plot;
JKQTPDatastore* ds=plot.getDatastore();
size_t columnX=ds->addColumn("x");
auto colXInserter=ds->backInserter(columnX);
size_t columnY=ds->addColumn("y");
auto colYInserter=ds->backInserter(columnY);
size_t columnS=ds->addColumn("sym");
auto colSInserter=ds->backInserter(columnS);
```

--------------------------------

### Main application entry point for FormWithJKQTPlotter

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_qt_creator.html

The main application file instantiates the FormWithJKQTPlotter class, displays the form, and sets its initial size.

```cpp
#include <QApplication>
#include "formwithjkqtplotter.h"
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
FormWithJKQTPlotter plot;
plot.show();
plot.resize(600,400);
return app.exec();
}
```

--------------------------------

### Context Menu Modification Example

Source: https://jkriege2.github.io/JKQtPlotter/jkqtplotter_8h_source.html

Example of how to modify the context menu within the contextMenuOpened signal.

```cpp
contextMenu->addSeparator();
QAction* act=contextMenu->addMenu(QString("contextMenuOpened(x=%1, y=%2)").arg(x).arg(y))->addAction("user-added action");
connect(act, &QAction::triggered, [x,y]() { QMessageBox::warning(nullptr, tr("Plot Context Menu"),
tr("Context Menu was opened at x/y=%1/%2!").arg(x).arg(y),
QMessageBox::Ok,
QMessageBox::Ok); });
```

--------------------------------

### JKQTPMathParser Usage Example

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_p_math_parser.html

Demonstrates how to instantiate the parser, parse various expression types (numeric, boolean, string), and evaluate the resulting nodes.

```cpp
try {
JKQTPMathParser mp; // instanciate
jkmpNode* n;
jkmpResult r;
// parse some numeric expression
n=mp.parse("pi^2+4*sin(65*pi/exp(3.45))");
r=n->evaluate();
cout<<r.num<<endl;
//delete n;
// parse some boolean expression
n=mp.parse("true==false");
r=n->evaluate();
if (r.type==jkmpBool) {
if (r.boolean) cout<<"true";
else cout<<"false";
}
if (r.type==jkmpDouble) cout<<r.num<<endl;
if (r.type==jkmpString) cout<<r.str<<endl;
delete n;
// parse some string expression
n=mp.parse("var1='false'; var1+'true'");
r=n->evaluate();
if (r.type==jkmpString) cout<<r.str<<endl;
delete n;
} catch(std::exception& E) {
cout<<"ERROR!!!\n "<<E.what()<<endl<<endl;
}
```

--------------------------------

### Example output for saveAsMatlab

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_plotter.html

Example output format for a Matlab script generated from plot data.

```text
% data from columne 1 ('x')
x = [ 0 0.251327 0.502655 ... ];
% data from columne 2 ('y')
y = [ 0 0.24869 0.481754 ... ]; 
```

--------------------------------

### Create GUI and Plot with User-Selectable Palette

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_image_plot_user_palette.html

This example initializes a QWidget containing a plotter and a combobox for palette selection, generates Airy disk data, and connects the combobox to the plot's color palette.

```cpp
// 1. create a window containing a plotter and a combobox to select the color palette
// ... and get a pointer to the internal datastore (for convenience)
QWidget win;
QVBoxLayout* lay=new QVBoxLayout();
win.setLayout(lay);
JKQTPMathImageColorPaletteComboBox* cmbPalette=new JKQTPMathImageColorPaletteComboBox(&win);
lay->addWidget(cmbPalette);
JKQTPlotter* plot=new JKQTPlotter(&win);
lay->addWidget(plot);
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]
const int NY=NX; // image dimension in x-direction [pixels]
const double dx=0.6e-2; // size of a pixel in x-direction [micrometers]
const double dy=0.6e-2; // size of a pixel in x-direction [micrometers]
// 2.1 Parameters for airy disk plot (see https://en.wikipedia.org/wiki/Airy_disk)
double NA=1.1; // numerical aperture of lens
double wavelength=488e-3; // wavelength of the light [micrometers]
// 2.2 calculate image of airy disk in a row-major array and immediately store the values
// in a new image column cAiryDisk
size_t cAiryDisk=ds->addCalculatedImageColumn(NX, NY, [&](size_t ix, size_t iy)->double {
double x=static_cast<double>(static_cast<int>(ix)-NX/2)*dx;
double y=static_cast<double>(static_cast<int>(iy)-NY/2)*dy;
const double r=sqrt(x*x+y*y);
const double v=2.0*M_PI*NA*r/wavelength;
if (ix==NX/2 && iy==NY/2) return 1.0;
else return pow(2.0*j1(v)/v, 2);
}, "imagedata");
// 3. create a graph (JKQTPColumnMathImage) with the column created above as data
// The data is color-coded with the color-palette JKQTPMathImageMATLAB
// the converted range of data is determined automatically because setAutoImageRange(true)
JKQTPColumnMathImage* graph=new JKQTPColumnMathImage(plot);
graph->setTitle("default MATLAB palette");
// set the image column with the data
graph->setImageColumn(cAiryDisk);
// where does the image start in the plot, given in plot-axis-coordinates (bottom-left corner)
graph->setX(0);
graph->setY(0);
// width and height of the image in plot-axis-coordinates
graph->setWidth(1);
graph->setHeight(1);
// color-map is taken from cmbPalette
plot->connect(cmbPalette, &JKQTPMathImageColorPaletteComboBox::currentPaletteChanged,[&](JKQTPMathImageColorPalette p) { graph->setColorPalette(p); plot->redrawPlot(); });
cmbPalette->setCurrentColorPalette(graph->getPalette());
// 4. add the graphs to the plot, so it is actually displayed
plot->addGraph(graph);
// 5. fix axis and plot aspect ratio to 1
plot->getPlotter()->setMaintainAspectRatio(true);
plot->getPlotter()->setMaintainAxisAspectRatio(true);
// 6. autoscale the plot so the graph is contained
plot->zoomToFit();
// 8. show plotter and make it a decent size
win.show();
win.resize(500,550);
win.setWindowTitle("JKQTPColumnMathImage, User Palettes");
```

--------------------------------

### addCopiedColumn (Pointer with Stride and Start)

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpdatastorage_8h_source.html

Copies an external array into the datastore with specific stride and start parameters.

```APIDOC
## size_t addCopiedColumn(const T* data, size_t rows, size_t stride, int start, const QString& name)

### Description
Copies elements from an external array using a stride and starting offset.

### Parameters
- **data** (T*) - Required - Pointer to the data.
- **rows** (size_t) - Required - Number of items to copy.
- **stride** (size_t) - Required - Step size.
- **start** (int) - Required - Starting index.
- **name** (QString) - Required - Name for the column.
```

--------------------------------

### saveAsGerExcelCSV Output Example

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpbaseplotter_8h_source.html

Example output format for the saveAsGerExcelCSV method, which uses a comma as a decimal separator.

```text
# x, y
0, 0
0,251327; 0,24869
0,502655; 0,481754
...
```

--------------------------------

### Load a Style from Qt Resources

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_styling.html

Demonstrates how to load a predefined style from the Qt resource system and apply it to the system default style settings.

```cpp
QSettings plotSettings(":/JKQTPlotter/styles/blackandwhite.ini", QSettings::IniFormat);;
JKQTPGetSystemDefaultStyle().loadSettings(plotSettings);
JKQTPGetSystemDefaultBaseStyle().loadSettings(plotSettings);
```

--------------------------------

### JKQTPBuildColorPaletteLUTLinSegments Segment Table Example

Source: https://jkriege2.github.io/JKQtPlotter/group__jkqtplotter__imagelots__tools___l_u_t_s.html

Example of a table defining linear segments for color palette construction.

```text
  i    position    colval1            colval2
 ~~~  ~~~~~~~~~~  ~~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~~~
  0       0.0           0 (IGNORED)        0
  1       0.5         100                100
  2       0.8         255                255
  3       1.0         255                255 (IGNORED)
```

--------------------------------

### Calculate Weighted Regression Example

Source: https://jkriege2.github.io/JKQtPlotter/group__jkqtptools__math__statistics__adaptors.html

Example usage of jkqtpstatAddWeightedRegression to perform an exponential regression on data stored in a datastore.

```cpp
double coeffA=0, coeffB=0;
jkqtpstatAddWeightedRegression(plotter, JKQTPStatRegressionModelType::Exponential,
datastore1->begin(colWLinX), datastore1->end(colWLinX),
datastore1->begin(colWLinY), datastore1->end(colWLinY),
datastore1->begin(colWLinE), datastore1->end(colWLinE),
coeffA, coeffB, false, false,
&jkqtp_inversePropSaveDefault<double>);
```

--------------------------------

### Load Settings from INI File

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_plotter_styling.html

Shows how to load plot and plotter styles from a QSettings INI file at startup.

```cpp
QSettings plotSettings("JKQTPlotterSettings.ini", QSettings::IniFormat);;
JKQTPGetSystemDefaultStyle().loadSettings(plotSettings);
JKQTPGetSystemDefaultBaseStyle().loadSettings(plotSettings);
```

--------------------------------

### Hash Combine Example

Source: https://jkriege2.github.io/JKQtPlotter/jkqtpmathtools_8h_source.html

Demonstrates how to build a hash value from multiple values using jkqtp_hash_combine.

```cpp
std::size_t seed=0;
jkqtp_hash_combine(seed, valA);
jkqtp_hash_combine(seed, valB);
//...
```

--------------------------------

### Example output for saveAsGerExcelCSV

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_plotter.html

Example output format for a Semicolon Separated Values file generated for German Excel.

```text
# x, y
0, 0
0,251327; 0,24869
0,502655; 0,481754
... 
```

--------------------------------

### CMakeLists.txt for JKQTPlotter FetchContent

Source: https://jkriege2.github.io/JKQtPlotter/_j_k_q_t_c_make_fetch_content_example.html

A basic CMake configuration file demonstrating the minimum requirements and project setup for using JKQTPlotter.

```cmake
# set minimum required CMake-Version
cmake_minimum_required(VERSION 3.23)
# set Project name
project(simpletest_cmake LANGUAGES CXX)
# some basic configurations
set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
```

--------------------------------

### copyDataMatlab Example Output

Source: https://jkriege2.github.io/JKQtPlotter/class_j_k_q_t_plotter.html

Example output format for the copyDataMatlab method, which exports plot data as a Matlab script.

```matlab
% data from columne 1 ('x')
x = [ 0 0.251327 0.502655 ... ];
% data from columne 2 ('y')
y = [ 0 0.24869 0.481754 ... ];
```
Tokens:
Raw