Applying Affine Transforms to Axes

[keltonhalbert]

I wanted to see if anyone might have some suggestions on how to approach affine transforms within the ImPlot library. I'd be more than happy to do the legwork and contribute a PR, but I'm still in the beginning stages of learning to navigate the API and learn how things work under the hood.

I am interested in using ImPlot to created a SkewT-LogP diagram, in which the horizontal axis lines/data are skewed by 45 degrees, and the vertical axis is in log10 space. I've written code before that handles this transform by taking an x,y pair and transforms it from data space into the appropriate pixel space. I see some reference to ImPlot having the ability to perform custom transforms on individual axes, but have yet to deduce how to do something like a shearing affine transform (which I believe is what would be needed to make this work).

Any suggestions on a good starting place for this?

[phkehl]

Not implot author here, but I have done several custom plots by (ab)using the available functionality. I don't think implot can do skewed grid lines. But I think you may get the desired effect like this:

• Have implot label the axis and draw the tick marks, but not draw the vertical grid lines.
• Draw the grid lines yourself as a lines plot with grey lines made of points of some distance (say, every 10y), and hide that plot's legend, nobody will know! E.g. the first line from bottom left to top right-ish: -50/1000 ... -48/900 ... -47/800 ... -30/400 .... You can calculate the exact coordinates in x/y space.
• Transform the raw x/y data appropriately to make it show as desired

I think there is also a custom draw API that can plot lines and stuff given plot coordinates. Not sure if that can be useful.

Be sure to check the implot demos window. Lots of inspiration there!

(Completely untested and unverified of course... but maybe it can be done.. :-))

[keltonhalbert]

Thanks for the suggestion, and this honestly isn't a bad idea! It will probably be my fallback option if I run into a complete dead end. It can absolutely be done, but I have yet to surmise what sort of sacrifices this entails for things like data readouts, modifiable lines/data selection, etc...

My gut says that a native implementation would mean being able to leverage some of the more powerful features of ImGui and ImPlot, but perhaps I'm just being paranoid!

[keltonhalbert]

A longshot tag of @epezent, just in case... I expect no work from you at all and would be happy to implement something myself, but being pointed in the right direction or being told I'm wasting my time would definitely be a huge help :). Thanks for this awesome library.

[keltonhalbert]

Spending some time familiarizing myself with the API, it looks like there could be two approaches for this, and I'm not sure which one is more generalizable to other ideas/tasks (such as polar coordinate plotting, for example).

1. ImPlotAxis (implot_internal.h) has a member function that applies the appropriately defined forward transform when calling ImPlotAxis.PlotToPixels (as well as the corresponding inverse transforms when calling PixelsToPlot). However, the main problem is that for the affine transform desired, the custom transform needs to know the Y coordinate of the datum in question, as well as the Y range. One solution would be to overload ImPlotAxis.PlotToPixels to have a definition that takes in both an X and a Y pair, which could get called under specific conditions (i.e. when a new, specific axis flag is defined, perhaps ImPlotScale_Skew).

2. The other option is to handle the skewed transform outside of the axis level and conduct in the main PlotToPixels call (implot.h/implot.cpp). Admittedly, the implications/extensibility of this approach is a little less clear.

3. EDIT: I also spent some time digging around and saw the TransformData pointer that can be used. I still haven't quite reasoned a correct approach using this, since each axis datum needs the value on its orthogonal axis... but it seems like this could be an appropriate avenue too.

It would be easy enough for me to experiment with both solutions in my own fork, brute force something, and then go about the rest of the project... however, if there's an opportunity to generalize something into the API that makes ImPlot more powerful, I'd prefer that approach. I would love to hear other thoughts.

[keltonhalbert]

After some more investigation, it looks like the transformer logic I'm looking for is actually contained in implot_items.cpp