matplotlib-devel Mailing List for matplotlib

Dear List,
dear Michael,
> Looks good. Does matplotlib still pass all regression tests with this
> change?
It does pass all regression tests that were passed with the git version
I started with. (There were 10 failures which are still there).
In the meantime, I also wrote a class that already uses my extension.
With it, you can plot rotated or sheared images with all backends.
(There were some quirks to get sheard images on some backends,
see examples/api/demo_affine_image.py, but it worked on some backends
only).
While writing it, I found some inconsistencies in matplotlib:
- bounding boxes are not correctly transformed. BboxBase.tranformed only
transformes the outer points of a bounding box, if you rotate it, this will give
wrong results for several angles. I wrote a function that should be correct for
all affine transformations:
def transform_bbox(bbox, trans):
 x0, y0, x1, y1 = bbox.extents
 tx0, ty0 = trans.transform([x0, y0])
 tx1, ty1 = trans.transform([x1, y1])
 tx2, ty2 = trans.transform([x1, y0])
 tx3, ty3 = trans.transform([x0, y1])
 return Bbox.from_extents(min(tx0, tx1, tx2, tx3), min(ty0, ty1, ty2, ty3),
 max(tx0, tx1, tx2, tx3), max(ty0, ty1, ty2, ty3))
- The other inconsistency is that within matplotlib, extents are
defined different:
in imshow, the parameter extent expects the order (left, right, bottom, top),
while BboxBase.extents is (left, bottom, right, top). This should be changed in
the future, maybe the move to python 3 is a good time for that?
But now to my code to draw images. It's a new class inheriting AxesImage,
but is supposed to once replace AxesImage, as it is compatible.
I'm re-writing _draw_unsampled_image, to actually draw a sampled image.
Thats only because make_image, the method to be rewritten for a sampled
image, is not flexible enough (the caller draws the image, but there is no way
for make_image to tell where that image is to be put). In the future,
the methods
should be renamed (it's a private method, so that's no problem).
class ShearImage(AxesImage):
 def _check_unsampled_image(self, _):
 return True
 def _draw_unsampled_image(self, renderer, gc):
 """
 actually, draw sampled image. This method is more flexible than
 make_image
 """
 mag = renderer.get_image_magnification()
 trans = Affine2D().scale(mag, mag) + self.get_transform() + \
 self.axes.transData.get_affine()
 bbox = self.axes.bbox
 viewLim = transform_bbox(bbox, trans.inverted())
 im, xmin, ymin, dxintv, dyintv, sx, sy = \
 self._get_unsampled_image(self._A, self.get_extent(), viewLim)
 if im is None: return # I'm not if this check is required. -JJL
 im.set_interpolation(self._interpd[self._interpolation])
 im.set_resample(self._resample)
 fc = self.axes.patch.get_facecolor()
 bg = mcolors.colorConverter.to_rgba(fc, 0)
 im.set_bg( *bg)
 # uncomment the following line to see the extent to which the image
 # is drawn
 # im.set_bg(0, 0, 0, 100)
 numrows, numcols = im.get_size()
 ex = self.get_extent()
 tex = Bbox.from_extents([ex[0], ex[2], ex[1], ex[3]])
 tex = transform_bbox(tex, trans)
 if tex.xmin < bbox.xmin:
 left = bbox.xmin
 tx = 0
 else:
 left = tex.xmin
 tx = tex.xmin - bbox.xmin
 if tex.ymin < bbox.ymin:
 bottom = bbox.ymin
 ty = 0
 else:
 bottom = tex.ymin
 ty = tex.ymin - bbox.ymin
 trans = Affine2D().scale(dxintv / numcols,
 dyintv / numrows).translate(xmin, ymin) + \
 trans + \
 Affine2D().translate(-bbox.xmin - tx, -bbox.ymin - ty)
 im.set_matrix(*trans.get_matrix()[:2, :].T.ravel())
 width = min(tex.xmax, bbox.xmax) - left
 height = min(tex.ymax, bbox.ymax) - bottom
 if width <= 0 or height <= 0:
 return
 im.resize(width * mag, height * mag,
 norm=self._filternorm, radius=self._filterrad)
 im._url = self.get_url()
 renderer.draw_image(gc, left, bottom, im)
Last but not least, a little script to test the above. It shows a rotated
image. You can scale and move the image nicely. If you uncomment the
line mentioned above in ShearImage code, you can see where the
image is actually drawn, and you will see that only the necessary parts
are drawn if the image is smaller than the entire axes.
The test script follows:
from pylab import *
ax = axes()
im = ShearImage(ax)
im.set_data(fromfunction(lambda x, y: sin(x + y ** 2), (100, 100)))
im.set_extent(im.get_extent())
transform = Affine2D().rotate_deg(30)
im.set_transform(transform)
ax.images.append(im)
show()
Greetings
Martin