Sth I encountered while working on #337: when using datashader, transformations of points and shapes need to be applied before rendering. I think the flipping of the y-axis leads to an inconsistency when applying Affine transformations (might also be for other transformations, that's just where I noticed it).
Say we are applying an affine transformation to our blobs polygons, namely a rotation 90° to the right (around 0/0), and then render:
from spatialdata.transformations import Affine
from spatialdata.datasets import blobs
from spatialdata.transformations._utils import _set_transformations
rotation = Affine(
[
[0, -1, 0],
[1, 0, 0],
[0, 0, 1],
],
input_axes=("x", "y"),
output_axes=("x", "y"),
)
blob = blobs()
_set_transformations(blob["blobs_polygons"], {"global": rotation})
blob.pl.render_shapes("blobs_polygons", method="matplotlib", outline_alpha=1.0).pl.show()If I get this correctly, a point can be transformed by performing matrix multiplication with the affine matrix of the transformation, such as np.array([1, 1]) @ np.array([[0, -1], [1, 0]]) which gives [1, -1], therefore rotation by 90° to the right around the point 0/0.
The original image of the blobs polygons without any transformation looks like this:
And the code above (using matplotlib) gives us
Which looks like a rotation to the right around 0/0. However, my question here is that when you flip the y-axis, wouldn't any rotation to the right look like a rotation to the left instead?
My current solution for datashader simply performs the matrix multiplication of all points of the polygons with the transformation matrix. This is all in a "normal", not flipped coordinate system, so when you flip the axes, you would get something like this:
(Looks like a rotation to the left, because the y-axis is flipped).
@LucaMarconato since you're the master of transformations, could you have a look and tell me what you think about it? Is this intended behavior since it is more intuitive for the user?
If yes: do you know an easy way how to get the affine matrix to do the transformation in the y-axis-not-flipped scenario (especially thinking about sequences of transformations...)
If no: the matplotlib version would be "incorrect" and I think get_extent() as well, since it gives us exactly the values that we see in the matplotlib plot (and that's a problem, because in the very end of basic.show(), the axis limits are adapted according to the extent - I only got the datashader plot above by manually overwriting the extent).
(cc: @timtreis)
Sth I encountered while working on #337: when using datashader, transformations of points and shapes need to be applied before rendering. I think the flipping of the y-axis leads to an inconsistency when applying
Affinetransformations (might also be for other transformations, that's just where I noticed it).Say we are applying an affine transformation to our
blobspolygons, namely a rotation 90° to the right (around 0/0), and then render:If I get this correctly, a point can be transformed by performing matrix multiplication with the affine matrix of the transformation, such as
np.array([1, 1]) @ np.array([[0, -1], [1, 0]])which gives[1, -1], therefore rotation by 90° to the right around the point 0/0.The original image of the blobs polygons without any transformation looks like this:
And the code above (using matplotlib) gives us
Which looks like a rotation to the right around 0/0. However, my question here is that when you flip the y-axis, wouldn't any rotation to the right look like a rotation to the left instead?
My current solution for datashader simply performs the matrix multiplication of all points of the polygons with the transformation matrix. This is all in a "normal", not flipped coordinate system, so when you flip the axes, you would get something like this:
(Looks like a rotation to the left, because the y-axis is flipped).
@LucaMarconato since you're the master of transformations, could you have a look and tell me what you think about it? Is this intended behavior since it is more intuitive for the user?
If yes: do you know an easy way how to get the affine matrix to do the transformation in the y-axis-not-flipped scenario (especially thinking about sequences of transformations...)
If no: the matplotlib version would be "incorrect" and I think
get_extent()as well, since it gives us exactly the values that we see in the matplotlib plot (and that's a problem, because in the very end ofbasic.show(), the axis limits are adapted according to the extent - I only got the datashader plot above by manually overwriting the extent).(cc: @timtreis)