Affine Transformations on images

Dear list,

I was just trying to shear an image to be plotted with
matplotlib (to get some snazzy 3D effect) and realized
that it's apparently not possible. Investigating further,
I realized that the underlying agg library indeed supports
shearing, as it simply uses an affine matrix for its
transforms (very much like the rest of matplotlib),
but it does not export that feature to matplotlib.

So, I just quickly added some code to actually
access the transformation matrix in the C++ code,
so that one can use it from within python. The next
step would be to hook that up to the usual code used
in matplotlib.

A patch is attached at the end of this post.

Greetings

Martin

--------------- patch follows -----------------------

commit b7d0d23d90460ee790f1e94f387070a69be661c8
Author: Martin Teichmann <martin@...977...(none)>

    Make affine transformations work for images

    The current code only supports scaling and maybe rotation of
    images, but not all affine transformations, although it is
    already prepared to do so.

    This patch adds a method set_matrix to the C++ image handling code,
    so that one can set (and thus perform) arbitrary affine transformations.

    It also fixes a little bug which introduced weird side effects
    if images were resized more than once.

diff --git a/src/_image.cpp b/src/_image.cpp
index 3278b6c..7d40664 100644
--- a/src/_image.cpp
+++ b/src/_image.cpp
@@ -92,7 +92,6 @@ Image::apply_rotation(const Py::Tuple& args)

     agg::trans_affine M = agg::trans_affine_rotation(r * agg::pi / 180.0);
     srcMatrix *= M;
- imageMatrix *= M;
     return Py::Object();
}

@@ -156,7 +155,6 @@ Image::apply_scaling(const Py::Tuple& args)
     //printf("applying scaling %1.2f, %1.2f\n", sx, sy);
     agg::trans_affine M = agg::trans_affine_scaling(sx, sy);
     srcMatrix *= M;
- imageMatrix *= M;

     return Py::Object();
}
@@ -179,7 +177,6 @@ Image::apply_translation(const Py::Tuple& args)
     //printf("applying translation %1.2f, %1.2f\n", tx, ty);
     agg::trans_affine M = agg::trans_affine_translation(tx, ty);
     srcMatrix *= M;
- imageMatrix *= M;

     return Py::Object();
}
@@ -285,7 +282,6 @@ Image::reset_matrix(const Py::Tuple& args)

     args.verify_length(0);
     srcMatrix.reset();
- imageMatrix.reset();

     return Py::Object();
}
@@ -316,6 +312,31 @@ Image::get_matrix(const Py::Tuple& args)
     return ret;
}

+char Image::set_matrix__doc__[] =
+ "set_matrix(m11,m21,m12,m22,m13,m23)\n"
+ "\n"
+ "Set the affine transformation matrix\n"
+ " /m11,m12,m13\\\n"
+ " /m21,m22,m23|\n"
+ " \\ 0 , 0 , 1 /"
+ ;

···

Date: Wed Jul 6 14:04:44 2011 +0200
+
+Py::Object
+Image::set_matrix(const Py::Tuple& args)
+{
+ _VERBOSE("Image::set_matrix");
+
+ args.verify_length(6);
+
+ double m[6];
+ for (int i = 0;i < 6;i++)
+ {
+ m[i] = Py::Float(args[i]);
+ }
+ srcMatrix.load_from(m);
+ return Py::Object();
+}
+
char Image::resize__doc__[] =
     "resize(width, height, norm=1, radius=4.0)\n"
     "\n"
@@ -376,8 +397,7 @@ Image::resize(const Py::Tuple& args, const Py::Dict& kwargs)

     ras.clip_box(0, 0, numcols, numrows);

- //srcMatrix *= resizingMatrix;
- //imageMatrix *= resizingMatrix;
+ imageMatrix = srcMatrix;
     imageMatrix.invert();
     interpolator_type interpolator(imageMatrix);

