fonttools 4.58.5__py3-none-any.whl → 4.59.1__py3-none-any.whl

fontTools/misc/sstruct.py

@@ -64,10 +64,7 @@ def pack(fmt, obj):
     elements = []
     if not isinstance(obj, dict):
         obj = obj.__dict__
-    string_index = formatstring
-    if formatstring.startswith(">"):
-        string_index = formatstring[1:]
-    for ix, name in enumerate(names.keys()):
+    for name in names.keys():
         value = obj[name]
         if name in fixes:
             # fixed point conversion
@@ -96,8 +93,7 @@ def unpack(fmt, data, obj=None):
     else:
         d = obj.__dict__
     elements = struct.unpack(formatstring, data)
-    for i in range(len(names)):
-        name = list(names.keys())[i]
+    for i, name in enumerate(names.keys()):
         value = elements[i]
         if name in fixes:
             # fixed point conversion

fontTools/misc/xmlWriter.py

@@ -4,8 +4,22 @@ from fontTools.misc.textTools import byteord, strjoin, tobytes, tostr
 import sys
 import os
 import string
+import logging
+import itertools
 
 INDENT = "  "
+TTX_LOG = logging.getLogger("fontTools.ttx")
+REPLACEMENT = "?"
+ILLEGAL_XML_CHARS = dict.fromkeys(
+    itertools.chain(
+        range(0x00, 0x09),
+        (0x0B, 0x0C),
+        range(0x0E, 0x20),
+        range(0xD800, 0xE000),
+        (0xFFFE, 0xFFFF),
+    ),
+    REPLACEMENT,
+)
 
 
 class XMLWriter(object):
@@ -168,12 +182,25 @@ class XMLWriter(object):
 
 
 def escape(data):
+    """Escape characters not allowed in `XML 1.0 <https://www.w3.org/TR/xml/#NT-Char>`_."""
     data = tostr(data, "utf_8")
     data = data.replace("&", "&amp;")
     data = data.replace("<", "&lt;")
     data = data.replace(">", "&gt;")
     data = data.replace("\r", "&#13;")
-    return data
+
+    newData = data.translate(ILLEGAL_XML_CHARS)
+    if newData != data:
+        maxLen = 10
+        preview = repr(data)
+        if len(data) > maxLen:
+            preview = repr(data[:maxLen])[1:-1] + "..."
+        TTX_LOG.warning(
+            "Illegal XML character(s) found; replacing offending " "string %r with %r",
+            preview,
+            REPLACEMENT,
+        )
+    return newData
 
 
 def escapeattr(data):

fontTools/pens/roundingPen.py

