Simplify mathtext code so it doesn't require cyclical/weak references anymore. Alas, still no luck solving the mysterious FT2Image memory leak.

mdboom · mdboom · commit 5a4c57893c27 · 2011-03-08T16:27:16.000-05:00
diff --git a/lib/matplotlib/mathtext.py b/lib/matplotlib/mathtext.py
@@ -30,7 +30,6 @@
     from sets import Set as set
 import unicodedata
 from warnings import warn
-import weakref
 
 from numpy import inf, isinf
 import numpy as np
@@ -57,8 +56,6 @@
         latex_to_standard, tex2uni, latex_to_cmex, stix_virtual_fonts
 from matplotlib import get_data_path, rcParams
 
-
-
 import matplotlib.colors as mcolors
 import matplotlib._png as _png
 ####################
@@ -119,7 +116,9 @@ class MathtextBackend(object):
       - :meth:`get_hinting_type`
     """
     def __init__(self):
-        self.fonts_object = None
+        self.width = 0
+        self.height = 0
+        self.depth = 0
 
     def set_canvas_size(self, w, h, d):
         'Dimension the drawing canvas'
@@ -154,111 +153,84 @@ def get_hinting_type(self):
         """
         return LOAD_NO_HINTING
 
-class MathtextBackendBbox(MathtextBackend):
+class MathtextBackendAgg(MathtextBackend):
     """
-    A backend whose only purpose is to get a precise bounding box.
-    Only required for the Agg backend.
+    Render glyphs and rectangles to an FTImage buffer, which is later
+    transferred to the Agg image by the Agg backend.
     """
-
-    def __init__(self, real_backend):
-        MathtextBackend.__init__(self)
+    def __init__(self):
+        self.ox = 0
+        self.oy = 0
+        self.image = None
+        self.mode = 'bbox'
         self.bbox = [0, 0, 0, 0]
-        self.real_backend = real_backend
+        MathtextBackend.__init__(self)
 
     def _update_bbox(self, x1, y1, x2, y2):
         self.bbox = [min(self.bbox[0], x1),
                      min(self.bbox[1], y1),
                      max(self.bbox[2], x2),
                      max(self.bbox[3], y2)]
 
+    def set_canvas_size(self, w, h, d):
+        MathtextBackend.set_canvas_size(self, w, h, d)
+        if self.mode != 'bbox':
+            self.image = FT2Image(ceil(w), ceil(h + d))
+
     def render_glyph(self, ox, oy, info):
-        self._update_bbox(ox + info.metrics.xmin,
-                          oy - info.metrics.ymax,
-                          ox + info.metrics.xmax,
-                          oy - info.metrics.ymin)
+        if self.mode == 'bbox':
+            self._update_bbox(ox + info.metrics.xmin,
+                              oy - info.metrics.ymax,
+                              ox + info.metrics.xmax,
+                              oy - info.metrics.ymin)
+        else:
+            info.font.draw_glyph_to_bitmap(
+                self.image, ox, oy - info.metrics.iceberg, info.glyph)
 
     def render_rect_filled(self, x1, y1, x2, y2):
-        self._update_bbox(x1, y1, x2, y2)
+        if self.mode == 'bbox':
+            self._update_bbox(x1, y1, x2, y2)
+        else:
+            height = max(int(y2 - y1) - 1, 0)
+            if height == 0:
+                center = (y2 + y1) / 2.0
+                y = int(center - (height + 1) / 2.0)
+            else:
+                y = int(y1)
+            self.image.draw_rect_filled(int(x1), y, ceil(x2), y + height)
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
+        self.mode = 'bbox'
         orig_height = box.height
         orig_depth  = box.depth
         ship(0, 0, box)
         bbox = self.bbox
         bbox = [bbox[0] - 1, bbox[1] - 1, bbox[2] + 1, bbox[3] + 1]
