backend_svg: separate font attributes && use translate(x y) in RendedSVG._draw_text_as_path

fixed linting (flake8 test failing)

Fixed checks in testing for svg.fonttype = none

fixed flake8 && failing tests

linting

modified tspans && fix to svg tests

Updated baseline images for svg tests

Update lib/matplotlib/testing/compare.py

nicer regex to check if font syling in svg is specified

Co-authored-by: Tim Hoffmann <[email protected]>

Apply suggestions from code review

More concise font testing in test_backend_svg.py

Co-authored-by: Tim Hoffmann <[email protected]>

Update lib/matplotlib/tests/test_mathtext.py

Co-authored-by: Tim Hoffmann <[email protected]>

Update backend_svg.py

inlining `style`

restored test images

update to baseline images

Fix to regex for testing/compare.py::compare

forgot one baseline image

Author: LorenzoPeri17

lib/matplotlib/backends/backend_svg.py

@@ -1066,12 +1066,13 @@ def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath, mtext=None):
             self._update_glyph_map_defs(glyph_map_new)
 
             for glyph_id, xposition, yposition, scale in glyph_info:
-                attrib = {'xlink:href': f'#{glyph_id}'}
-                if xposition != 0.0:
-                    attrib['x'] = _short_float_fmt(xposition)
-                if yposition != 0.0:
-                    attrib['y'] = _short_float_fmt(yposition)
-                writer.element('use', attrib=attrib)
+                writer.element(
+                    'use',
+                    transform=_generate_transform([
+                        ('translate', (xposition, yposition)),
+                        ('scale', (scale,)),
+                        ]),
+                    attrib={'xlink:href': f'#{glyph_id}'})
 
         else:
             if ismath == "TeX":
@@ -1109,25 +1110,26 @@ def _draw_text_as_text(self, gc, x, y, s, prop, angle, ismath, mtext=None):
         writer = self.writer
 
         color = rgb2hex(gc.get_rgb())
-        style = {}
+        font_style = {}
+        color_style = {}
         if color != '#000000':
-            style['fill'] = color
+            color_style['fill'] = color
 
         alpha = gc.get_alpha() if gc.get_forced_alpha() else gc.get_rgb()[3]
         if alpha != 1:
-            style['opacity'] = _short_float_fmt(alpha)
+            color_style['opacity'] = _short_float_fmt(alpha)
 
         if not ismath:
             attrib = {}
 
-            font_parts = []
+            # Separate font style in their separate attributes
             if prop.get_style() != 'normal':
-                font_parts.append(prop.get_style())
+                font_style['font-style'] = prop.get_style()
             if prop.get_variant() != 'normal':
-                font_parts.append(prop.get_variant())
+                font_style['font-variant'] = prop.get_variant()
             weight = fm.weight_dict[prop.get_weight()]
             if weight != 400:
-                font_parts.append(f'{weight}')
+                font_style['font-weight'] = f'{weight}'
 
             def _normalize_sans(name):
                 return 'sans-serif' if name in ['sans', 'sans serif'] else name
@@ -1150,15 +1152,15 @@ def _get_all_quoted_names(prop):
                         for entry in prop.get_family()
                         for name in _expand_family_entry(entry)]
 
-            font_parts.extend([
-                f'{_short_float_fmt(prop.get_size())}px',
-                # ensure expansion, quoting, and dedupe of font names
-                ", ".join(dict.fromkeys(_get_all_quoted_names(prop)))
-            ])
-            style['font'] = ' '.join(font_parts)
+            font_style['font-size'] = f'{_short_float_fmt(prop.get_size())}px'
+            # ensure expansion, quoting, and dedupe of font names
+            font_style['font-family'] = ", ".join(
+                dict.fromkeys(_get_all_quoted_names(prop))
+                )
+
             if prop.get_stretch() != 'normal':
-                style['font-stretch'] = prop.get_stretch()
-            attrib['style'] = _generate_css(style)
+                font_style['font-stretch'] = prop.get_stretch()
+            attrib['style'] = _generate_css({**font_style, **color_style})
 
             if mtext and (angle == 0 or mtext.get_rotation_mode() == "anchor"):
                 # If text anchoring can be supported, get the original
@@ -1180,11 +1182,11 @@ def _get_all_quoted_names(prop):
 
                 ha_mpl_to_svg = {'left': 'start', 'right': 'end',
                                  'center': 'middle'}
