foundrytools-cli 1.1.4__tar.gz → 1.1.6__tar.gz

{foundrytools-cli-1.1.4/foundrytools_cli.egg-info → foundrytools-cli-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foundrytools-cli
-Version: 1.1.4
+Version: 1.1.6
 Summary: A set of command line tools to inspect, manipulate and convert font files
 Home-page: https://github.com/ftCLI/FoundryTools-CLI
 Author: ftCLI
@@ -10,11 +10,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: afdko>=4.0.0
-Requires-Dist: fonttools>=4.44.3
+Requires-Dist: afdko>=4.0.1
+Requires-Dist: fonttools>=4.47.2
 Requires-Dist: brotli>=1.1.0
 Requires-Dist: click>=8.1.7
-Requires-Dist: cffsubr>=0.2.9.post1
+Requires-Dist: cffsubr>=0.3.0
 Requires-Dist: dehinter>=4.0.0
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: pathvalidate>=3.2.0

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundryToolsCLI/CLI/ftcli_cff.py

@@ -33,6 +33,7 @@ tbl_cff = click.Group("subcommands")
     "--copyright", "Copyright", is_flag=True, help="Deletes CFF.cff.topDictIndex[0] Copyright"
 )
 @click.option("--notice", "Notice", is_flag=True, help="Deletes CFF.cff.topDictIndex[0] Copyright")
+@click.option("--unique-id", "UniqueID", is_flag=True, help="Deletes CFF.cff.topDictIndex[0] UniqueID")
 @add_recursive_option()
 @add_common_options()
 @Timer(logger=logger.info)

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundryToolsCLI/CLI/ftcli_otf.py

@@ -4,6 +4,7 @@ from typing import Optional, List
 
 import click
 from fontTools.misc.cliTools import makeOutputFileName
+from rich.pretty import pprint
 
 from foundryToolsCLI.Lib.Font import Font
 from foundryToolsCLI.Lib.utils.cli_tools import get_fonts_in_path, initial_check_pass

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundryToolsCLI/Lib/Font.py

@@ -17,6 +17,8 @@ from foundryToolsCLI.Lib.tables.hhea import TableHhea
 from foundryToolsCLI.Lib.tables.name import TableName
 from foundryToolsCLI.Lib.tables.post import TablePost
 from foundryToolsCLI.Lib.utils.otf_tools import correct_otf_contours
+from foundryToolsCLI.Lib.utils.ps_recalc_zones import recalc_zones
+from foundryToolsCLI.Lib.utils.ps_recalc_stems import recalc_stems
 from foundryToolsCLI.Lib.utils.ttf_tools import correct_ttf_contours, decomponentize
 
 
@@ -505,6 +507,55 @@ class Font(TTFont):
     def otf_fix_contours(self, min_area: int = 25, verbose: bool = False) -> None:
         correct_otf_contours(font=self, min_area=min_area, verbose=verbose)
 
+    def otf_recalc_zones(self) -> t.Optional[t.Tuple[t.List[int], t.List[int]]]:
+        """
+        This function recalculates the zones of an OpenType font.
+        """
+        if not self.is_otf:
+            return
+
+        zones = recalc_zones(font=self)
+        return zones
+
+    def otf_recalc_stems(self) -> t.Tuple[int, int]:
+        """
+        This function recalculates the stems of an OpenType font.
+        """
+        if not self.is_otf:
+            raise ValueError("The font is not an OpenType font.")
+        if not hasattr(self.reader, "file"):
+            raise ValueError("The font is not a file-backed font.")
+
+        stems = recalc_stems(file_path=Path(self.reader.file.name))
+        return stems
+
+    def set_zones(self, other_blues: t.List[int], blue_values: t.List[int]) -> None:
+        """
+        Set zones for a font.
+
+        :param other_blues: Other blues.
+        :param blue_values: Blue values.
+        """
+        if not self.is_otf:
+            raise NotImplementedError("Setting zones is only supported for PostScript fonts.")
+
+        self["CFF "].cff.topDictIndex[0].Private.BlueValues = blue_values
+        self["CFF "].cff.topDictIndex[0].Private.OtherBlues = other_blues
+
+    def set_stems(self, std_h_w: int, std_v_w: int) -> None:
+        """
+        Set stems for a font.
+
+        :param std_h_w: StdHW.
+        :param std_v_w: StdVW.
+        """
+        if not self.is_otf:
+            raise NotImplementedError("Setting stems is only supported for PostScript fonts.")
+
+        self["CFF "].cff.topDictIndex[0].Private.StdHW = std_h_w
+        self["CFF "].cff.topDictIndex[0].Private.StdVW = std_v_w
+
+
     def ttf_fix_contours(
         self, min_area: int = 25, remove_hinting: bool = True, verbose: bool = False
     ) -> None:

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundryToolsCLI/Lib/converters/ttf_to_otf.py

