Snippets/ttf2otf.py - third_party/fonttools - Git at Google

 __doc__ = """
 Convert TrueType flavored fonts to CFF flavored fonts.

 INPUT_PATH argument can be a file or a directory. If it is a directory, all the TrueType
 flavored fonts found in the directory will be converted.

 Examples:

     $ ttf2otf font.ttf
     $ ttf2otf font.ttf -o output_dir
     $ ttf2otf fonts_dir
     $ ttf2otf fonts_dir -r
     $ ttf2otf fonts_dir -o output_dir
     $ ttf2otf fonts_dir -o output_dir --no-overwrite
     $ ttf2otf fonts_dir -o output_dir --max-err 0.5
     $ ttf2otf fonts_dir -o output_dir --new-upem 1000
     $ ttf2otf fonts_dir -o output_dir --correct-contours
 """

 import argparse
 import logging
 import sys
 import typing as t
 from pathlib import Path

 import pathops
 from cffsubr import subroutinize as subr
 from fontTools import configLogger
 from fontTools.cffLib import PrivateDict
 from fontTools.fontBuilder import FontBuilder
 from fontTools.misc.cliTools import makeOutputFileName
 from fontTools.misc.psCharStrings import T2CharString
 from fontTools.misc.roundTools import otRound
 from fontTools.pens.cu2quPen import Cu2QuPen
 from fontTools.pens.qu2cuPen import Qu2CuPen
 from fontTools.pens.recordingPen import DecomposingRecordingPen
 from fontTools.pens.t2CharStringPen import T2CharStringPen
 from fontTools.pens.ttGlyphPen import TTGlyphPen
 from fontTools.ttLib import TTFont, TTLibError
 from fontTools.ttLib.scaleUpem import scale_upem

 log = logging.getLogger(__name__)


 def decomponentize_tt(font: TTFont) -> None:
     """
     Decomposes all composite glyphs of a TrueType font.
     """
     if not font.sfntVersion == "\x00\x01\x00\x00":
         raise NotImplementedError(
             "Decomponentization is only supported for TrueType fonts."
         )

     glyph_set = font.getGlyphSet()
     glyf_table = font["glyf"]
     dr_pen = DecomposingRecordingPen(glyphSet=glyph_set)
     tt_pen = TTGlyphPen(glyphSet=None)

     for glyph_name in font.glyphOrder:
         glyph = glyf_table[glyph_name]
         if not glyph.isComposite():
             continue
         dr_pen.value = []
         tt_pen.init()
         glyph.draw(dr_pen, glyf_table)
         dr_pen.replay(tt_pen)
         glyf_table[glyph_name] = tt_pen.glyph()


 def skia_path_from_charstring(charstring: T2CharString) -> pathops.Path:
     """
     Get a Skia path from a T2CharString.
     """
     path = pathops.Path()
     path_pen = path.getPen(glyphSet=None)
     charstring.draw(path_pen)
     return path


 def charstring_from_skia_path(path: pathops.Path, width: int) -> T2CharString:
     """
     Get a T2CharString from a Skia path.
     """
     t2_pen = T2CharStringPen(width=width, glyphSet=None)
     path.draw(t2_pen)
     return t2_pen.getCharString()


 def round_path(
     path: pathops.Path, rounder: t.Callable[[float], float] = otRound
 ) -> pathops.Path:
     """
     Rounds the points coordinate of a ``pathops.Path``

     Args:
         path (pathops.Path): The ``pathops.Path``
         rounder (Callable[[float], float], optional): The rounding function. Defaults to otRound.

     Returns:
         pathops.Path: The rounded path
     """

     rounded_path = pathops.Path()
     for verb, points in path:
         rounded_path.add(verb, *((rounder(p[0]), rounder(p[1])) for p in points))
     return rounded_path


 def simplify_path(path: pathops.Path, glyph_name: str, clockwise: bool) -> pathops.Path:
     """
     Simplify a ``pathops.Path by`` removing overlaps, fixing contours direction and, optionally,
     removing tiny paths

     Args:
         path (pathops.Path): The ``pathops.Path`` to simplify
         glyph_name (str): The glyph name
         clockwise (bool): The winding direction. Must be ``True`` for TrueType glyphs and ``False``
             for OpenType-PS fonts.

     Returns:
         pathops.Path: The simplified path
     """

     try:
         return pathops.simplify(path, fix_winding=True, clockwise=clockwise)
     except pathops.PathOpsError:
         pass

     path = round_path(path)
     try:
         path = pathops.simplify(path, fix_winding=True, clockwise=clockwise)
         return path
     except pathops.PathOpsError as e:
         raise pathops.PathOpsError(
             f"Failed to simplify path for glyph {glyph_name}: {e}"
         )


 def quadratics_to_cubics(
     font: TTFont, tolerance: float = 1.0, correct_contours: bool = False
 ) -> t.Dict[str, T2CharString]:
     """
     Get CFF charstrings using Qu2CuPen

     Args:
         font (TTFont): The TTFont object.
         tolerance (float, optional): The tolerance for the conversion. Defaults to 1.0.
         correct_contours (bool, optional): Whether to correct the contours with pathops. Defaults to
             False.

     Returns:
         tuple: A tuple containing the list of failed glyphs and the T2 charstrings.
     """

     qu2cu_charstrings = {}
     glyph_set = font.getGlyphSet()

     for k, v in glyph_set.items():
         width = v.width

         try:
             t2_pen = T2CharStringPen(width=width, glyphSet={k: v})
             qu2cu_pen = Qu2CuPen(
                 t2_pen, max_err=tolerance, all_cubic=True, reverse_direction=True
             )
             glyph_set[k].draw(qu2cu_pen)
             qu2cu_charstrings[k] = t2_pen.getCharString()

         except NotImplementedError:
             # Workaround for "oncurve-less contours with all_cubic not implemented"
             temp_t2_pen = T2CharStringPen(width=width, glyphSet=None)
             glyph_set[k].draw(temp_t2_pen)
             t2_charstring = temp_t2_pen.getCharString()
             t2_charstring.private = PrivateDict()

             tt_pen = TTGlyphPen(glyphSet=None)
             cu2qu_pen = Cu2QuPen(
                 other_pen=tt_pen, max_err=tolerance, reverse_direction=False
             )
             t2_charstring.draw(cu2qu_pen)
             tt_glyph = tt_pen.glyph()

             t2_pen = T2CharStringPen(width=width, glyphSet=None)
             qu2cu_pen = Qu2CuPen(
                 t2_pen, max_err=tolerance, all_cubic=True, reverse_direction=True
             )
             tt_glyph.draw(pen=qu2cu_pen, glyfTable=None)
             log.warning(
                 f"Failed to convert glyph '{k}' to cubic at first attempt, but succeeded at second "
                 f"one."
             )

         charstring = t2_pen.getCharString()

         if correct_contours:
             charstring.private = PrivateDict()
             path = skia_path_from_charstring(charstring)
             simplified_path = simplify_path(path, glyph_name=k, clockwise=False)
             charstring = charstring_from_skia_path(path=simplified_path, width=width)

         qu2cu_charstrings[k] = charstring

     return qu2cu_charstrings


 def build_font_info_dict(font: TTFont) -> t.Dict[str, t.Any]:
     """
     Builds CFF topDict from a TTFont object.

     Args:
         font (TTFont): The TTFont object.

     Returns:
         dict: The CFF topDict.
     """

     font_revision = str(round(font["head"].fontRevision, 3)).split(".")
     major_version = str(font_revision[0])
     minor_version = str(font_revision[1]).ljust(3, "0")

     name_table = font["name"]
     post_table = font["post"]
     cff_font_info = {
         "version": ".".join([major_version, str(int(minor_version))]),
         "FullName": name_table.getBestFullName(),
         "FamilyName": name_table.getBestFamilyName(),
         "ItalicAngle": post_table.italicAngle,
         "UnderlinePosition": post_table.underlinePosition,
         "UnderlineThickness": post_table.underlineThickness,
         "isFixedPitch": bool(post_table.isFixedPitch),
     }

     return cff_font_info


 def get_post_values(font: TTFont) -> t.Dict[str, t.Any]:
     """
     Setup CFF post table values

     Args:
         font (TTFont): The TTFont object.

     Returns:
         dict: The post table values.
     """
     post_table = font["post"]
     post_info = {
         "italicAngle": otRound(post_table.italicAngle),
         "underlinePosition": post_table.underlinePosition,
         "underlineThickness": post_table.underlineThickness,
         "isFixedPitch": post_table.isFixedPitch,
         "minMemType42": post_table.minMemType42,
         "maxMemType42": post_table.maxMemType42,
         "minMemType1": post_table.minMemType1,
         "maxMemType1": post_table.maxMemType1,
     }
     return post_info


 def get_hmtx_values(
     font: TTFont, charstrings: t.Dict[str, T2CharString]
 ) -> t.Dict[str, t.Tuple[int, int]]:
     """
     Get the horizontal metrics for a font.

     Args:
         font (TTFont): The TTFont object.
         charstrings (dict): The charstrings dictionary.

     Returns:
         dict: The horizontal metrics.
     """
     glyph_set = font.getGlyphSet()
     advance_widths = {k: v.width for k, v in glyph_set.items()}
     lsb = {}
     for gn, cs in charstrings.items():
         lsb[gn] = cs.calcBounds(None)[0] if cs.calcBounds(None) is not None else 0
     metrics = {}
     for gn, advance_width in advance_widths.items():
         metrics[gn] = (advance_width, lsb[gn])
     return metrics


 def build_otf(
     font: TTFont,
     charstrings_dict: t.Dict[str, T2CharString],
     ps_name: t.Optional[str] = None,
     font_info: t.Optional[t.Dict[str, t.Any]] = None,
     private_dict: t.Optional[t.Dict[str, t.Any]] = None,
 ) -> None:
     """
     Builds an OpenType font with FontBuilder.

     Args:
         font (TTFont): The TTFont object.
         charstrings_dict (dict): The charstrings dictionary.
         ps_name (str, optional): The PostScript name of the font. Defaults to None.
         font_info (dict, optional): The font info dictionary. Defaults to None.
         private_dict (dict, optional): The private dictionary. Defaults to None.
     """

     if not ps_name:
         ps_name = font["name"].getDebugName(6)
     if not font_info:
         font_info = build_font_info_dict(font=font)
     if not private_dict:
         private_dict = {}

     fb = FontBuilder(font=font)
     fb.isTTF = False
     ttf_tables = ["glyf", "cvt ", "loca", "fpgm", "prep", "gasp", "LTSH", "hdmx"]
     for table in ttf_tables:
         if table in font:
             del font[table]
     fb.setupGlyphOrder(font.getGlyphOrder())
     fb.setupCFF(
         psName=ps_name,
         charStringsDict=charstrings_dict,
         fontInfo=font_info,
         privateDict=private_dict,
     )
     metrics = get_hmtx_values(font=fb.font, charstrings=charstrings_dict)
     fb.setupHorizontalMetrics(metrics)
     fb.setupDummyDSIG()
     fb.setupMaxp()
     post_values = get_post_values(font=fb.font)
     fb.setupPost(**post_values)


 def find_fonts(
     input_path: Path, recursive: bool = False, recalc_timestamp: bool = False
 ) -> t.List[TTFont]:
     """
     Returns a list of TTFont objects found in the input path.

     Args:
         input_path (Path): The input file or directory.
         recursive (bool): If input_path is a directory, search for fonts recursively in
             subdirectories.
         recalc_timestamp (bool): Weather to recalculate the font's timestamp on save.

     Returns:
         List[TTFont]: A list of TTFont objects.
     """

     if input_path.is_file():
         files = [input_path]
     elif input_path.is_dir():
         if recursive:
             files = [x for x in input_path.rglob("*") if x.is_file()]
         else:
             files = [x for x in input_path.glob("*") if x.is_file()]
     else:
         raise ValueError("Input path must be a file or directory.")

     fonts = []
     for file in files:
         try:
             font = TTFont(file, recalcTimestamp=recalc_timestamp)
             # Filter out CFF and variable fonts
             if font.sfntVersion == "\x00\x01\x00\x00" and "fvar" not in font:
                 fonts.append(font)
         except (TTLibError, PermissionError):
             pass
     return fonts


 def main(args=None) -> None:
     """
     Convert TrueType flavored fonts to CFF flavored fonts.

     INPUT_PATH argument can be a file or a directory. If it is a directory, all the TrueType
     flavored fonts found in the directory will be converted.
     """

     parser = argparse.ArgumentParser(
         description=__doc__,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     parser.add_argument(
         "input_path",
         type=Path,
         help="The input file or directory.",
     )
     parser.add_argument(
         "-r",
         "--recursive",
         action="store_true",
         help="Search for fonts recursively in subdirectories.",
     )
     parser.add_argument(
         "-o",
         "--output-dir",
         type=Path,
         help="Specify a directory where the output files are to be saved.",
     )
     parser.add_argument(
         "--no-overwrite",
         dest="overwrite",
         action="store_false",
         help="Do not overwrite the output file if it already exists.",
     )
     parser.add_argument(
         "-rt",
         "--recalc-timestamp",
         action="store_true",
         help="Recalculate the font's modified timestamp on save.",
     )
     parser.add_argument(
         "--max-err",
         type=float,
         default=1.0,
         help="The maximum error allowed when converting the font to TrueType.",
     )
     parser.add_argument(
         "--new-upem",
         type=int,
         help="The target UPM to scale the font to.",
     )
     parser.add_argument(
         "--correct-contours",
         action="store_true",
         help="Correct contours with pathops.",
     )
     parser.add_argument(
         "--no-subroutinize",
         dest="subroutinize",
         action="store_false",
         help="Do not subroutinize the converted font.",
     )

     args = parser.parse_args(args)

     input_path = args.input_path
     recursive = args.recursive
     output_dir = args.output_dir
     overwrite = args.overwrite
     recalc_timestamp = args.recalc_timestamp
     max_err = args.max_err
     new_upem = args.new_upem
     correct_contours = args.correct_contours
     subroutinize = args.subroutinize

     fonts = find_fonts(
         input_path, recursive=recursive, recalc_timestamp=recalc_timestamp
     )
     if not fonts:
         log.error("No TrueType flavored fonts found.")
         return

     if output_dir and not output_dir.exists():
         output_dir.mkdir(parents=True)

     for font in fonts:
         with font:
             if font.sfntVersion != "\x00\x01\x00\x00":
                 log.error(f"Font {font.reader.file.name} is not a TrueType font.")
                 continue
             in_file = font.reader.file.name
             log.info(f"Converting {in_file}...")

             log.info("Decomponentizing source font...")
             decomponentize_tt(font)

             if new_upem:
                 log.info(f"Scaling UPM to {new_upem}...")
                 scale_upem(font=font, new_upem=new_upem)

             log.info("Converting to OTF...")
             charstrings_dict = quadratics_to_cubics(
                 font, tolerance=max_err, correct_contours=correct_contours
             )

             ps_name = font["name"].getDebugName(6)
             font_info = build_font_info_dict(font=font)
             private_dict: t.Dict[str, t.Any] = {}
             build_otf(font, charstrings_dict, ps_name, font_info, private_dict)

             os_2_table = font["OS/2"]
             os_2_table.recalcAvgCharWidth(ttFont=font)

             if subroutinize:
                 flavor = font.flavor
                 font.flavor = None
                 log.info("Subroutinizing...")
                 subr(otf=font)
                 font.flavor = flavor

             out_file = makeOutputFileName(
                 input=in_file,
                 outputDir=output_dir,
                 extension=".otf" if font.flavor is None else f".{font.flavor}",
                 suffix=".otf" if font.flavor is not None else "",
                 overWrite=overwrite,
             )
             font.save(out_file)
             log.info(f"File saved to {out_file}")
             print()


 if __name__ == "__main__":
     configLogger(logger=log, level="INFO")
     sys.exit(main())
	__doc__ = """
	Convert TrueType flavored fonts to CFF flavored fonts.

	INPUT_PATH argument can be a file or a directory. If it is a directory, all the TrueType
	flavored fonts found in the directory will be converted.

	Examples:

	$ ttf2otf font.ttf
	$ ttf2otf font.ttf -o output_dir
	$ ttf2otf fonts_dir
	$ ttf2otf fonts_dir -r
	$ ttf2otf fonts_dir -o output_dir
	$ ttf2otf fonts_dir -o output_dir --no-overwrite
	$ ttf2otf fonts_dir -o output_dir --max-err 0.5
	$ ttf2otf fonts_dir -o output_dir --new-upem 1000
	$ ttf2otf fonts_dir -o output_dir --correct-contours
	"""

	import argparse
	import logging
	import sys
	import typing as t
	from pathlib import Path

	import pathops
	from cffsubr import subroutinize as subr
	from fontTools import configLogger
	from fontTools.cffLib import PrivateDict
	from fontTools.fontBuilder import FontBuilder
	from fontTools.misc.cliTools import makeOutputFileName
	from fontTools.misc.psCharStrings import T2CharString
	from fontTools.misc.roundTools import otRound
	from fontTools.pens.cu2quPen import Cu2QuPen
	from fontTools.pens.qu2cuPen import Qu2CuPen
	from fontTools.pens.recordingPen import DecomposingRecordingPen
	from fontTools.pens.t2CharStringPen import T2CharStringPen
	from fontTools.pens.ttGlyphPen import TTGlyphPen
	from fontTools.ttLib import TTFont, TTLibError
	from fontTools.ttLib.scaleUpem import scale_upem

	log = logging.getLogger(__name__)


	def decomponentize_tt(font: TTFont) -> None:
	"""
	Decomposes all composite glyphs of a TrueType font.
	"""
	if not font.sfntVersion == "\x00\x01\x00\x00":
	raise NotImplementedError(
	"Decomponentization is only supported for TrueType fonts."
	)

	glyph_set = font.getGlyphSet()
	glyf_table = font["glyf"]
	dr_pen = DecomposingRecordingPen(glyphSet=glyph_set)
	tt_pen = TTGlyphPen(glyphSet=None)

	for glyph_name in font.glyphOrder:
	glyph = glyf_table[glyph_name]
	if not glyph.isComposite():
	continue
	dr_pen.value = []
	tt_pen.init()
	glyph.draw(dr_pen, glyf_table)
	dr_pen.replay(tt_pen)
	glyf_table[glyph_name] = tt_pen.glyph()


	def skia_path_from_charstring(charstring: T2CharString) -> pathops.Path:
	"""
	Get a Skia path from a T2CharString.
	"""
	path = pathops.Path()
	path_pen = path.getPen(glyphSet=None)
	charstring.draw(path_pen)
	return path


	def charstring_from_skia_path(path: pathops.Path, width: int) -> T2CharString:
	"""
	Get a T2CharString from a Skia path.
	"""
	t2_pen = T2CharStringPen(width=width, glyphSet=None)
	path.draw(t2_pen)
	return t2_pen.getCharString()


	def round_path(
	path: pathops.Path, rounder: t.Callable[[float], float] = otRound
	) -> pathops.Path:
	"""
	Rounds the points coordinate of a ``pathops.Path``

	Args:
	path (pathops.Path): The ``pathops.Path``
	rounder (Callable[[float], float], optional): The rounding function. Defaults to otRound.

	Returns:
	pathops.Path: The rounded path
	"""

	rounded_path = pathops.Path()
	for verb, points in path:
	rounded_path.add(verb, *((rounder(p[0]), rounder(p[1])) for p in points))
	return rounded_path


	def simplify_path(path: pathops.Path, glyph_name: str, clockwise: bool) -> pathops.Path:
	"""
	Simplify a ``pathops.Path by`` removing overlaps, fixing contours direction and, optionally,
	removing tiny paths

	Args:
	path (pathops.Path): The ``pathops.Path`` to simplify
	glyph_name (str): The glyph name
	clockwise (bool): The winding direction. Must be ``True`` for TrueType glyphs and ``False``
	for OpenType-PS fonts.

	Returns:
	pathops.Path: The simplified path
	"""

	try:
	return pathops.simplify(path, fix_winding=True, clockwise=clockwise)
	except pathops.PathOpsError:
	pass

	path = round_path(path)
	try:
	path = pathops.simplify(path, fix_winding=True, clockwise=clockwise)
	return path
	except pathops.PathOpsError as e:
	raise pathops.PathOpsError(
	f"Failed to simplify path for glyph {glyph_name}: {e}"
	)


	def quadratics_to_cubics(
	font: TTFont, tolerance: float = 1.0, correct_contours: bool = False
	) -> t.Dict[str, T2CharString]:
	"""
	Get CFF charstrings using Qu2CuPen

	Args:
	font (TTFont): The TTFont object.
	tolerance (float, optional): The tolerance for the conversion. Defaults to 1.0.
	correct_contours (bool, optional): Whether to correct the contours with pathops. Defaults to
	False.

	Returns:
	tuple: A tuple containing the list of failed glyphs and the T2 charstrings.
	"""

	qu2cu_charstrings = {}
	glyph_set = font.getGlyphSet()

	for k, v in glyph_set.items():
	width = v.width

	try:
	t2_pen = T2CharStringPen(width=width, glyphSet={k: v})
	qu2cu_pen = Qu2CuPen(
	t2_pen, max_err=tolerance, all_cubic=True, reverse_direction=True
	)
	glyph_set[k].draw(qu2cu_pen)
	qu2cu_charstrings[k] = t2_pen.getCharString()

	except NotImplementedError:
	# Workaround for "oncurve-less contours with all_cubic not implemented"
	temp_t2_pen = T2CharStringPen(width=width, glyphSet=None)
	glyph_set[k].draw(temp_t2_pen)
	t2_charstring = temp_t2_pen.getCharString()
	t2_charstring.private = PrivateDict()

	tt_pen = TTGlyphPen(glyphSet=None)
	cu2qu_pen = Cu2QuPen(
	other_pen=tt_pen, max_err=tolerance, reverse_direction=False
	)
	t2_charstring.draw(cu2qu_pen)
	tt_glyph = tt_pen.glyph()

	t2_pen = T2CharStringPen(width=width, glyphSet=None)
	qu2cu_pen = Qu2CuPen(
	t2_pen, max_err=tolerance, all_cubic=True, reverse_direction=True
	)
	tt_glyph.draw(pen=qu2cu_pen, glyfTable=None)
	log.warning(
	f"Failed to convert glyph '{k}' to cubic at first attempt, but succeeded at second "
	f"one."
	)

	charstring = t2_pen.getCharString()

	if correct_contours:
	charstring.private = PrivateDict()
	path = skia_path_from_charstring(charstring)
	simplified_path = simplify_path(path, glyph_name=k, clockwise=False)
	charstring = charstring_from_skia_path(path=simplified_path, width=width)

	qu2cu_charstrings[k] = charstring

	return qu2cu_charstrings


	def build_font_info_dict(font: TTFont) -> t.Dict[str, t.Any]:
	"""
	Builds CFF topDict from a TTFont object.

	Args:
	font (TTFont): The TTFont object.

	Returns:
	dict: The CFF topDict.
	"""

	font_revision = str(round(font["head"].fontRevision, 3)).split(".")
	major_version = str(font_revision[0])
	minor_version = str(font_revision[1]).ljust(3, "0")

	name_table = font["name"]
	post_table = font["post"]
	cff_font_info = {
	"version": ".".join([major_version, str(int(minor_version))]),
	"FullName": name_table.getBestFullName(),
	"FamilyName": name_table.getBestFamilyName(),
	"ItalicAngle": post_table.italicAngle,
	"UnderlinePosition": post_table.underlinePosition,
	"UnderlineThickness": post_table.underlineThickness,
	"isFixedPitch": bool(post_table.isFixedPitch),
	}

	return cff_font_info


	def get_post_values(font: TTFont) -> t.Dict[str, t.Any]:
	"""
	Setup CFF post table values

	Args:
	font (TTFont): The TTFont object.

	Returns:
	dict: The post table values.
	"""
	post_table = font["post"]
	post_info = {
	"italicAngle": otRound(post_table.italicAngle),
	"underlinePosition": post_table.underlinePosition,
	"underlineThickness": post_table.underlineThickness,
	"isFixedPitch": post_table.isFixedPitch,
	"minMemType42": post_table.minMemType42,
	"maxMemType42": post_table.maxMemType42,
	"minMemType1": post_table.minMemType1,
	"maxMemType1": post_table.maxMemType1,
	}
	return post_info


	def get_hmtx_values(
	font: TTFont, charstrings: t.Dict[str, T2CharString]
	) -> t.Dict[str, t.Tuple[int, int]]:
	"""
	Get the horizontal metrics for a font.

	Args:
	font (TTFont): The TTFont object.
	charstrings (dict): The charstrings dictionary.

	Returns:
	dict: The horizontal metrics.
	"""
	glyph_set = font.getGlyphSet()
	advance_widths = {k: v.width for k, v in glyph_set.items()}
	lsb = {}
	for gn, cs in charstrings.items():
	lsb[gn] = cs.calcBounds(None)[0] if cs.calcBounds(None) is not None else 0
	metrics = {}
	for gn, advance_width in advance_widths.items():
	metrics[gn] = (advance_width, lsb[gn])
	return metrics


	def build_otf(
	font: TTFont,
	charstrings_dict: t.Dict[str, T2CharString],
	ps_name: t.Optional[str] = None,
	font_info: t.Optional[t.Dict[str, t.Any]] = None,
	private_dict: t.Optional[t.Dict[str, t.Any]] = None,
	) -> None:
	"""
	Builds an OpenType font with FontBuilder.

	Args:
	font (TTFont): The TTFont object.
	charstrings_dict (dict): The charstrings dictionary.
	ps_name (str, optional): The PostScript name of the font. Defaults to None.
	font_info (dict, optional): The font info dictionary. Defaults to None.
	private_dict (dict, optional): The private dictionary. Defaults to None.
	"""

	if not ps_name:
	ps_name = font["name"].getDebugName(6)
	if not font_info:
	font_info = build_font_info_dict(font=font)
	if not private_dict:
	private_dict = {}

	fb = FontBuilder(font=font)
	fb.isTTF = False
	ttf_tables = ["glyf", "cvt ", "loca", "fpgm", "prep", "gasp", "LTSH", "hdmx"]
	for table in ttf_tables:
	if table in font:
	del font[table]
	fb.setupGlyphOrder(font.getGlyphOrder())
	fb.setupCFF(
	psName=ps_name,
	charStringsDict=charstrings_dict,
	fontInfo=font_info,
	privateDict=private_dict,
	)
	metrics = get_hmtx_values(font=fb.font, charstrings=charstrings_dict)
	fb.setupHorizontalMetrics(metrics)
	fb.setupDummyDSIG()
	fb.setupMaxp()
	post_values = get_post_values(font=fb.font)
	fb.setupPost(**post_values)


	def find_fonts(
	input_path: Path, recursive: bool = False, recalc_timestamp: bool = False
	) -> t.List[TTFont]:
	"""
	Returns a list of TTFont objects found in the input path.

	Args:
	input_path (Path): The input file or directory.
	recursive (bool): If input_path is a directory, search for fonts recursively in
	subdirectories.
	recalc_timestamp (bool): Weather to recalculate the font's timestamp on save.

	Returns:
	List[TTFont]: A list of TTFont objects.
	"""

	if input_path.is_file():
	files = [input_path]
	elif input_path.is_dir():
	if recursive:
	files = [x for x in input_path.rglob("*") if x.is_file()]
	else:
	files = [x for x in input_path.glob("*") if x.is_file()]
	else:
	raise ValueError("Input path must be a file or directory.")

	fonts = []
	for file in files:
	try:
	font = TTFont(file, recalcTimestamp=recalc_timestamp)
	# Filter out CFF and variable fonts
	if font.sfntVersion == "\x00\x01\x00\x00" and "fvar" not in font:
	fonts.append(font)
	except (TTLibError, PermissionError):
	pass
	return fonts


	def main(args=None) -> None:
	"""
	Convert TrueType flavored fonts to CFF flavored fonts.

	INPUT_PATH argument can be a file or a directory. If it is a directory, all the TrueType
	flavored fonts found in the directory will be converted.
	"""

	parser = argparse.ArgumentParser(
	description=__doc__,
	formatter_class=argparse.RawDescriptionHelpFormatter,
	)
	parser.add_argument(
	"input_path",
	type=Path,
	help="The input file or directory.",
	)
	parser.add_argument(
	"-r",
	"--recursive",
	action="store_true",
	help="Search for fonts recursively in subdirectories.",
	)
	parser.add_argument(
	"-o",
	"--output-dir",
	type=Path,
	help="Specify a directory where the output files are to be saved.",
	)
	parser.add_argument(
	"--no-overwrite",
	dest="overwrite",
	action="store_false",
	help="Do not overwrite the output file if it already exists.",
	)
	parser.add_argument(
	"-rt",
	"--recalc-timestamp",
	action="store_true",
	help="Recalculate the font's modified timestamp on save.",
	)
	parser.add_argument(
	"--max-err",
	type=float,
	default=1.0,
	help="The maximum error allowed when converting the font to TrueType.",
	)
	parser.add_argument(
	"--new-upem",
	type=int,
	help="The target UPM to scale the font to.",
	)
	parser.add_argument(
	"--correct-contours",
	action="store_true",
	help="Correct contours with pathops.",
	)
	parser.add_argument(
	"--no-subroutinize",
	dest="subroutinize",
	action="store_false",
	help="Do not subroutinize the converted font.",
	)

	args = parser.parse_args(args)

	input_path = args.input_path
	recursive = args.recursive
	output_dir = args.output_dir
	overwrite = args.overwrite
	recalc_timestamp = args.recalc_timestamp
	max_err = args.max_err
	new_upem = args.new_upem
	correct_contours = args.correct_contours
	subroutinize = args.subroutinize

	fonts = find_fonts(
	input_path, recursive=recursive, recalc_timestamp=recalc_timestamp
	)
	if not fonts:
	log.error("No TrueType flavored fonts found.")
	return

	if output_dir and not output_dir.exists():
	output_dir.mkdir(parents=True)

	for font in fonts:
	with font:
	if font.sfntVersion != "\x00\x01\x00\x00":
	log.error(f"Font {font.reader.file.name} is not a TrueType font.")
	continue
	in_file = font.reader.file.name
	log.info(f"Converting {in_file}...")

	log.info("Decomponentizing source font...")
	decomponentize_tt(font)

	if new_upem:
	log.info(f"Scaling UPM to {new_upem}...")
	scale_upem(font=font, new_upem=new_upem)

	log.info("Converting to OTF...")
	charstrings_dict = quadratics_to_cubics(
	font, tolerance=max_err, correct_contours=correct_contours
	)

	ps_name = font["name"].getDebugName(6)
	font_info = build_font_info_dict(font=font)
	private_dict: t.Dict[str, t.Any] = {}
	build_otf(font, charstrings_dict, ps_name, font_info, private_dict)

	os_2_table = font["OS/2"]
	os_2_table.recalcAvgCharWidth(ttFont=font)

	if subroutinize:
	flavor = font.flavor
	font.flavor = None
	log.info("Subroutinizing...")
	subr(otf=font)
	font.flavor = flavor

	out_file = makeOutputFileName(
	input=in_file,
	outputDir=output_dir,
	extension=".otf" if font.flavor is None else f".{font.flavor}",
	suffix=".otf" if font.flavor is not None else "",
	overWrite=overwrite,
	)
	font.save(out_file)
	log.info(f"File saved to {out_file}")
	print()


	if __name__ == "__main__":
	configLogger(logger=log, level="INFO")
	sys.exit(main())