I'm trying to understand how the TransformedPath mechanism is working
with only limited success, and was hoping someone could help.
I have a non-affine transformation defined (subclass of
matplotlib.transforms.Transform) which takes a path and applies an
intensive transformation (path curving & cutting) which can take a
little while, but am able to guarantee that this transformation is a
one off and will never change for this transform instance, therefore
there are obvious caching opportunities.
I am aware that TransformedPath is doing some caching and would really
like to hook into this rather than rolling my own caching mechanism
but can't q
uite figure out (the probably obvious!) way to do it.
To see this problem for yourself I have attached a dummy example of
what I am working on:
import matplotlib.transforms
class SlowNonAffineTransform(matplotlib.transforms.Transform):
input_dims = 2
output_dims = 2
is_separable = False
has_inverse = True
def transform(self, points):
return matplotlib.transforms.IdentityTransform().transform(points)
def transform_path(self, path):
# pretends that it is doing something clever & time consuming,
but really is just sleeping
import time
# take a long time to do something
time.sleep(3)
# return the original path
return matplotlib.transforms.IdentityTransform().transform_path(path)
if __name__ == '__main__':
import matplotlib.pyplot as plt
ax = plt.axes()
ax.plot([0, 10, 20], [1, 3, 2], transform=SlowNonAffineTransform()
+ ax.transData)
plt.show()
When this code is run the initial "show" is slow, which is fine, but a
simple resize/zoom rect/pan/zoom will also take a long time.
How can I tell mpl that I can guarantee that my level of the transform
stack is never invalidated?
Many Thanks,