@@ -86,8 +86,15 @@ class TTF2OTFRunner(object):
                 cff_font.save(output_file)
                 cff_font = Font(output_file, recalcTimestamp=False)
                 cff_font.otf_fix_contours(min_area=25, verbose=False)
+
                 if self.options.subroutinize:
                     cff_font.otf_subroutinize()
+
+                other_blues, blue_values = cff_font.otf_recalc_zones()
+                cff_font.set_zones(other_blues=other_blues, blue_values=blue_values)
+                std_h_w, std_v_w = cff_font.otf_recalc_stems()
+                cff_font.set_stems(std_h_w=std_h_w, std_v_w=std_v_w)
+
                 cff_font.save(output_file)
                 cff_font.close()
 

foundrytools-cli-1.1.6/foundryToolsCLI/Lib/utils/ps_recalc_stems.py

@@ -0,0 +1,92 @@
+import typing as t
+
+from pathlib import Path
+
+from afdko.otfautohint.__main__ import ReportOptions, get_stemhist_options, _validate_path
+from afdko.otfautohint.autohint import fontWrapper, FontInstance, openFont
+from afdko.otfautohint.hinter import glyphHinter
+from afdko.otfautohint.report import Report
+
+H_STEM_GLYPHS = ["A", "H", "T", "S", "C", "O"]
+V_STEM_GLYPHS = ["E", "H", "I", "K", "L", "M", "N", "T", "U"]
+
+__all__ = ["get_stems", "recalc_stems"]
+
+
+def get_stems(
+    file_path: Path, glyph_list: t.List[str]
+) -> t.Tuple[t.List[t.Tuple[int, int, t.List[str]]], t.List[t.Tuple[int, int, t.List[str]]]]:
+    """
+    Retrieves stem data from a font file for a given list of glyphs.
+
+    Parameters:
+        file_path`: The path to the font file.
+        glyph_list`: A list of glyph names for which stem data will be
+        retrieved.
+
+    Returns:
+        Tuple: a tuple containing two lists: the first list contains the horizontal stem data,
+        and the second list contains the vertical stem data. Each list contains tuples of the
+        form (stem width, stem count, glyph names).
+    """
+    file_path = _validate_path(file_path)
+    _, parsed_args = get_stemhist_options(args=[file_path])
+    options = ReportOptions(parsed_args)
+    options.report_all_stems = True
+    options.report_zones = False
+    options.glyphList = glyph_list
+
+    font = openFont(file_path, options=options)
+    font_instance = FontInstance(font=font, inpath=file_path, outpath=file_path)
+
+    fw = fontWrapper(options=options, fil=[font_instance])
+    dict_record = fw.dictManager.getDictRecord()
+
+    hinter = glyphHinter(options=options, dictRecord=dict_record)
+    hinter.initialize(options=options, dictRecord=dict_record)
+    gmap = map(hinter.hint, fw)
+
+    report = Report()
+    for name, r in gmap:
+        report.glyphs[name] = r
+
+    h_stems, v_stems, _, _ = report._get_lists(options)
+    h_stems.sort(key=report._sort_count)
+    v_stems.sort(key=report._sort_count)
+
+    return h_stems, v_stems
+
+
+def recalc_stems(
+    file_path: Path,
+    h_stems_glyphs: t.Optional[t.List[str]] = None,
+    v_stems_glyphs: t.Optional[t.List[str]] = None,
+) -> t.Tuple[int, int]:
+    """
+    Recalculates the StdHW and StdVW values for a given font file.
+
+    Parameters:
+        file_path: A `Path` object representing the path to the file.
+        h_stems_glyphs: A list of glyph names to use for calculating the horizontal stems.
+        v_stems_glyphs: A list of glyph names to use for calculating the vertical stems.
+
+    Returns:
+        A tuple containing the recalculated stem values for horizontal and vertical stems. The first
+        value in the tuple represents the horizontal stem value, and the second value represents the
+        vertical stem value.
+    """
+
+    if h_stems_glyphs is None:
+        h_stems_glyphs = H_STEM_GLYPHS
+    if v_stems_glyphs is None:
+        v_stems_glyphs = V_STEM_GLYPHS
+
+    h_stems, _ = get_stems(file_path=file_path, glyph_list=h_stems_glyphs)
+    _, v_stems = get_stems(file_path=file_path, glyph_list=v_stems_glyphs)
+
+    if not h_stems:
+        raise ValueError("No horizontal stems found")
+    if not v_stems:
+        raise ValueError("No vertical stems found")
+
+    return int(h_stems[0][1]), int(v_stems[0][1])