@@ -116,8 +116,8 @@ class RoundingPointPen(FilterPointPen):
     def addComponent(self, baseGlyphName, transformation, identifier=None, **kwargs):
         xx, xy, yx, yy, dx, dy = transformation
         self._outPen.addComponent(
-            baseGlyphName=baseGlyphName,
-            transformation=Transform(
+            baseGlyphName,
+            Transform(
                 self.transformRoundFunc(xx),
                 self.transformRoundFunc(xy),
                 self.transformRoundFunc(yx),

fontTools/subset/__init__.py

@@ -27,16 +27,16 @@ from collections import Counter, defaultdict
 from functools import reduce
 from types import MethodType
 
-__usage__ = "pyftsubset font-file [glyph...] [--option=value]..."
+__usage__ = "fonttools subset font-file [glyph...] [--option=value]..."
 
 __doc__ = (
     """\
-pyftsubset -- OpenType font subsetter and optimizer
+fonttools subset -- OpenType font subsetter and optimizer
 
-pyftsubset is an OpenType font subsetter and optimizer, based on fontTools.
-It accepts any TT- or CFF-flavored OpenType (.otf or .ttf) or WOFF (.woff)
-font file. The subsetted glyph set is based on the specified glyphs
-or characters, and specified OpenType layout features.
+fonttools subset is an OpenType font subsetter and optimizer, based on
+fontTools. It accepts any TT- or CFF-flavored OpenType (.otf or .ttf)
+or WOFF (.woff) font file. The subsetted glyph set is based on the
+specified glyphs or characters, and specified OpenType layout features.
 
 The tool also performs some size-reducing optimizations, aimed for using
 subset fonts as webfonts.  Individual optimizations can be enabled or
@@ -130,11 +130,11 @@ you might need to escape the question mark, like this: '--glyph-names\\?'.
 
 Examples::
 
-    $ pyftsubset --glyph-names?
+    $ fonttools subset --glyph-names?
     Current setting for 'glyph-names' is: False
-    $ pyftsubset --name-IDs=?
+    $ fonttools subset --name-IDs=?
     Current setting for 'name-IDs' is: [0, 1, 2, 3, 4, 5, 6]
-    $ pyftsubset --hinting? --no-hinting --hinting?
+    $ fonttools subset --hinting? --no-hinting --hinting?
     Current setting for 'hinting' is: True
     Current setting for 'hinting' is: False
 
@@ -445,7 +445,7 @@ Example
 Produce a subset containing the characters ' !"#$%' without performing
 size-reducing optimizations::
 
-  $ pyftsubset font.ttf --unicodes="U+0020-0025" \\
+  $ fonttools subset font.ttf --unicodes="U+0020-0025" \\
     --layout-features=* --glyph-names --symbol-cmap --legacy-cmap \\
     --notdef-glyph --notdef-outline --recommended-glyphs \\
     --name-IDs=* --name-legacy --name-languages=*
@@ -3768,7 +3768,7 @@ def parse_glyphs(s):
 
 def usage():
     print("usage:", __usage__, file=sys.stderr)
-    print("Try pyftsubset --help for more information.\n", file=sys.stderr)
+    print("Try fonttools subset --help for more information.\n", file=sys.stderr)
 
 
 @timer("make one with everything (TOTAL TIME)")

fontTools/ttLib/sfnt.py

@@ -375,10 +375,9 @@ class SFNTWriter(object):
 
     def _calcMasterChecksum(self, directory):
         # calculate checkSumAdjustment
-        tags = list(self.tables.keys())
         checksums = []
-        for i in range(len(tags)):
-            checksums.append(self.tables[tags[i]].checkSum)
+        for tag in self.tables.keys():
+            checksums.append(self.tables[tag].checkSum)
 
         if self.DirectoryEntry != SFNTDirectoryEntry:
             # Create a SFNT directory for checksum calculation purposes

fontTools/ttLib/tables/S__i_l_f.py

@@ -948,7 +948,7 @@ class Pass(object):
         writer.newline()
         writer.begintag("rules")
         writer.newline()
-        for i in range(len(self.actions)):
+        for i, action in enumerate(self.actions):
             writer.begintag(
                 "rule",
                 index=i,
@@ -958,7 +958,7 @@ class Pass(object):
             writer.newline()
             if len(self.ruleConstraints[i]):
                 writecode("constraint", writer, self.ruleConstraints[i])
-            writecode("action", writer, self.actions[i])
+            writecode("action", writer, action)
             writer.endtag("rule")
             writer.newline()
         writer.endtag("rules")

fontTools/ttLib/tables/T_S_I__1.py

@@ -91,12 +91,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
         glyphNames = ttFont.getGlyphOrder()
 
         indices = []
-        for i in range(len(glyphNames)):
+        for i, name in enumerate(glyphNames):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars. Yum.
-            name = glyphNames[i]
             if name in self.glyphPrograms:
                 text = tobytes(self.glyphPrograms[name], encoding="utf-8")
             else:
@@ -108,13 +107,11 @@ class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
             data = data + text
 
         extra_indices = []
-        codes = sorted(self.extras.items())
-        for i in range(len(codes)):
+        for code, name in sorted(self.extras.items()):
             if len(data) % 2:
                 data = (
                     data + b"\015"
                 )  # align on 2-byte boundaries, fill with return chars.
-            code, name = codes[i]
             if name in self.extraPrograms:
                 text = tobytes(self.extraPrograms[name], encoding="utf-8")
             else:

fontTools/ttLib/tables/T_S_I__5.py

@@ -38,8 +38,8 @@ class table_T_S_I__5(DefaultTable.DefaultTable):
     def compile(self, ttFont):
         glyphNames = ttFont.getGlyphOrder()
         a = array.array("H")
-        for i in range(len(glyphNames)):
-            a.append(self.glyphGrouping.get(glyphNames[i], 0))
+        for glyphName in glyphNames:
+            a.append(self.glyphGrouping.get(glyphName, 0))
         if sys.byteorder != "big":
             a.byteswap()
         return a.tobytes()

fontTools/ttLib/tables/_c_m_a_p.py

@@ -398,7 +398,7 @@ class cmap_format_0(CmapSubtable):
         assert 262 == self.length, "Format 0 cmap subtable not 262 bytes"
         gids = array.array("B")
         gids.frombytes(self.data)
-        charCodes = list(range(len(gids)))
+        charCodes = range(len(gids))
         self.cmap = _make_map(self.ttFont, charCodes, gids)
 
     def compile(self, ttFont):

fontTools/ttLib/tables/_c_v_t.py

@@ -29,8 +29,7 @@ class table__c_v_t(DefaultTable.DefaultTable):
         return values.tobytes()
 
     def toXML(self, writer, ttFont):
-        for i in range(len(self.values)):
-            value = self.values[i]
+        for i, value in enumerate(self.values):
             writer.simpletag("cv", value=value, index=i)
             writer.newline()
 

fontTools/ttLib/tables/_g_l_y_f.py

@@ -974,11 +974,10 @@ class Glyph(object):
         lastcomponent = len(self.components) - 1
         more = 1
         haveInstructions = 0
-        for i in range(len(self.components)):
+        for i, compo in enumerate(self.components):
             if i == lastcomponent:
                 haveInstructions = hasattr(self, "program")
                 more = 0
-            compo = self.components[i]
             data = data + compo.compile(more, haveInstructions, glyfTable)
         if haveInstructions:
             instructions = self.program.getBytecode()
@@ -2037,8 +2036,8 @@ class GlyphCoordinates(object):
         if round is noRound:
             return
         a = self._a
-        for i in range(len(a)):
-            a[i] = round(a[i])
+        for i, value in enumerate(a):
+            a[i] = round(value)
 
     def calcBounds(self):
         a = self._a
@@ -2168,8 +2167,8 @@ class GlyphCoordinates(object):
         """
         r = self.copy()
         a = r._a
-        for i in range(len(a)):
-            a[i] = -a[i]
+        for i, value in enumerate(a):
+            a[i] = -value
         return r
 
     def __round__(self, *, round=otRound):
@@ -2214,8 +2213,8 @@ class GlyphCoordinates(object):
             other = other._a
             a = self._a
             assert len(a) == len(other)
-            for i in range(len(a)):
-                a[i] += other[i]
+            for i, value in enumerate(other):
+                a[i] += value
             return self
         return NotImplemented
 
@@ -2238,8 +2237,8 @@ class GlyphCoordinates(object):
             other = other._a
             a = self._a
             assert len(a) == len(other)
-            for i in range(len(a)):
-                a[i] -= other[i]
+            for i, value in enumerate(other):
+                a[i] -= value
             return self
         return NotImplemented
 

fontTools/ttLib/tables/_g_v_a_r.py

@@ -64,7 +64,6 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         self.variations = {}
 
     def compile(self, ttFont):
-
         axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
         sharedTuples = tv.compileSharedTuples(
             axisTags, itertools.chain(*self.variations.values())
@@ -141,8 +140,12 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
             self,
         )
 
-        assert len(glyphs) == self.glyphCount
-        assert len(axisTags) == self.axisCount
+        assert len(glyphs) == self.glyphCount, (len(glyphs), self.glyphCount)
+        assert len(axisTags) == self.axisCount, (
+            len(axisTags),
+            self.axisCount,
+            axisTags,
+        )
         sharedCoords = tv.decompileSharedTuples(
             axisTags, self.sharedTupleCount, data, self.offsetToSharedTuples
         )

fontTools/ttLib/tables/_h_d_m_x.py

@@ -65,8 +65,8 @@ class table__h_d_m_x(DefaultTable.DefaultTable):
         items = sorted(self.hdmx.items())
         for ppem, widths in items:
             data = data + bytechr(ppem) + bytechr(max(widths.values()))
-            for glyphID in range(len(glyphOrder)):
-                width = widths[glyphOrder[glyphID]]
+            for glyphName in glyphOrder:
+                width = widths[glyphName]
                 data = data + bytechr(width)
             data = data + pad
         return data
@@ -123,5 +123,5 @@ class table__h_d_m_x(DefaultTable.DefaultTable):
                 glyphName = safeEval('"""' + glyphName + '"""')
             line = list(map(int, line[1:]))
             assert len(line) == len(ppems), "illegal hdmx format"
-            for i in range(len(ppems)):
-                hdmx[ppems[i]][glyphName] = line[i]
+            for i, ppem in enumerate(ppems):
+                hdmx[ppem][glyphName] = line[i]

fontTools/ttLib/tables/_h_m_t_x.py

@@ -40,15 +40,19 @@ class table__h_m_t_x(DefaultTable.DefaultTable):
                 % (self.headerTag, self.numberOfMetricsName)
             )
             numberOfMetrics = numGlyphs
-        if len(data) < 4 * numberOfMetrics:
-            raise ttLib.TTLibError("not enough '%s' table data" % self.tableTag)
+        numberOfSideBearings = numGlyphs - numberOfMetrics
+        tableSize = 4 * numberOfMetrics + 2 * numberOfSideBearings
+        if len(data) < tableSize:
+            raise ttLib.TTLibError(
+                f"not enough '{self.tableTag}' table data: "
+                f"expected {tableSize} bytes, got {len(data)}"
+            )
         # Note: advanceWidth is unsigned, but some font editors might
         # read/write as signed. We can't be sure whether it was a mistake
         # or not, so we read as unsigned but also issue a warning...
         metricsFmt = ">" + self.longMetricFormat * numberOfMetrics
         metrics = struct.unpack(metricsFmt, data[: 4 * numberOfMetrics])
         data = data[4 * numberOfMetrics :]
-        numberOfSideBearings = numGlyphs - numberOfMetrics
         sideBearings = array.array("h", data[: 2 * numberOfSideBearings])
         data = data[2 * numberOfSideBearings :]
 

fontTools/ttLib/tables/_l_o_c_a.py

@@ -46,8 +46,8 @@ class table__l_o_c_a(DefaultTable.DefaultTable):
             max_location = 0
         if max_location < 0x20000 and all(l % 2 == 0 for l in self.locations):
             locations = array.array("H")
-            for i in range(len(self.locations)):
-                locations.append(self.locations[i] // 2)
+            for location in self.locations:
+                locations.append(location // 2)
             ttFont["head"].indexToLocFormat = 0
         else:
             locations = array.array("I", self.locations)

fontTools/ttLib/tables/_p_o_s_t.py

@@ -174,10 +174,9 @@ class table__p_o_s_t(DefaultTable.DefaultTable):
         extraNames = self.extraNames = [
             n for n in self.extraNames if n not in standardGlyphOrder
         ]
-        for i in range(len(extraNames)):
-            extraDict[extraNames[i]] = i
-        for glyphID in range(numGlyphs):
-            glyphName = glyphOrder[glyphID]
+        for i, name in enumerate(extraNames):
+            extraDict[name] = i
+        for glyphName in glyphOrder:
             if glyphName in self.mapping:
                 psName = self.mapping[glyphName]
             else:

fontTools/ttLib/tables/otBase.py

@@ -500,8 +500,7 @@ class OTTableWriter(object):
             internedTables = {}
 
         items = self.items
-        for i in range(len(items)):
-            item = items[i]
+        for i, item in enumerate(items):
             if hasattr(item, "getCountData"):
                 items[i] = item.getCountData()
             elif hasattr(item, "subWriter"):
@@ -1130,8 +1129,7 @@ class BaseTable(object):
         for conv in self.getConverters():
             if conv.repeat:
                 value = getattr(self, conv.name, [])
-                for i in range(len(value)):
-                    item = value[i]
+                for i, item in enumerate(value):
                     conv.xmlWrite(xmlWriter, font, item, conv.name, [("index", i)])
             else:
                 if conv.aux and not eval(conv.aux, None, vars(self)):

fontTools/ttLib/tables/otTables.py

@@ -990,8 +990,7 @@ class Coverage(FormatSwitchingBaseTable):
             if brokenOrder or len(ranges) * 3 < len(glyphs):  # 3 words vs. 1 word
                 # Format 2 is more compact
                 index = 0
-                for i in range(len(ranges)):
-                    start, end = ranges[i]
+                for i, (start, end) in enumerate(ranges):
                     r = RangeRecord()
                     r.StartID = start
                     r.Start = font.getGlyphName(start)
@@ -1404,8 +1403,7 @@ class ClassDef(FormatSwitchingBaseTable):
             glyphCount = endGlyph - startGlyph + 1
             if len(ranges) * 3 < glyphCount + 1:
                 # Format 2 is more compact
-                for i in range(len(ranges)):
-                    cls, start, startName, end, endName = ranges[i]
+                for i, (cls, start, startName, end, endName) in enumerate(ranges):
                     rec = ClassRangeRecord()
                     rec.Start = startName
                     rec.End = endName
@@ -1463,8 +1461,7 @@ class AlternateSubst(FormatSwitchingBaseTable):
         if alternates is None:
             alternates = self.alternates = {}
         items = list(alternates.items())
-        for i in range(len(items)):
-            glyphName, set = items[i]
+        for i, (glyphName, set) in enumerate(items):
             items[i] = font.getGlyphID(glyphName), glyphName, set
         items.sort()
         cov = Coverage()
@@ -1520,8 +1517,8 @@ class LigatureSubst(FormatSwitchingBaseTable):
             input = _getGlyphsFromCoverageTable(rawTable["Coverage"])
             ligSets = rawTable["LigatureSet"]
             assert len(input) == len(ligSets)
-            for i in range(len(input)):
-                ligatures[input[i]] = ligSets[i].Ligature
+            for i, inp in enumerate(input):
+                ligatures[inp] = ligSets[i].Ligature
         else:
             assert 0, "unknown format: %s" % self.Format
         self.ligatures = ligatures
@@ -1577,8 +1574,7 @@ class LigatureSubst(FormatSwitchingBaseTable):
             ligatures = newLigatures
 
         items = list(ligatures.items())
-        for i in range(len(items)):
-            glyphName, set = items[i]
+        for i, (glyphName, set) in enumerate(items):
             items[i] = font.getGlyphID(glyphName), glyphName, set
         items.sort()
         cov = Coverage()
@@ -2279,8 +2275,7 @@ def fixLookupOverFlows(ttf, overflowRecord):
         lookup = lookups[lookupIndex]
         if lookup.LookupType != extType:
             lookup.LookupType = extType
-            for si in range(len(lookup.SubTable)):
-                subTable = lookup.SubTable[si]
+            for si, subTable in enumerate(lookup.SubTable):
                 extSubTableClass = lookupTypes[overflowRecord.tableType][extType]
                 extSubTable = extSubTableClass()
                 extSubTable.Format = 1

fontTools/ttLib/tables/sbixStrike.py

@@ -128,9 +128,9 @@ class Strike(object):
         xmlWriter.simpletag("resolution", value=self.resolution)
         xmlWriter.newline()
         glyphOrder = ttFont.getGlyphOrder()
-        for i in range(len(glyphOrder)):
-            if glyphOrder[i] in self.glyphs:
-                self.glyphs[glyphOrder[i]].toXML(xmlWriter, ttFont)
+        for glyphName in glyphOrder:
+            if glyphName in self.glyphs:
+                self.glyphs[glyphName].toXML(xmlWriter, ttFont)
                 # TODO: what if there are more glyph data records than (glyf table) glyphs?
         xmlWriter.endtag("strike")
         xmlWriter.newline()

fontTools/ttLib/ttFont.py

@@ -259,9 +259,8 @@ class TTFont(object):
                 "head"
             ]  # make sure 'head' is loaded so the recalculation is actually done
 
-        tags = list(self.keys())
-        if "GlyphOrder" in tags:
-            tags.remove("GlyphOrder")
+        tags = self.keys()
+        tags.pop(0)  # skip GlyphOrder tag
         numTables = len(tags)
         # write to a temporary stream to allow saving to unseekable streams
         writer = SFNTWriter(
@@ -307,14 +306,9 @@ class TTFont(object):
         self.disassembleInstructions = disassembleInstructions
         self.bitmapGlyphDataFormat = bitmapGlyphDataFormat
         if not tables:
-            tables = list(self.keys())
-            if "GlyphOrder" not in tables:
-                tables = ["GlyphOrder"] + tables
+            tables = self.keys()
             if skipTables:
-                for tag in skipTables:
-                    if tag in tables:
-                        tables.remove(tag)
-        numTables = len(tables)
+                tables = [tag for tag in tables if tag not in skipTables]
 
         if writeVersion:
             from fontTools import version
@@ -337,8 +331,7 @@ class TTFont(object):
         else:
             path, ext = os.path.splitext(writer.filename)
 
-        for i in range(numTables):
-            tag = tables[i]
+        for tag in tables:
             if splitTables:
                 tablePath = path + "." + tagToIdentifier(tag) + ext
                 tableWriter = xmlWriter.XMLWriter(
@@ -608,8 +601,7 @@ class TTFont(object):
         else:
             reversecmap = {}
         useCount = {}
-        for i in range(numGlyphs):
-            tempName = glyphOrder[i]
+        for i, tempName in enumerate(glyphOrder):
             if tempName in reversecmap:
                 # If a font maps both U+0041 LATIN CAPITAL LETTER A and
                 # U+0391 GREEK CAPITAL LETTER ALPHA to the same glyph,
@@ -866,8 +858,7 @@ class GlyphOrder(object):
             "The 'id' attribute is only for humans; " "it is ignored when parsed."
         )
         writer.newline()
-        for i in range(len(glyphOrder)):
-            glyphName = glyphOrder[i]
+        for i, glyphName in enumerate(glyphOrder):
             writer.simpletag("GlyphID", id=i, name=glyphName)
             writer.newline()
 

fontTools/ttLib/woff2.py

@@ -394,10 +394,9 @@ class WOFF2Writer(SFNTWriter):
 
     def _calcMasterChecksum(self):
         """Calculate checkSumAdjustment."""
-        tags = list(self.tables.keys())
         checksums = []
-        for i in range(len(tags)):
-            checksums.append(self.tables[tags[i]].checkSum)
+        for tag in self.tables.keys():
+            checksums.append(self.tables[tag].checkSum)
 
         # Create a SFNT directory for checksum calculation purposes
         self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(
@@ -642,10 +641,10 @@ woff2OverlapSimpleBitmapFlag = 0x0001
 
 def getKnownTagIndex(tag):
     """Return index of 'tag' in woff2KnownTags list. Return 63 if not found."""
-    for i in range(len(woff2KnownTags)):
-        if tag == woff2KnownTags[i]:
-            return i
-    return woff2UnknownTagIndex
+    try:
+        return woff2KnownTags.index(tag)
+    except ValueError:
+        return woff2UnknownTagIndex
 
 
 class WOFF2DirectoryEntry(DirectoryEntry):
@@ -747,8 +746,8 @@ class WOFF2LocaTable(getTableClass("loca")):
                         "indexFormat is 0 but local offsets not multiples of 2"
                     )
                 locations = array.array("H")
-                for i in range(len(self.locations)):
-                    locations.append(self.locations[i] // 2)
+                for location in self.locations:
+                    locations.append(location // 2)
             else:
                 locations = array.array("I", self.locations)
             if sys.byteorder != "big":
@@ -1026,11 +1025,10 @@ class WOFF2GlyfTable(getTableClass("glyf")):
         lastcomponent = len(glyph.components) - 1
         more = 1
         haveInstructions = 0
-        for i in range(len(glyph.components)):
+        for i, component in enumerate(glyph.components):
             if i == lastcomponent:
                 haveInstructions = hasattr(glyph, "program")
                 more = 0
-            component = glyph.components[i]
             self.compositeStream += component.compile(more, haveInstructions, self)
         if haveInstructions:
             self._encodeInstructions(glyph)
@@ -1078,9 +1076,8 @@ class WOFF2GlyfTable(getTableClass("glyf")):
 
         flags = array.array("B")
         triplets = array.array("B")
-        for i in range(len(coordinates)):
+        for i, (x, y) in enumerate(coordinates):
             onCurve = glyph.flags[i] & _g_l_y_f.flagOnCurve
-            x, y = coordinates[i]
             absX = abs(x)
             absY = abs(y)
             onCurveBit = 0 if onCurve else 128