-                style['text-anchor'] = ha_mpl_to_svg[mtext.get_ha()]
+                font_style['text-anchor'] = ha_mpl_to_svg[mtext.get_ha()]
 
                 attrib['x'] = _short_float_fmt(ax)
                 attrib['y'] = _short_float_fmt(ay)
-                attrib['style'] = _generate_css(style)
+                attrib['style'] = _generate_css({**font_style, **color_style})
                 attrib['transform'] = _generate_transform([
                     ("rotate", (-angle, ax, ay))])
 
@@ -1204,7 +1206,7 @@ def _get_all_quoted_names(prop):
             # Apply attributes to 'g', not 'text', because we likely have some
             # rectangles as well with the same style and transformation.
             writer.start('g',
-                         style=_generate_css(style),
+                         style=_generate_css({**font_style, **color_style}),
                          transform=_generate_transform([
                              ('translate', (x, y)),
                              ('rotate', (-angle,))]),
@@ -1216,43 +1218,32 @@ def _get_all_quoted_names(prop):
             spans = {}
             for font, fontsize, thetext, new_x, new_y in glyphs:
                 entry = fm.ttfFontProperty(font)
-                font_parts = []
+                font_style = {}
+                # Separate font style in its separate attributes
                 if entry.style != 'normal':
-                    font_parts.append(entry.style)
+                    font_style['font-style'] = entry.style
                 if entry.variant != 'normal':
-                    font_parts.append(entry.variant)
+                    font_style['font-variant'] = entry.variant
                 if entry.weight != 400:
-                    font_parts.append(f'{entry.weight}')
-                font_parts.extend([
-                    f'{_short_float_fmt(fontsize)}px',
-                    f'{entry.name!r}',  # ensure quoting
-                ])
-                style = {'font': ' '.join(font_parts)}
+                    font_style['font-weight'] = f'{entry.weight}'
+                font_style['font-size'] = f'{_short_float_fmt(fontsize)}px'
+                font_style['font-family'] = f'{entry.name!r}'  # ensure quoting
                 if entry.stretch != 'normal':
-                    style['font-stretch'] = entry.stretch
-                style = _generate_css(style)
+                    font_style['font-stretch'] = entry.stretch
+                style = _generate_css({**font_style, **color_style})
                 if thetext == 32:
                     thetext = 0xa0  # non-breaking space
                 spans.setdefault(style, []).append((new_x, -new_y, thetext))
 
             for style, chars in spans.items():
-                chars.sort()
-
-                if len({y for x, y, t in chars}) == 1:  # Are all y's the same?
-                    ys = str(chars[0][1])
-                else:
-                    ys = ' '.join(str(c[1]) for c in chars)
-
-                attrib = {
-                    'style': style,
-                    'x': ' '.join(_short_float_fmt(c[0]) for c in chars),
-                    'y': ys
-                    }
-
-                writer.element(
-                    'tspan',
-                    ''.join(chr(c[2]) for c in chars),
-                    attrib=attrib)
+                chars.sort()  # Sort by increasing x position
+                for x, y, t in chars:  # Output one tspan for each character
+                    writer.element(
+                        'tspan',
+                        chr(t),
+                        x=_short_float_fmt(x),
+                        y=_short_float_fmt(y),
+                        style=style)
 
             writer.end('text')
 

lib/matplotlib/testing/compare.py

@@ -13,6 +13,7 @@
 import sys
 from tempfile import TemporaryDirectory, TemporaryFile
 import weakref
+import re
 
 import numpy as np
 from PIL import Image
@@ -305,7 +306,15 @@ def convert(filename, cache):
             # re-generate any SVG test files using this mode, or else such tests will
             # fail to use the converter for the expected images (but will for the
             # results), and the tests will fail strangely.
-            if 'style="font:' in contents:
+            if re.search(
+                # searches for attributes :
+                #   style=[font|font-size|font-weight|
+                #          font-family|font-variant|font-style]
+                # taking care of the possibility of multiple style attributes
+                # before the font styling (i.e. opacity)
+                r'style="[^"]*font(|-size|-weight|-family|-variant|-style):',
+                contents  # raw contents of the svg file
+                    ):
                 # for svg.fonttype = none, we explicitly patch the font search
                 # path so that fonts shipped by Matplotlib are found.
                 convert = _svg_with_matplotlib_fonts_converter