Add support for arbitrary angles of rotation on mathtext in Agg

mdboom · mdboom · commit ba1d8d5a4814 · 2007-09-04T19:00:18.000Z
backend.  Uses agg to rotate the raster of the text.

svn path=/trunk/matplotlib/; revision=3776
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -174,17 +174,10 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
                                      'debug-annoying')
         ox, oy, width, height, descent, font_image, used_characters = \
             self.mathtext_parser.parse(s, self.dpi.get(), prop)
-
-        if angle == 90:
-            width, height = height, width
-            ox, oy = oy, ox
-            x = int(x) - width + ox
-            y = int(y) - height + oy
-            font_image.rotate()
-        else:
-            x = int(x) + ox
-            y = int(y) - height + oy
-        self._renderer.draw_text_image(font_image, x, y + 1, gc)
+        
+        x = int(x) + ox
+        y = int(y) - oy
+        self._renderer.draw_text_image(font_image, x, y + 1, angle, gc)
         if 0:
             self._renderer.draw_rectangle(gc, None,
                                           int(x),
@@ -205,12 +198,14 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath):
         if len(s) == 1 and ord(s) > 127:
             font.load_char(ord(s), flags=LOAD_DEFAULT)
         else:
-            font.set_text(s, angle, flags=LOAD_DEFAULT)
+            font.set_text(s, 0, flags=LOAD_DEFAULT)
         font.draw_glyphs_to_bitmap()
 
         #print x, y, int(x), int(y)
 
-        self._renderer.draw_text_image(font.get_image(), int(x), int(y) + 1, gc)
+        # We pass '0' for angle here, since is has already been rotated
+        # (in vector space) in the above call to font.set_text.
+        self._renderer.draw_text_image(font.get_image(), int(x), int(y) + 1, angle, gc)
 
 
     def get_text_width_height_descent(self, s, prop, ismath, rgb=(0,0,0)):
@@ -229,7 +224,7 @@ def get_text_width_height_descent(self, s, prop, ismath, rgb=(0,0,0)):
             Z = texmanager.get_rgba(s, size, self.dpi.get(), rgb)
             m,n,tmp = Z.shape
             # TODO: descent of TeX text (I am imitating backend_ps here -JKS)
-            return n, m, m
+            return n, m, 0
 
         if ismath:
             ox, oy, width, height, descent, fonts, used_characters = \
diff --git a/lib/matplotlib/backends/backend_ps.py b/lib/matplotlib/backends/backend_ps.py
@@ -275,10 +275,9 @@ def get_text_width_height_descent(self, s, prop, ismath):
             l,b,r,t = texmanager.get_ps_bbox(s, fontsize)
             w = (r-l)
             h = (t-b)
-            #print s, w, h
             # TODO: We need a way to get a good baseline from
             # text.usetex
-            return w, h, h
+            return w, h, 0
 
         if ismath:
             width, height, descent, pswriter, used_characters = \
diff --git a/lib/matplotlib/mathtext.py b/lib/matplotlib/mathtext.py
@@ -541,7 +541,7 @@ def __init__(self, font):
             self.font     = font
             self.charmap  = font.get_charmap()
             self.glyphmap = dict(
-                [(glyphind, ccode) for ccode, glyphind in self.charmap.items()])
+                [(glyphind, ccode) for ccode, glyphind in self.charmap.iteritems()])
 
         def __repr__(self):
             return repr(self.font)
@@ -671,7 +671,7 @@ class BakomaFonts(TruetypeFonts):
     def __init__(self, *args, **kwargs):
         TruetypeFonts.__init__(self, *args, **kwargs)
         if not len(self.fontmap):
-            for key, val in self._fontmap.items():
+            for key, val in self._fontmap.iteritems():
                 fullpath = os.path.join(self.basepath, val + ".ttf")
                 self.fontmap[key] = fullpath
                 self.fontmap[val] = fullpath
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -16,6 +16,9 @@
 #include "agg_scanline_storage_aa.h"
 #include "agg_scanline_storage_bin.h"
 #include "agg_renderer_primitives.h"
+#include "agg_span_image_filter_gray.h"
+#include "agg_span_interpolator_linear.h"
+#include "agg_span_allocator.h"
 #include "util/agg_color_conv_rgb8.h"
 
 #include "ft2font.h"
@@ -2103,13 +2106,74 @@ RendererAgg::draw_path(const Py::Tuple& args) {
   
 }
 