@@ -733,6 +753,7 @@ Image::init_type()
     add_varargs_method("get_size_out", &Image::get_size_out,
Image::get_size_out__doc__);
     add_varargs_method("reset_matrix", &Image::reset_matrix,
Image::reset_matrix__doc__);
     add_varargs_method("get_matrix", &Image::get_matrix,
Image::get_matrix__doc__);
+ add_varargs_method("set_matrix", &Image::set_matrix,
Image::set_matrix__doc__);
     add_keyword_method("resize", &Image::resize, Image::resize__doc__);
     add_varargs_method("set_interpolation",
&Image::set_interpolation, Image::set_interpolation__doc__);
     add_varargs_method("set_resample", &Image::set_resample,
Image::set_resample__doc__);
diff --git a/src/_image.h b/src/_image.h
index 8a3be54..89a923c 100644
--- a/src/_image.h
+++ b/src/_image.h
@@ -34,6 +34,7 @@ public:
     Py::Object buffer_rgba(const Py::Tuple& args);
     Py::Object reset_matrix(const Py::Tuple& args);
     Py::Object get_matrix(const Py::Tuple& args);
+ Py::Object set_matrix(const Py::Tuple& args);
     Py::Object resize(const Py::Tuple& args, const Py::Dict& kwargs);
     Py::Object get_aspect(const Py::Tuple& args);
     Py::Object get_size(const Py::Tuple& args);
@@ -105,6 +106,7 @@ private:
     static char buffer_rgba__doc__[];
     static char reset_matrix__doc__[];
     static char get_matrix__doc__[];
+ static char set_matrix__doc__[];
     static char resize__doc__[];
     static char get_aspect__doc__[];
     static char get_size__doc__[];

Looks good. Does matplotlib still pass all regression tests with this change?

(See here for information on running the regression tests: http://matplotlib.sourceforge.net/devel/coding_guide.html?highlight=nosetests#testing).

Cheers,
Mike

···

On 07/06/2011 08:33 AM, Martin Teichmann wrote:

Dear list,

I was just trying to shear an image to be plotted with
matplotlib (to get some snazzy 3D effect) and realized
that it's apparently not possible. Investigating further,
I realized that the underlying agg library indeed supports
shearing, as it simply uses an affine matrix for its
transforms (very much like the rest of matplotlib),
but it does not export that feature to matplotlib.

So, I just quickly added some code to actually
access the transformation matrix in the C++ code,
so that one can use it from within python. The next
step would be to hook that up to the usual code used
in matplotlib.

A patch is attached at the end of this post.

Greetings

Martin

--------------- patch follows -----------------------

commit b7d0d23d90460ee790f1e94f387070a69be661c8
Author: Martin Teichmann<martin@...977...(none)>
Date: Wed Jul 6 14:04:44 2011 +0200

     Make affine transformations work for images

     The current code only supports scaling and maybe rotation of
     images, but not all affine transformations, although it is
     already prepared to do so.

     This patch adds a method set_matrix to the C++ image handling code,
     so that one can set (and thus perform) arbitrary affine transformations.

     It also fixes a little bug which introduced weird side effects
     if images were resized more than once.

diff --git a/src/_image.cpp b/src/_image.cpp
index 3278b6c..7d40664 100644
--- a/src/_image.cpp
+++ b/src/_image.cpp
@@ -92,7 +92,6 @@ Image::apply_rotation(const Py::Tuple& args)

      agg::trans_affine M = agg::trans_affine_rotation(r * agg::pi / 180.0);
      srcMatrix *= M;
- imageMatrix *= M;
      return Py::Object();
  }

@@ -156,7 +155,6 @@ Image::apply_scaling(const Py::Tuple& args)
      //printf("applying scaling %1.2f, %1.2f\n", sx, sy);
      agg::trans_affine M = agg::trans_affine_scaling(sx, sy);
      srcMatrix *= M;
- imageMatrix *= M;

      return Py::Object();
  }
@@ -179,7 +177,6 @@ Image::apply_translation(const Py::Tuple& args)
      //printf("applying translation %1.2f, %1.2f\n", tx, ty);
      agg::trans_affine M = agg::trans_affine_translation(tx, ty);
      srcMatrix *= M;
- imageMatrix *= M;

      return Py::Object();
  }
@@ -285,7 +282,6 @@ Image::reset_matrix(const Py::Tuple& args)

      args.verify_length(0);
      srcMatrix.reset();
- imageMatrix.reset();

      return Py::Object();
  }
@@ -316,6 +312,31 @@ Image::get_matrix(const Py::Tuple& args)
      return ret;
  }

