Handle colour fonts

Author: QuLogic

lib/matplotlib/backends/backend_agg.py

@@ -189,7 +189,7 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
                  round(0x40 * (self.height - y + dx * sin + dy * cos))]
             )
             bitmap = font._render_glyph(
-                glyph_index, get_hinting_flag(),
+                glyph_index, get_hinting_flag() | LoadFlags.COLOR,
                 RenderMode.NORMAL if gc.get_antialiased() else RenderMode.MONO)
             buffer = np.asarray(bitmap.buffer)
             if not gc.get_antialiased():
@@ -221,20 +221,38 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         if ismath:
             return self.draw_mathtext(gc, x, y, s, prop, angle)
         font = self._prepare_font(prop)
-        font.set_text(s, angle, flags=get_hinting_flag(),
-                      features=mtext.get_fontfeatures() if mtext is not None else None,
-                      language=mtext.get_language() if mtext is not None else None)
-        for bitmap in font._render_glyphs(
-            x, self.height - y,
-            RenderMode.NORMAL if gc.get_antialiased() else RenderMode.MONO,
-        ):
+        cos = math.cos(math.radians(angle))
+        sin = math.sin(math.radians(angle))
+        load_flags = get_hinting_flag() | LoadFlags.COLOR | LoadFlags.NO_SVG
+        items = font._layout(
+            s, flags=load_flags,
+            features=mtext.get_fontfeatures() if mtext is not None else None,
+            language=mtext.get_language() if mtext is not None else None)
+        for item in items:
+            hf = item.ft_object._hinting_factor
+            item.ft_object._set_transform(
+                [[round(0x10000 * cos / hf), round(0x10000 * -sin)],
+                 [round(0x10000 * sin / hf), round(0x10000 * cos)]],
+                [round(0x40 * (x + item.x * cos - item.y * sin)),
+                 # FreeType's y is upwards.
+                 round(0x40 * (self.height - y + item.x * sin + item.y * cos))]
+            )
+            bitmap = item.ft_object._render_glyph(
+                item.glyph_index, load_flags,
+                RenderMode.NORMAL if gc.get_antialiased() else RenderMode.MONO)
             buffer = bitmap.buffer
             if not gc.get_antialiased():
                 buffer *= 0xff
-            self._renderer.draw_text_image(
-                buffer,
-                bitmap.left, int(self.height) - bitmap.top + buffer.shape[0],
-                0, gc)
+            if buffer.ndim == 3:
+                self._renderer.draw_image(
+                    gc,
+                    bitmap.left, bitmap.top - buffer.shape[0],
+                    buffer[::-1, :, [2, 1, 0, 3]])
+            else:
+                self._renderer.draw_text_image(
+                    buffer,
+                    bitmap.left, int(self.height) - bitmap.top + buffer.shape[0],
+                    0, gc)
 
     def get_text_width_height_descent(self, s, prop, ismath):
         # docstring inherited

src/ft2font_wrapper.cpp

@@ -297,14 +297,22 @@ struct PyPositionedBitmap {
         left{slot->bitmap_left}, top{slot->bitmap_top}, owning{true}
     {
         FT_Bitmap_Init(&bitmap);
-        FT_CHECK(FT_Bitmap_Convert, _ft2Library, &slot->bitmap, &bitmap, 1);
+        if (slot->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
+            FT_CHECK(FT_Bitmap_Convert, _ft2Library, &slot->bitmap, &bitmap, 1);
+        } else {
+            FT_CHECK(FT_Bitmap_Copy, _ft2Library, &slot->bitmap, &bitmap);
+        }
     }
 
     PyPositionedBitmap(FT_BitmapGlyph bg) :
         left{bg->left}, top{bg->top}, owning{true}
     {
         FT_Bitmap_Init(&bitmap);
-        FT_CHECK(FT_Bitmap_Convert, _ft2Library, &bg->bitmap, &bitmap, 1);
+        if (bg->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
+            FT_CHECK(FT_Bitmap_Convert, _ft2Library, &bg->bitmap, &bitmap, 1);
+        } else {
+            FT_CHECK(FT_Bitmap_Copy, _ft2Library, &bg->bitmap, &bitmap);
+        }
     }
 
     PyPositionedBitmap(PyPositionedBitmap& other) = delete;  // Non-copyable.
@@ -1668,9 +1676,19 @@ PYBIND11_MODULE(ft2font, m, py::mod_gil_not_used())
         .def_readonly("top", &PyPositionedBitmap::top)
         .def_property_readonly(
           "buffer", [](PyPositionedBitmap &self) -> py::array {
-            return {{self.bitmap.rows, self.bitmap.width},
+            if (self.bitmap.pixel_mode == FT_PIXEL_MODE_BGRA) {
+                return {
+                    py::array::ShapeContainer({self.bitmap.rows, self.bitmap.width, 4}),
+                    py::array::StridesContainer({self.bitmap.pitch, 4, 1}),
+                    self.bitmap.buffer
+                };
+            } else {
+                return {
+                    {self.bitmap.rows, self.bitmap.width},
                     {self.bitmap.pitch, 1},
-                    self.bitmap.buffer};
+                    self.bitmap.buffer
+                };
+            }
         })
         ;
 
@@ -1913,16 +1931,6 @@ PYBIND11_MODULE(ft2font, m, py::mod_gil_not_used())
                 FT_CHECK(FT_Render_Glyph, face->glyph, render_mode);
                 return PyPositionedBitmap{face->glyph};
             })
-        .def("_render_glyphs",
-             [](PyFT2Font *self, double x, double y, FT_Render_Mode render_mode) {
-                auto origin = FT_Vector{std::lround(x * 64), std::lround(y * 64)};
-                auto pbs = std::vector<PyPositionedBitmap>{};
-                for (auto &g: self->get_glyphs()) {
-                    FT_CHECK(FT_Glyph_To_Bitmap, &g, render_mode, &origin, 1);
-                    pbs.emplace_back(reinterpret_cast<FT_BitmapGlyph>(g));
-                }
-                return pbs;
-            })
         ;
 
     m.attr("__freetype_version__") = version_string;