plotting widget like QCustomPlot

[DaMilyutin]

I've used QCustomPlot (for Qt) in one of my projects.
https://www.qcustomplot.com/index.php/introduction

It allows to have different kinds of plots, pan/zoom, customize plot (axes, labes, ticks, linestyle, markers, etc.).
And it works with big arrays well.

I've seen discussion about usage of plotting (#381).
I've written my comment there. But as I understand there was no activity lately.
So I create this one.
And to my understanding QCustomPlot has more than "basic" functionality.

So question is. Is there any chance to have something similar?
Is it possible to implement this with plotting?

Another question is what data structure does sixtyfps use for passing arrays around with C++?
It is crucial to send data from code to plot widget. That's why I'm asking.
Ex. QCustomPlot uses QVector.
Upd: To my last question. Just watching tutorial and see sixtyfps::VectorModel<T>. Will it do the job?

[tronical]

Yes, sixtyfps::VectorModel<T> will be used for arrays/models.

[tronical]

For Rust we have a plotter example that integrates with a plotting crate - using API to construct an image from a pixel buffer. The same API could be added to C++’s sixtyfps::Image.

[DaMilyutin]

I'd also add some ideas to look into.
https://www.aosabook.org/en/matplotlib.html

Probably plotting widget may be side-project for sixtyfps.

[tronical]

Thanks for the pointer to matplotlib.

Generally speaking, we would like to enable developers to use third-party plotting libraries and for software renderered plots that in particular needs that image API I mentioned. I thought there was already a ticket, but I think I'm mistaken, so I've filed #616.

[DaMilyutin]

@ogoffart, @tronical I have intent to write simple plot widget example for my purposes.
I have some questions on this topic.

In most applications I have to use double for plotting. Can I somehow pass arrays of double or arrays of structures containing double between .60 and C++? Between Rust and C++?

Since plotters library is written in Rust I'd want to compile all plotting functionality (callbacks which render image) in Rust.
But I'd want to export plotting widget interface for C++. Can I do this in one CMakeLists?
Or maybe you can advise better way to do this?

[DaMilyutin]

I'm going to apply sixty FPS to pet/helper project which will probably use many already working C++ code.

I'd want to mix plotters and this code. I'm not going to use Python as it is heavyweight and I want lightweight exe-only application.

Second thoughts... I probably could wrap C++ code in Rust and then do stuff with plotters.
However, I have no Idea how I pass data to widget. if there are no doubles.
I'd like to pass {X,Y} double points to widget and then widget will plot zoomed area using plotters.

That is unfortunately sixtyfps can't use double. Can it do some type erasure then? Or some hacking?
With this I could pass some data around from C++ to Rust and use widget just to store data.

Example I don't really like is, storing string to file with data (ex. SQLite) and some identifiers to tables, columns, etc.
But this will have latency I do not want.

Maybe callbacks will do the job if I could return something or assign values to &mut array of double(f64) somehow?
Or some global structures/singletones which are both visible in C++ Rust?

I'm not so sure. Maybe, you advise some method to pass data around.

One more (a little offtop) question which bugs me, My cpp example works only when I copy sixtyfps.dll to exe folder.
(Actually, this sounds like bug to me which I've worked around.)
Can I compile lib into exe somehow to get single working exe?

[tronical]

Hmm, I think that I may not have the full picture yet, but I think we're getting there. When you wrote "working C++ code", what does the C++ code do / what is the role of C++?

Generally, what I suggest for the moment is to use an existing plotting library in Rust (like plotters), feed your data into it, generate an image and integrate that into into your .60 component. This means that for now the application needs to be also written in Rust. Via the cpp crate it you could embed C++ code though.

Regarding the dll: This is how Windows works, the DLL needs to be in the path :-/. What I typically do is to put \path\to\build\directory\api\sixtyfps-cpp\ into %PATH%, then the copying isn't needed. Newer CMake versions have convenience that, alternatively, allows for the automation of copying of dependening dlls into the directory where your target .exe is located: https://cmake.org/cmake/help/git-stage/manual/cmake-generator-expressions.7.html#genex:TARGET_RUNTIME_DLLS . Maybe that helps?

[ogoffart]

If you want to stay with C++, You can use any C++ plotting library that somehow generate images, and display these images in SixtyFPS. Then you don't need to use rust at all.

[DaMilyutin]

Regarding the dll: This is how Windows works, the DLL needs to be in the path :-/. What I typically do is to put \path\to\build\directory\api\sixtyfps-cpp\ into %PATH%, then the copying isn't needed. Newer CMake versions have convenience that, alternatively, allows for the automation of copying of dependening dlls into the directory where your target .exe is located: https://cmake.org/cmake/help/git-stage/manual/cmake-generator-expressions.7.html#genex:TARGET_RUNTIME_DLLS . Maybe that helps?

I mean can we link sixtyfps statically in exe file? Like in C++ we can link static library into executable with header files and lib.
So DLL is not required.

[tronical]

Yes, in theory it's possible to do static linking. At the moment that is not implemented. It requires a bit of work in order to propagate the third-party dependencies correctly - especially with Qt.

[DaMilyutin]

Hello @ogoffart, @tronical, I've just occasionally bumped into
interpreter::Value

So can I actually pass some doubles and pointers to doubles in sixtyfps and back with this Value?
Value is similar to C++ std::any as I can guess. And this is what I needed.

My idea on plotting widget is to store arrays of doubles X[N], Y[N] and some properties per each curve.
Then I pass this to plotters and do some maths and rendering picture to buffer. Image is displayed in sixtyfps.

What I wanted as extra is reading data X[N],Y[N] from C++ code and storing them in widget.
And seems to me it is actually possible with Value. Am I right?
Please, can you give me some hints how can I do this?

Extra idea,
Maybe, if .60 markdown language does not support Value directly you could consider to support it for passing type-erased data around?

[ogoffart]

You can store the double as an array of Value in a interpreter::Value, yet.
interpreter::Value is more like a std::variant with pre-defined types that an std::any.

[DaMilyutin]

Is there a way to store array of doubles in one value? Or ex. std::vector<double>?
Or maybe user struct{ double* values; int size; } ?
I'm concerned that big sized array of doubles will require almost twice more memory when each double stored in Value separately.

[ogoffart]

That would be possible with something like

struct ArrayOfDouble : sixtyfps::Model<float> {
     double* values; int size;
     // ... implementation of sixtyfps::Model goes here.
};

Then in .60 you can assign that to a property <[float]>