-        self._switch_to_real_backend()
-        self.fonts_object().set_canvas_size(
+        self.mode = 'render'
+        self.set_canvas_size(
             bbox[2] - bbox[0],
             (bbox[3] - bbox[1]) - orig_depth,
             (bbox[3] - bbox[1]) - orig_height)
         ship(-bbox[0], -bbox[1], box)
-        return self.fonts_object().get_results(box)
-
-    def get_hinting_type(self):
-        return self.real_backend.get_hinting_type()
-
-    def _switch_to_real_backend(self):
-        self.fonts_object().mathtext_backend = weakref.ref(self.real_backend)
-        self.real_backend.fonts_object = self.fonts_object
-        self.real_backend.ox = self.bbox[0]
-        self.real_backend.oy = self.bbox[1]
-
-class MathtextBackendAggRender(MathtextBackend):
-    """
-    Render glyphs and rectangles to an FTImage buffer, which is later
-    transferred to the Agg image by the Agg backend.
-    """
-    def __init__(self):
-        self.ox = 0
-        self.oy = 0
-        self.image = None
-        MathtextBackend.__init__(self)
-
-    def set_canvas_size(self, w, h, d):
-        MathtextBackend.set_canvas_size(self, w, h, d)
-        self.image = FT2Image(ceil(w), ceil(h + d))
-
-    def render_glyph(self, ox, oy, info):
-        info.font.draw_glyph_to_bitmap(
-            self.image, ox, oy - info.metrics.iceberg, info.glyph)
-
-    def render_rect_filled(self, x1, y1, x2, y2):
-        height = max(int(y2 - y1) - 1, 0)
-        if height == 0:
-            center = (y2 + y1) / 2.0
-            y = int(center - (height + 1) / 2.0)
-        else:
-            y = int(y1)
-        self.image.draw_rect_filled(int(x1), y, ceil(x2), y + height)
-
-    def get_results(self, box):
         return (self.ox,
                 self.oy,
                 self.width,
                 self.height + self.depth,
                 self.depth,
                 self.image,
-                self.fonts_object().get_used_characters())
+                used_characters)
 
     def get_hinting_type(self):
         if rcParams['text.hinting']:
             return LOAD_FORCE_AUTOHINT
         else:
             return LOAD_NO_HINTING
 
-def MathtextBackendAgg():
-    return MathtextBackendBbox(MathtextBackendAggRender())
-
-class MathtextBackendBitmapRender(MathtextBackendAggRender):
-    def get_results(self, box):
-        return self.image, self.depth
-
-def MathtextBackendBitmap():
-    """
-    A backend to generate standalone mathtext images.  No additional
-    matplotlib backend is required.
-    """
-    return MathtextBackendBbox(MathtextBackendBitmapRender())
+class MathtextBackendBitmap(MathtextBackendAgg):
+    def get_results(self, box, used_characters):
+        ox, oy, width, height, depth, image, characters = \
+            MathtextBackendAgg(self, box, used_characters)
+        return image, depth
 
 class MathtextBackendPs(MathtextBackend):
     """
@@ -292,14 +264,14 @@ def render_rect_filled(self, x1, y1, x2, y2):
         ps = "%f %f %f %f rectfill\n" % (x1, self.height - y2, x2 - x1, y2 - y1)
         self.pswriter.write(ps)
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
         #print self.depth
         return (self.width,
                 self.height + self.depth,
                 self.depth,
                 self.pswriter,
-                self.fonts_object().get_used_characters())
+                used_characters)
 
 class MathtextBackendPdf(MathtextBackend):
     """
@@ -320,14 +292,14 @@ def render_glyph(self, ox, oy, info):
     def render_rect_filled(self, x1, y1, x2, y2):
         self.rects.append((x1, self.height - y2, x2 - x1, y2 - y1))
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
         return (self.width,
                 self.height + self.depth,
                 self.depth,
                 self.glyphs,
                 self.rects,
-                self.fonts_object().get_used_characters())
+                used_characters)
 
 class MathtextBackendSvg(MathtextBackend):
     """
@@ -348,15 +320,15 @@ def render_rect_filled(self, x1, y1, x2, y2):
         self.svg_rects.append(
             (x1, self.height - y1 + 1, x2 - x1, y2 - y1))
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
         svg_elements = Bunch(svg_glyphs = self.svg_glyphs,
                              svg_rects = self.svg_rects)
         return (self.width,
                 self.height + self.depth,
                 self.depth,
                 svg_elements,
-                self.fonts_object().get_used_characters())
+                used_characters)
 
 class MathtextBackendPath(MathtextBackend):
     """