+char Image::set_matrix__doc__[] =
+ "set_matrix(m11,m21,m12,m22,m13,m23)\n"
+ "\n"
+ "Set the affine transformation matrix\n"
+ " /m11,m12,m13\\\n"
+ " /m21,m22,m23|\n"
+ " \\ 0 , 0 , 1 /"
+ ;
+
+Py::Object
+Image::set_matrix(const Py::Tuple& args)
+{
+ _VERBOSE("Image::set_matrix");
+
+ args.verify_length(6);
+
+ double m[6];
+ for (int i = 0;i< 6;i++)
+ {
+ m[i] = Py::Float(args[i]);
+ }
+ srcMatrix.load_from(m);
+ return Py::Object();
+}
+
  char Image::resize__doc__[] =
      "resize(width, height, norm=1, radius=4.0)\n"
      "\n"
@@ -376,8 +397,7 @@ Image::resize(const Py::Tuple& args, const Py::Dict& kwargs)

      ras.clip_box(0, 0, numcols, numrows);

- //srcMatrix *= resizingMatrix;
- //imageMatrix *= resizingMatrix;
+ imageMatrix = srcMatrix;
      imageMatrix.invert();
      interpolator_type interpolator(imageMatrix);

@@ -733,6 +753,7 @@ Image::init_type()
      add_varargs_method("get_size_out",&Image::get_size_out,
Image::get_size_out__doc__);
      add_varargs_method("reset_matrix",&Image::reset_matrix,
Image::reset_matrix__doc__);
      add_varargs_method("get_matrix",&Image::get_matrix,
Image::get_matrix__doc__);
+ add_varargs_method("set_matrix",&Image::set_matrix,
Image::set_matrix__doc__);
      add_keyword_method("resize",&Image::resize, Image::resize__doc__);
      add_varargs_method("set_interpolation",
&Image::set_interpolation, Image::set_interpolation__doc__);
      add_varargs_method("set_resample",&Image::set_resample,
Image::set_resample__doc__);
diff --git a/src/_image.h b/src/_image.h
index 8a3be54..89a923c 100644
--- a/src/_image.h
+++ b/src/_image.h
@@ -34,6 +34,7 @@ public:
      Py::Object buffer_rgba(const Py::Tuple& args);
      Py::Object reset_matrix(const Py::Tuple& args);
      Py::Object get_matrix(const Py::Tuple& args);
+ Py::Object set_matrix(const Py::Tuple& args);
      Py::Object resize(const Py::Tuple& args, const Py::Dict& kwargs);
      Py::Object get_aspect(const Py::Tuple& args);
      Py::Object get_size(const Py::Tuple& args);
@@ -105,6 +106,7 @@ private:
      static char buffer_rgba__doc__[];
      static char reset_matrix__doc__[];
      static char get_matrix__doc__[];
+ static char set_matrix__doc__[];
      static char resize__doc__[];
      static char get_aspect__doc__[];
      static char get_size__doc__[];

------------------------------------------------------------------------------
All of the data generated in your IT infrastructure is seriously valuable.
Why? It contains a definitive record of application performance, security
threats, fraudulent activity, and more. Splunk takes this data and makes
sense of it. IT sense. And common sense.
http://p.sf.net/sfu/splunk-d2d-c2
_______________________________________________
Matplotlib-devel mailing list
Matplotlib-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-devel

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