+/**
+ * This is a custom span generator that converts spans in the 
+ * 8-bit inverted greyscale font buffer to rgba that agg can use.
+ */
+template<
+  class ColorT,
+  class ChildGenerator>
+class font_to_rgba :
+  public agg::span_generator<ColorT, 
+			     agg::span_allocator<ColorT> >
+{
+public:
+  typedef ChildGenerator child_type;
+  typedef ColorT color_type;
+  typedef agg::span_allocator<color_type> allocator_type;
+  typedef agg::span_generator<
+    ColorT, 
+    agg::span_allocator<ColorT> > base_type;
+
+private:
+  child_type* _gen;
+  allocator_type _alloc;
+  color_type _color;
+  
+public:
+  font_to_rgba(child_type* gen, color_type color) : 
+    base_type(_alloc),
+    _gen(gen),
+    _color(color) {
+  }
 
+  color_type* generate(int x, int y, unsigned len)
+  {
+    color_type* dst = base_type::allocator().span();
+
+    typename child_type::color_type* src = _gen->generate(x, y, len);
+
+    do {
+      *dst = _color;
+      dst->a = src->v;
+      ++src;
+      ++dst;
+    } while (--len);
+
+    return base_type::allocator().span();
+  }
+
+  void prepare(unsigned max_span_len) 
+  {
+    _alloc.allocate(max_span_len);
+    _gen->prepare(max_span_len);
+  }
+
+};
 
 Py::Object
 RendererAgg::draw_text_image(const Py::Tuple& args) {
   _VERBOSE("RendererAgg::draw_text");
+
+  typedef agg::span_interpolator_linear<> interpolator_type;
+  typedef agg::span_image_filter_gray<agg::gray8, interpolator_type> 
+    image_span_gen_type;
+  typedef font_to_rgba<pixfmt::color_type, image_span_gen_type> 
+    span_gen_type;
+  typedef agg::renderer_scanline_aa<renderer_base, span_gen_type> 
+    renderer_type;
   
-  args.verify_length(4);
+  args.verify_length(5);
   
   FT2Image *image = static_cast<FT2Image*>(args[0].ptr());
   if (!image->get_buffer())
@@ -2125,70 +2189,48 @@ RendererAgg::draw_text_image(const Py::Tuple& args) {
     return Py::Object();
   }
   
-  GCAgg gc = GCAgg(args[3], dpi);
-  
-  set_clipbox_rasterizer( gc.cliprect);
-  
-  
-  pixfmt::color_type p;
-  p.r = int(255*gc.color.r);
-  p.b = int(255*gc.color.b);
-  p.g = int(255*gc.color.g);
-  p.a = int(255*gc.color.a);
-  
-  //y = y-font->image.height;
-  unsigned thisx, thisy;
-  
-  double l = 0;
-  double b = 0;
-  double r = width;
-  double t = height;
-  if (gc.cliprect!=NULL) {
-    l = gc.cliprect[0] ;
-    b = gc.cliprect[1] ;
-    double w = gc.cliprect[2];
-    double h = gc.cliprect[3];
-    r = l+w;
-    t = b+h;
-  }
+  double angle = Py::Float( args[3] );
+
+  GCAgg gc = GCAgg(args[4], dpi);
   
+  set_clipbox_rasterizer(gc.cliprect);
+
   const unsigned char* const buffer = image->get_buffer();
-  
-  for (size_t i=0; i< image->get_width(); i++) {
-    for (size_t j=0; j< image->get_height(); j++) {
-      thisx = i+x+image->offsetx;
-      thisy = j+y+image->offsety;
-      if (thisx<l || thisx>=r)  continue;
-      if (thisy<height-t || thisy>=height-b) continue;
-      pixFmt->blend_pixel
-	(thisx, thisy, p, buffer[i + j*image->get_width()]);
-    }
-  }
-  
-  /*  bbox the text for debug purposes
-      
-  agg::path_storage path;
-  
-  path.move_to(x, y);
-  path.line_to(x, y+font->image.height);
-  path.line_to(x+font->image.width, y+font->image.height);
-  path.line_to(x+font->image.width, y);
-  path.close_polygon();
-  
-  agg::rgba edgecolor(1,0,0,1);
-  
-  //now fill the edge
-  agg::conv_stroke<agg::path_storage> stroke(path);
-  stroke.width(1.0);
-  rendererAA->color(edgecolor);
-  //self->theRasterizer->gamma(agg::gamma_power(gamma));
-  theRasterizer->add_path(stroke);
-  agg::render_scanlines(*theRasterizer, *slineP8, *rendererAA);
-  
-  */
+  agg::rendering_buffer srcbuf
+    ((agg::int8u*)buffer, image->get_width(), 
+     image->get_height(), image->get_width());
+  agg::pixfmt_gray8 pixf_img(srcbuf);
+  
+  agg::trans_affine mtx;
+  mtx *= agg::trans_affine_translation(0, -(int)image->get_height());
+  mtx *= agg::trans_affine_rotation(-angle * agg::pi / 180.0);
+  mtx *= agg::trans_affine_translation(x, y);
+
+  agg::path_storage rect;
+  rect.move_to(0, 0);
+  rect.line_to(image->get_width(), 0);
+  rect.line_to(image->get_width(), image->get_height());
+  rect.line_to(0, image->get_height());
+  rect.line_to(0, 0);
+  agg::conv_transform<agg::path_storage> rect2(rect, mtx);
+
+  agg::trans_affine inv_mtx(mtx);
+  inv_mtx.invert();
+
+  agg::image_filter_lut filter;
+  filter.calculate(agg::image_filter_spline36());
+  interpolator_type interpolator(inv_mtx);
+  agg::span_allocator<agg::gray8> gray_span_allocator;
+  image_span_gen_type image_span_generator(gray_span_allocator, 
+					   srcbuf, 0, interpolator, filter);
+  span_gen_type output_span_generator(&image_span_generator, gc.color);
+  renderer_type ri(*rendererBase, output_span_generator);
+  agg::rasterizer_scanline_aa<> rasterizer;
+  agg::scanline_p8 scanline;
+  rasterizer.add_path(rect2);
+  agg::render_scanlines(rasterizer, scanline, ri);
   
   return Py::Object();
-  
 }
 
 
diff --git a/src/ft2font.cpp b/src/ft2font.cpp
diff --git a/src/ft2font.h b/src/ft2font.h