@@ -378,7 +350,7 @@ def render_rect_filled(self, x1, y1, x2, y2):
         self.rects.append(
             (x1, self.height-y2 , x2 - x1, y2 - y1))
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
         return (self.width,
                 self.height + self.depth,
@@ -406,7 +378,7 @@ def render_rect_filled(self, x1, y1, x2, y2):
         self.rects.append(
             (x1, y1 - self.height, x2 - x1, y2 - y1))
 
-    def get_results(self, box):
+    def get_results(self, box, used_characters):
         ship(0, -self.depth, box)
         return (self.width,
                 self.height + self.depth,
@@ -434,9 +406,7 @@ def __init__(self, default_font_prop, mathtext_backend):
         used to delegate the actual rendering.
         """
         self.default_font_prop = default_font_prop
-        self.mathtext_backend = weakref.ref(mathtext_backend)
-        # Make these classes doubly-linked
-        mathtext_backend.fonts_object = weakref.ref(self)
+        self.mathtext_backend = mathtext_backend
         self.used_characters = {}
 
     def destroy(self):
@@ -502,7 +472,7 @@ def set_canvas_size(self, w, h, d):
         Only really necessary for the bitmap backends.
         """
         self.width, self.height, self.depth = ceil(w), ceil(h), ceil(d)
-        self.mathtext_backend().set_canvas_size(self.width, self.height, self.depth)
+        self.mathtext_backend.set_canvas_size(self.width, self.height, self.depth)
 
     def render_glyph(self, ox, oy, facename, font_class, sym, fontsize, dpi):
         """
@@ -525,13 +495,13 @@ def render_glyph(self, ox, oy, facename, font_class, sym, fontsize, dpi):
         used_characters = self.used_characters.setdefault(
             stat_key, (realpath, set()))
         used_characters[1].add(info.num)
-        self.mathtext_backend().render_glyph(ox, oy, info)
+        self.mathtext_backend.render_glyph(ox, oy, info)
 
     def render_rect_filled(self, x1, y1, x2, y2):
         """
         Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*).
         """
-        self.mathtext_backend().render_rect_filled(x1, y1, x2, y2)
+        self.mathtext_backend.render_rect_filled(x1, y1, x2, y2)
 
     def get_xheight(self, font, fontsize, dpi):
         """
@@ -559,7 +529,7 @@ def get_results(self, box):
         Get the data needed by the backend to render the math
         expression.  The return value is backend-specific.
         """
-        return self.mathtext_backend().get_results(box)
+        return self.mathtext_backend.get_results(box, self.get_used_characters())
 
     def get_sized_alternatives_for_symbol(self, fontname, sym):
         """
@@ -632,7 +602,7 @@ def _get_info(self, fontname, font_class, sym, fontsize, dpi):
         font.set_size(fontsize, dpi)
         glyph = font.load_char(
             num,
-            flags=self.mathtext_backend().get_hinting_type())
+            flags=self.mathtext_backend.get_hinting_type())
 
         xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox]
         offset = self._get_offset(cached_font, glyph, fontsize, dpi)
diff --git a/src/ft2font.cpp b/src/ft2font.cpp
@@ -62,7 +62,6 @@ FT2Image::FT2Image(Py::PythonClassInstance *self, Py::Tuple &args, Py::Dict &kwd
 }
 
 FT2Image::~FT2Image() {
-    printf("~FT2Image");
     delete [] _buffer;
     _buffer = NULL;
 }
@@ -1905,10 +1904,6 @@ FT2Image::init_type(void)
                              FT2Image::as_array__doc__);
     PYCXX_ADD_VARARGS_METHOD(as_str, py_as_str,
                              FT2Image::as_str__doc__);
-    PYCXX_ADD_VARARGS_METHOD(as_rgb_str, py_as_rgb_str,
-                             FT2Image::as_rgb_str__doc__);
-    PYCXX_ADD_VARARGS_METHOD(as_rgba_str, py_as_rgba_str,
-                             FT2Image::as_rgba_str__doc__);
     PYCXX_ADD_VARARGS_METHOD(get_width, py_get_width,
                              "Returns the width of the image");
     PYCXX_ADD_VARARGS_METHOD(get_height, py_get_height,
