initial implementation of direction sub-command

Author: chrissimpkins

lib/pathins/direction.py

@@ -1,21 +1,25 @@
 import argparse
+from typing import Sequence, Tuple
 
 import pathops  # type: ignore
 from fontTools.ttLib import TTFont  # type: ignore
+from fontTools.ttLib.tables._g_l_y_f import Glyph  # type: ignore
 
 from .bridge import ttfont_glyph_to_skia_path
 from .stringbuilder import direction_result
 from .validators import validate_fontpath, validate_glyph_in_font
 
-# TODO: add --check support to confirm all paths in same direction
 # TODO: add --summary to include total CW and CCW directions
 
 
 def direction_run(args: argparse.Namespace) -> None:
     """
     Displays the direction of the outermost contour of one
     or more glyphs in a font.  Results are expressed as either
-    "clockwise" or "counter-clockwise".
+    "clockwise" or "counter-clockwise".  The report includes
+    the x, y scaling factors for transfomed components of
+    composite glyphs.  This scaling *may* reverse the path
+    direction that is reported for the decomposed outline.
     """
     fontpath: str = args.fontpath
     glyphname: str = args.glyphname
@@ -32,23 +36,68 @@ def direction_run(args: argparse.Namespace) -> None:
     if glyphname:
         validate_glyph_in_font(glyphname, tt)
         skia_path = ttfont_glyph_to_skia_path(glyphname, tt)
+
+        # transformed components can change path direction
+        # in the decomposed paths
+        # (e.g. 180 degree Y-axis rotation = mirroring)
+        # add base component glyph name and transform values
+        # to the report if this is present
+        glyph = tt["glyf"][glyphname]
+        components_with_transforms: Sequence[Tuple] = []
+        if glyph.isComposite():
+            components_with_transforms = _get_components_with_transforms(glyph)
+
         print(
             direction_result(
                 glyphname,
                 skia_path.clockwise,
                 len(list(skia_path.contours)),
+                components_with_transforms=components_with_transforms,
                 nocolor=args.nocolor,
             )
         )
     else:
         glyph_names = tt.getGlyphOrder()
         for local_glyphname in glyph_names:
+            glyph = tt["glyf"][local_glyphname]
+            components_with_transforms = []
+
+            # transformed components can change path direction
+            # in the decomposed paths
+            # (e.g. 180 degree Y-axis rotation = mirroring)
+            # add base component glyph name and transform values
+            # to the report if this is present
+            if glyph.isComposite():
+                components_with_transforms = _get_components_with_transforms(glyph)
+
             skia_path = ttfont_glyph_to_skia_path(local_glyphname, tt)  # type: ignore
+
             print(
                 direction_result(
                     str(local_glyphname),
                     skia_path.clockwise,
                     len(list(skia_path.contours)),
+                    components_with_transforms=components_with_transforms,
                     nocolor=args.nocolor,
                 )
             )
+
+
+def _get_components_with_transforms(glyph: Glyph) -> Sequence[Tuple]:
+    """
+    Returns list with component glyph names and x,y transforms
+    for composite glyphs with transforms. In all other cases,
+    returns an empty list
+    """
+    components_with_transforms = []
+    if glyph.isComposite():
+        for component in glyph.components:
+            if hasattr(component, "transform"):
+                a1 = round(component.transform[0][0], 3)
+                a2 = round(component.transform[0][1], 3)
+                b1 = round(component.transform[1][0], 3)
+                b2 = round(component.transform[1][1], 3)
+                components_with_transforms.append(
+                    (component.glyphName, [[a1, a2], [b1, b2]])
+                )
+    return components_with_transforms

lib/pathins/stringbuilder.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from typing import Dict, Text
+from typing import Dict, Sequence, Text, Tuple
 
 ansicolors: Dict[Text, Text] = {
     "BLACK": "\033[30m",
@@ -59,19 +59,56 @@ def overlap_result(glyphname: str, test_pass: bool, nocolor=False) -> str:
 
 
 def direction_result(
-    glyphname: str, direction_clockwise: bool, contours: int, nocolor=False
+    glyphname: str,
+    direction_clockwise: bool,
+    contours: int,
+    components_with_transforms: Sequence[Tuple] = [],
+    nocolor=False,
 ) -> str:
     if not nocolor and sys.stdout.isatty():
         if contours == 0:
             return f"[ {light_cyan_start}{glyphname}{reset} ]: no contours"
         if direction_clockwise:
-            return f"[ {light_cyan_start}{glyphname}{reset} ]: clockwise"
+            return (
+                f"[ {light_cyan_start}{glyphname}{reset} ]: "
+                f"clockwise"
+                f"{_transformed_component(components_with_transforms)}"
+            )
         else:
-            return f"[ {light_cyan_start}{glyphname}{reset} ]: counter-clockwise"
+            return (
+                f"[ {light_cyan_start}{glyphname}{reset} ]: "
+                f"counter-clockwise"
+                f"{_transformed_component(components_with_transforms)}"
+            )
     else:
         if contours == 0:
             return f"[ {glyphname} ]: no contours"
         if direction_clockwise:
-            return f"[ {glyphname} ]: clockwise"
+            return (
+                f"[ {glyphname} ]: clockwise"
+                f"{_transformed_component(components_with_transforms)}"
+            )
         else:
-            return f"[ {glyphname} ]: counter-clockwise"
+            return (
+                f"[ {glyphname} ]: counter-clockwise"
+                f"{_transformed_component(components_with_transforms)}"
+            )
+
+
+def _transformed_component(components_with_transforms: Sequence[Tuple]) -> str:
+    if len(components_with_transforms) > 0:
+        left_pad = " " * 10
+        components_string = f"{os.linesep}"
+        for x, component in enumerate(components_with_transforms):
+            component_glyphname = component[0]
+            component_transform = component[1]
+            components_string += (
+                f"{left_pad}with component '{component_glyphname}' transform: "
+                f"{component_transform}"
+            )
+            if x + 1 < len(components_with_transforms):
+                # add newline unless this is the last component in the list
+                components_string += f"{os.linesep}"
+        return components_string
+    else:
+        return ""