foundrytools-cli-1.1.6/foundryToolsCLI/Lib/utils/ps_recalc_zones.py

@@ -0,0 +1,246 @@
+import typing as t
+from collections import Counter
+
+from fontTools.pens.boundsPen import BoundsPen
+from fontTools.ttLib.ttFont import TTFont
+
+UPPERCASE_LETTERS = [chr(i) for i in range(65, 91)]  # A-Z
+UPPERCASE_DESCENDERS = ["J", "Q"]
+LOWERCASE_LETTERS = [chr(i) for i in range(97, 123)]  # a-z
+LOWERCASE_DESCENDERS = ["f", "g", "j", "p", "q", "y"]
+LOWERCASE_ASCENDERS = ["b", "d", "f", "h", "k", "l", "t"]
+
+DESCENDER_GLYPHS = list(set(LOWERCASE_DESCENDERS) - {"f", "j"})
+BASELINE_GLYPHS = list(
+    set(UPPERCASE_LETTERS + LOWERCASE_LETTERS)
+    - set(LOWERCASE_DESCENDERS)
+    - set(UPPERCASE_DESCENDERS)
+)
+X_HEIGHT_GLYPHS = list(set(LOWERCASE_LETTERS) - set(LOWERCASE_ASCENDERS + ["i", "j"]))
+UPPERCASE_GLYPHS = UPPERCASE_LETTERS
+ASCENDER_GLYPHS = list(set(LOWERCASE_ASCENDERS) - {"t"})
+
+
+__all__ = ["recalc_zones", "GlyphBounds"]
+
+
+class GlyphBounds(t.TypedDict):
+    """
+    A type representing the bounds of a glyph.
+    """
+
+    xMin: float
+    yMin: float
+    xMax: float
+    yMax: float
+
+
+def get_glyph_bounds(font: TTFont, glyph_name: str) -> GlyphBounds:
+    """
+    Get the bounds of a glyph.
+
+    Parameters:
+        font (TTFont): The TTFont object.
+        glyph_name (str): The name of the glyph.
+
+    Returns:
+        GlyphBounds: The bounds of the glyph.
+
+    Raises:
+        ValueError: If the glyph does not exist in the font.
+    """
+    glyph_set = font.getGlyphSet()
+    if glyph_name not in glyph_set:
+        raise ValueError(f"Glyph '{glyph_name}' does not exist in the font.")
+
+    bounds_pen = BoundsPen(glyphSet=glyph_set)
+
+    glyph_set[glyph_name].draw(bounds_pen)
+    bounds = GlyphBounds(
+        xMin=bounds_pen.bounds[0],
+        yMin=bounds_pen.bounds[1],
+        xMax=bounds_pen.bounds[2],
+        yMax=bounds_pen.bounds[3],
+    )
+
+    return bounds
+
+
+def get_glyph_bounds_many(font: TTFont, glyph_names: t.List[str]) -> t.Dict[str, GlyphBounds]:
+    """
+    Get the bounds of multiple glyphs in a given font.
+
+    Parameters:
+        font (TTFont): The TTFont object.
+        glyph_names (List[str]): A list of glyph names.
+
+    Returns:
+        dict: A dictionary containing glyph names as keys and GlyphBounds objects as values.
+    """
+    glyphs_bounds = {}
+    for glyph_name in glyph_names:
+        try:
+            bounds = get_glyph_bounds(font=font, glyph_name=glyph_name)
+            glyphs_bounds[glyph_name] = bounds
+        except ValueError:
+            pass
+
+    return glyphs_bounds
+
+
+def get_pair(counter: Counter) -> t.List[float]:
+    """
+    Get the two most common elements from the given counter.
+
+    Parameters:
+        counter (Counter): The counter object containing elements and their counts.
+
+    Returns:
+        List[float]: List containing the pair of most common elements.
+    """
+    most_common = counter.most_common(2)
+    if len(counter) == 1:
+        return [most_common[0][0], most_common[0][0]]
+    return sorted([most_common[0][0], most_common[1][0]])
+
+
+def lists_overlaps(lists: t.List[t.List[float]]) -> bool:
+    """
+    Check if there are overlapping intervals in a list of lists.
+
+    Args:
+        lists (List[List[float]]): A list of lists, where each inner list represents an interval.
+
+    Returns:
+        bool: True if there are overlapping intervals, False otherwise.
+    """
+    for i in range(len(lists) - 1):
+        if lists[i][1] > lists[i + 1][0]:
+            return True
+    return False
+
+
+def fix_lists_overlaps(lists: t.List[t.List[float]]) -> t.List[t.List[float]]:
+    """
+    Fixes overlaps in a list of lists of floats.
+
+    Args:
+        lists (List[List[float]]): A list of lists of floats.
+
+    Returns:
+        List[List[float]]: The input list with any overlaps fixed.
+    """
+    for i in range(len(lists) - 1):
+        if lists[i][1] > lists[i + 1][0]:
+            lists[i + 1][0] = lists[i][1]
+            lists[i + 1] = sorted(lists[i + 1])
+    return lists
+
+
+def fix_min_separation_limits(lists: t.List[t.List[float]], limit: int) -> t.List[t.List[float]]:
+    """
+    Fixes the minimum separation between zones.
+
+    Args:
+        lists (List[List[float]]): A list of lists of floats.
+        limit (int): The minimum separation between zones.
+
+    Returns:
+        List[List[float]]: The input list with the minimum separation between zones fixed.
+    """
+    for i in range(len(lists) - 1):
+        if lists[i + 1][0] - lists[i][1] < limit:
+            # If the difference between the two values is less than 3, then
+            # set the second value to the first value
+            if lists[i + 1][1] - lists[i][1] > limit:
+                lists[i + 1][0] = lists[i + 1][1]
+            else:
+                # Remove the second list
+                lists.pop(i + 1)
+    return lists
+
+
+def calculate_zone(
+    font: TTFont, glyph_names: t.List[str], min_or_max: t.Literal["yMin", "yMax"]
+) -> t.List[float]:
+    """
+    Calculates the minimum and maximum vertical values for a given zone.
+
+    Parameters:
+        font: TTFont object representing the font.
+        glyph_names: List of glyph names to process.
+        min_or_max: Literal specifying whether to process the minimum ('yMin') or maximum ('yMax')
+            values.
+
+    Returns:
+        List of float values representing the minimum or maximum vertical values for each glyph.
+
+    """
+    data = get_glyph_bounds_many(font=font, glyph_names=glyph_names)
+    counter = Counter([v[min_or_max] for v in data.values()])
+    return get_pair(counter)
+
+
+def recalc_zones(
+    font: TTFont,
+    descender_glyphs: t.Optional[t.List[str]] = None,
+    baseline_glyphs: t.Optional[t.List[str]] = None,
+    x_height_glyphs: t.Optional[t.List[str]] = None,
+    uppercase_glyphs: t.Optional[t.List[str]] = None,
+    ascender_glyphs: t.Optional[t.List[str]] = None,
+) -> t.Tuple[t.List[int], t.List[int]]:
+    """
+    Recalc Zones
+
+    Recalculates the zones for a given TTFont object.
+
+    Parameters:
+        font (TTFont): The TTFont object.
+        descender_glyphs (List[str]): A list of glyph names to use for calculating the descender
+            zone.
+        baseline_glyphs (List[str]): A list of glyph names to use for calculating the baseline
+            zone.
+        x_height_glyphs (List[str]): A list of glyph names to use for calculating the x-height
+            zone.
+        uppercase_glyphs (List[str]): A list of glyph names to use for calculating the uppercase
+            zone.
+        ascender_glyphs (List[str]): A list of glyph names to use for calculating the ascender
+            zone.
+
+    Returns:
+        Tuple[List[int], List[int]]: A tuple containing two lists. The first list contains the
+            values for the OtherBlues zones, and the second list contains the values for the
+            BlueValues zones.
+    """
+
+    if descender_glyphs is None:
+        descender_glyphs = DESCENDER_GLYPHS
+    if baseline_glyphs is None:
+        baseline_glyphs = BASELINE_GLYPHS
+    if x_height_glyphs is None:
+        x_height_glyphs = X_HEIGHT_GLYPHS
+    if uppercase_glyphs is None:
+        uppercase_glyphs = UPPERCASE_GLYPHS
+    if ascender_glyphs is None:
+        ascender_glyphs = ASCENDER_GLYPHS
+
+    descender_zone = calculate_zone(font=font, glyph_names=descender_glyphs, min_or_max="yMin")
+    baseline_zone = calculate_zone(font=font, glyph_names=baseline_glyphs, min_or_max="yMin")
+    x_height_zone = calculate_zone(font=font, glyph_names=x_height_glyphs, min_or_max="yMax")
+    uppercase_zone = calculate_zone(font=font, glyph_names=uppercase_glyphs, min_or_max="yMax")
+    ascender_zone = calculate_zone(font=font, glyph_names=ascender_glyphs, min_or_max="yMax")
+
+    zones = sorted([descender_zone, baseline_zone, x_height_zone, uppercase_zone, ascender_zone])
+    if lists_overlaps(zones):
+        zones = fix_lists_overlaps(zones)
+
+    min_separation = font["CFF "].cff.topDictIndex[0].Private.BlueFuzz * 2 + 1
+    zones = fix_min_separation_limits(zones, limit=min_separation)
+
+    other_blues = [int(v) for v in zones[0]]
+
+    blue_values = []
+    for zone in zones[1:]:
+        blue_values.extend([int(v) for v in zone])
+
+    return other_blues, blue_values

