We should be able to mix dimensions

[ghost]

Hi,

For some reasons (one allocation for geometrical multi stage analysis.. ) , one may need to import and allocate geometries with 3d points but apply 2d algorithms on them.

It would be really nice if we could have, eg, a polygon of 3d points being 2d corrected and managing to access all the 2d algorithms.
It is needed when multi staging a geometric structure. Because at some stages, only the 2d points are of importance. No matter the height, we want to be able to cut "from the top view".

That will avoid costly conversions just because the library will stop you from doing otherwise.

The only thing we need to have is a strategy stating that the 3rd point is not used. No more error prone conversions, ad hoc structures to remember the z value and so on.

We could add one stage of complexity stating which axis is which but I guess that is going too far.
I had a look at the code and it is really locked as is, with the logic I complain about.

Maybe someone has an idea to make it happen without rewriting everything?

[awulkiew]

Which algorithms and geometries are you using in 2d and which in 3d?

[ghost]

Sure:
correct, buffer, difference, union and within.

[awulkiew]

Have you tried calling these algorithms with 3d geometries? AFAIR at least buffer, difference and union, maybe also within, just ignore the third coordinate right now so are essentially 2d.

[ghost]

Yes but I get a compilation error about the dimensions which disappears when switching to 2d vectors/polygons/mpolygons. You don't experience the same behaviour?

[awulkiew]

I based my comment on the knowledge about the strategies that are used. It's possible that there are some other parts of the algorithm that are failing to compile.

I'm considering this becasue it's possible that we could think about some kind of working solution, a workaround. But it wouldn't guarantee that such solution will be working in the future.

[ghost]

I can't use them in 3D I have to convert first.
For the 3d I mainly use the rotate, scale and transform.

This is the conversion I would like to avoid, to have for example a rotate with my 3d points I get from another source, then a difference, then a buffer without touching the z points (they remain at the same height anyway) for the 2d algorithms.

[awulkiew]

Technically it should be possible to implement 2D views for all of the types. Types which contain references or pointers to the original 3D geometries and return non-true references instead. I know that some users have done this but I don't know if all of the parts of the library will work properly because this use case is not tested.

So something like this class which only works for points:
https://github.com/boostorg/geometry/blob/develop/include/boost/geometry/views/detail/two_dimensional_view.hpp#L42
but for all geometries that you use.

I'm also not sure if this is doable for mutable geometries and whether it'd require fixing some of the algorithms to work with non-true mutable references properly.

[ghost]

Yes, a view would be perfect

[ghost]

That class may be all I need because the point is the smallest element anyway. Will try this evening.. maybe I miss something

[ghost]

The issue is that I can't tell the algorithms to use that view. Algorithms using polygons are not aware of the fact they should use the view..

Maybe a view type could help, but is more than a workaround here..

[ghost]

Just an update:

I think it could be easier to add a flag "IMPLICITLY_CONVERT_TO_2D" before including the lib.
Then, every time the library sees a nth dimension in a 2d dimension algorithm, it only uses the first two elements.
It is opt-in.

If a new array needs to be created, we read the decltype of the incoming element and reuse that, and still only set the 2d variables, leaving the rest uninitialized (not sure we can do otherwise). Otherwise, if we can modify in place, don't touch the rest.

How hard would it be? The direct way is to bypass the dimensional assertion with that flag to true.

Again, the net result is the speedup from not having to copy values around when we need different dimensions in a chain of logic.