I didn't have time to go through your code carefully, but my
understanding is that you rely on Agg to get a transformed image
(resampled image) and provide that image to backends, right? Note that
when interpolation mode is "none", resampling should be prohibited.
There is a good reason why we implemented the "none" interpolation
mode even though this is not supported for some backends. Overriding
this behavior (which I guess is the case of you current ShearImage
implementation. Please correct me if I'm wrong) won't be acceptable.
Please makes sure that resampling of images only happens when the
interpolation mode is not "none".

Regards,

-JJ

···

On Tue, Jul 12, 2011 at 7:01 PM, Martin Teichmann <martin.teichmann@...780...> wrote:

(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).

I'm starting to get a better sense of the code now. One of the features of the current implementation is that images are resampled before going into the output of the vector backends, so that we can a) control file size and b) control the interpolation algorithm used. It looks like that separation is maintained with this approach, only difference is that images can be both prerotated as well as prescaled now. Is that correct? (I must admit, I've work on bits and pieces of the image code at the edges, but I don't understand it in great detail).

It looks like overriding "draw_unsampled_image" is the wrong thing to do here, though. The purpose of that function is to draw an image in a vector backend without any resampling at all -- and here you seem to be adding that. It also only gets called when interpolation is "none" or "nearest", so your helpful changes currently don't work with other forms of interpolation. I think we need to either add a function "_draw_sampled_image", or modify make_image so it returns an offset with the new location to draw the image (because rotation may cause the bounds of the image to be shifted).

This is great work, and is looking to be fairly significant. Would you be able to set up a personal git fork and branch for you work? It would make it easier for the rest of us to evaluate what you have done and kick the tires a bit. The outline of how to do this is here:

http://matplotlib.sourceforge.net/devel/gitwash/index.html

Cheers,
Mike

···

On 07/12/2011 06:01 AM, Martin Teichmann wrote:

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

------------------------------------------------------------------------------
AppSumo Presents a FREE Video for the SourceForge Community by Eric
Ries, the creator of the Lean Startup Methodology on "Lean Startup
Secrets Revealed." This video shows you how to validate your ideas,
optimize your ideas and identify your business strategy.
http://p.sf.net/sfu/appsumosfdev2dev
_______________________________________________
Matplotlib-devel mailing list
Matplotlib-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-devel

Hello List,
Hello Michael, Hello Jae-Joon,

Michale wrote:

It looks like overriding "draw_unsampled_image" is the wrong thing to do
here, though.

JJ wrote:

Overriding this behavior (which I guess is the case of you current ShearImage
implementation. Please correct me if I'm wrong) won't be acceptable.

I was (and am) aware of this problem, this is what I meant when I wrote
"I should have overridden make_image". That's exactly the point:
there are two ways to make the image: one using Agg and fancy interpolations,
the other one to use the backend and have the interpolation "none".

The former is done by make_image, the latter by _draw_unsampled_image.
It would have been correct for me to override make_image, unfortunately
this was not possible since make_image only makes the image, it is then
drawn by _AxesImageBase.draw, which unfortunately is not flexible enough,
as it does not allow for the image to be drawn elsewhere than the
origin of the axes, which is not necessarily what I want.

This is why I abused _draw_unsampled_image. I am aware that this is
an abuse, but my code was only inteded as demonstration code.

I don't know where to go from here. We could:

- make make_image actually draw the image. This would be a break in
the API.
- introduce a new method (_draw_sampled_image seems like a good name)
that does that. That indirectly changes the API since make_image won't
be called anymore, overriding it doesn't make a difference anymore.
- Rewrite matplotlib from scratch in Java (just kidding)

I'm looking forward to your ideas.

Greetings

Martin

···

--
Fachbereich Physik
Freie Universität Berlin
Arnimallee 14
14195 Berlin
+49 30 6392 1234

Hello List,
Hello Michael, Hello Jae-Joon,

Michale wrote:

It looks like overriding "draw_unsampled_image" is the wrong thing to do
here, though.

JJ wrote:

Overriding this behavior (which I guess is the case of you current ShearImage
implementation. Please correct me if I'm wrong) won't be acceptable.

I don't know where to go from here. We could:

- make make_image actually draw the image. This would be a break in
the API.
- introduce a new method (_draw_sampled_image seems like a good name)
that does that. That indirectly changes the API since make_image won't
be called anymore, overriding it doesn't make a difference anymore.

I think either of these is ok. make_image is not really in the public API anyway -- I know it doesn't have a preceding underscore, but I think this code may predate that convention. If you add _draw_sampled_image, I would remove make_image to eliminate confusion.

- Rewrite matplotlib from scratch in Java (just kidding)

We generally, consider patches in first-come-first-serve order, so I would recommend taking whichever approach could be completed sooner :wink:

Cheers,
Mike

···

On 07/14/2011 07:33 AM, Martin Teichmann wrote:

--
Michael Droettboom
Science Software Branch
Space Telescope Science Institute
Baltimore, Maryland, USA