foundrytools-cli-1.1.6/foundryToolsCLI/__init__.py

@@ -0,0 +1,3 @@
+VERSION = __version__ = "1.1.6"
+
+__all__ = ["VERSION"]

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6/foundrytools_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foundrytools-cli
-Version: 1.1.4
+Version: 1.1.6
 Summary: A set of command line tools to inspect, manipulate and convert font files
 Home-page: https://github.com/ftCLI/FoundryTools-CLI
 Author: ftCLI
@@ -10,11 +10,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: afdko>=4.0.0
-Requires-Dist: fonttools>=4.44.3
+Requires-Dist: afdko>=4.0.1
+Requires-Dist: fonttools>=4.47.2
 Requires-Dist: brotli>=1.1.0
 Requires-Dist: click>=8.1.7
-Requires-Dist: cffsubr>=0.2.9.post1
+Requires-Dist: cffsubr>=0.3.0
 Requires-Dist: dehinter>=4.0.0
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: pathvalidate>=3.2.0

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundrytools_cli.egg-info/SOURCES.txt

@@ -50,6 +50,8 @@ foundryToolsCLI/Lib/utils/cli_tools.py
 foundryToolsCLI/Lib/utils/click_tools.py
 foundryToolsCLI/Lib/utils/logger.py
 foundryToolsCLI/Lib/utils/otf_tools.py
+foundryToolsCLI/Lib/utils/ps_recalc_stems.py
+foundryToolsCLI/Lib/utils/ps_recalc_zones.py
 foundryToolsCLI/Lib/utils/skia_tools.py
 foundryToolsCLI/Lib/utils/text_tools.py
 foundryToolsCLI/Lib/utils/timer.py

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/foundrytools_cli.egg-info/requires.txt

@@ -1,8 +1,8 @@
-afdko>=4.0.0
-fonttools>=4.44.3
+afdko>=4.0.1
+fonttools>=4.47.2
 brotli>=1.1.0
 click>=8.1.7
-cffsubr>=0.2.9.post1
+cffsubr>=0.3.0
 dehinter>=4.0.0
 loguru>=0.7.2
 pathvalidate>=3.2.0

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/requirements.txt

@@ -1,9 +1,9 @@
 # Hard pinning here gets relaxed to ">=" in setup.py
-afdko==4.0.0
-fonttools==4.44.3
+afdko==4.0.1
+fonttools==4.47.2
 brotli==1.1.0
 click==8.1.7
-cffsubr==0.2.9.post1
+cffsubr==0.3.0
 dehinter==4.0.0
 loguru==0.7.2
 pathvalidate==3.2.0

{foundrytools-cli-1.1.4 → foundrytools-cli-1.1.6}/setup.py

@@ -18,7 +18,7 @@ def _get_requirements():
 
 setuptools.setup(
     name="foundrytools-cli",
-    version="1.1.4",
+    version="1.1.6",
     description="A set of command line tools to inspect, manipulate and convert font files",
     long_description=long_description,
     long_description_content_type="text/markdown",

foundrytools-cli-1.1.4/foundryToolsCLI/__init__.py

@@ -1,3 +0,0 @@
-VERSION = __version__ = "1.1.4"
-
-__all__ = ["VERSION"]