update tests. add to_unicode

Author: andersonhc

fpdf/drawing.py

@@ -3789,6 +3789,11 @@ def _insert_implicit_close_if_open(self):
             self._close_context = self._graphics_context
             self._closed = True
 
+    def linear_gradient_fill(self, x1, y1, x2, y2, stops):
+        gradient = LinearGradient(fpdf=None, from_x=x1, from_y=y1, to_x=x2, to_ys=y2, colors=[stop[1] for stop in stops])
+        gradient.coords = list(map(str, [x1, x2, y1, y2]))
+        self.gradient=gradient
+
     def render(
         self, gsd_registry, style, last_item, initial_point, debug_stream=None, pfx=None
     ):

fpdf/font_type_3.py

@@ -3,6 +3,8 @@
 from typing import List, Tuple, TYPE_CHECKING
 from io import BytesIO
 from fontTools.ttLib.tables.BitmapGlyphMetrics import BigGlyphMetrics, SmallGlyphMetrics
+from fontTools.ttLib.tables.C_O_L_R_ import table_C_O_L_R_
+from fontTools.ttLib.tables.otTables import Paint, PaintFormat
 
 from .drawing import DeviceRGB, GraphicsContext, Transform, PathPen, PaintedPath
 
@@ -146,34 +148,56 @@ def load_glyph_image(self, glyph: Type3FontGlyph):
 
 class COLRFont(Type3Font):
 
+    def __init__(self, fpdf: "FPDF", base_font: "TTFFont"):
+        super().__init__(fpdf, base_font)
+        colr_table: table_C_O_L_R_ = self.base_font.ttfont["COLR"]
+        self.colrv0_glyphs = []
+        self.colrv1_glyphs = []
+        self.version = colr_table.version
+        if colr_table.version == 0:
+            self.colrv0_glyphs = colr_table.ColorLayers
+        else:
+            self.colrv0_glyphs = colr_table._decompileColorLayersV0(colr_table.table)
+            self.colrv1_glyphs = {
+                glyph.BaseGlyph: glyph
+                for glyph in colr_table.table.BaseGlyphList.BaseGlyphPaintRecord
+            }
+        self.palette = None
+        if "CPAL" in self.base_font.ttfont:
+            # hardcoding the first palette for now
+            print(f"This font has {len(self.base_font.ttfont['CPAL'].palettes)} palettes")
+            palette = self.base_font.ttfont["CPAL"].palettes[0]
+            self.palette = [
+                (color.red / 255, color.green / 255, color.blue / 255, color.alpha / 255) for color in palette
+            ]
+        
+
     def glyph_exists(self, glyph_name):
-        return glyph_name in self.base_font.ttfont["COLR"].ColorLayers
+        return glyph_name in self.colrv0_glyphs or glyph_name in self.colrv1_glyphs
 
     def load_glyph_image(self, glyph: Type3FontGlyph):
         w = round(self.base_font.ttfont["hmtx"].metrics[glyph.glyph_name][0] + 0.001)
-        glyph_layers = self.base_font.ttfont["COLR"].ColorLayers[glyph.glyph_name]
-        img = self.draw_glyph_colrv0(glyph_layers)
-        img.transform = Transform.scaling(self.scale, -self.scale)
+        if glyph.glyph_name in self.colrv0_glyphs:
+            glyph_layers = self.base_font.ttfont["COLR"].ColorLayers[glyph.glyph_name]
+            img = self.draw_glyph_colrv0(glyph_layers)
+        else:
+            img = self.draw_glyph_colrv1(glyph.glyph_name)
+        img.transform = img.transform @ Transform.scaling(self.scale, -self.scale)
         output_stream = self.fpdf.draw_vector_glyph(img, self)
         glyph.glyph = (
             f"{w * self.scale / self.upem} 0 d0\n" "q\n" f"{output_stream}\n" "Q"
         )
         glyph.glyph_width = w
 
-    def get_color(self, color_index, palette=0):
-        palettes = [
-            [(c.red / 255, c.green / 255, c.blue / 255, c.alpha / 255) for c in p]
-            for p in self.base_font.ttfont["CPAL"].palettes
-        ]
-        r, g, b, a = palettes[palette][color_index]
-        # a *= alpha
+    def get_color(self, color_index, alpha=1):
+        r, g, b, a = self.palette[color_index]
+        a *= alpha
         return DeviceRGB(r, g, b, a)
 
     def draw_glyph_colrv0(self, layers):
         gc = GraphicsContext()
+        gc.transform = Transform.identity()
         for layer in layers:
-            print(layer.__repr__)
-            print(layer.colorID, layer.name)
             path = PaintedPath()
             glyph_set = self.base_font.ttfont.getGlyphSet()
             pen = PathPen(path, glyphSet=glyph_set)
@@ -183,10 +207,44 @@ def draw_glyph_colrv0(self, layers):
             path.style.stroke_color = self.get_color(layer.colorID)
             gc.add_item(path)
         return gc
-        # print(path)
-        # self.base_font.hbfont.draw_glyph_with_pen(gid, path)
-        # canvas.drawPathSolid(path, self._getColor(layer.colorID, 1))
+    
+    def draw_glyph_colrv1(self, glyph_name):
+        gc = GraphicsContext()
+        gc.transform = Transform.identity()
+        glyph = self.colrv1_glyphs[glyph_name]
+        self.draw_colrv1_paint(glyph.Paint, gc)
+        return gc
 
+    def draw_colrv1_paint(self, paint: Paint, gc: GraphicsContext):
+        print(paint.getFormatName())
+        if paint.Format == PaintFormat.PaintColrLayers: #1
+            print("[PaintColrLayers] FirstLayerIndex: ", paint.FirstLayerIndex, " NumLayers: ", paint.NumLayers)
+            layer_list = self.base_font.ttfont["COLR"].table.LayerList
+            for layer in range(paint.FirstLayerIndex, paint.FirstLayerIndex + paint.NumLayers):
+                self.draw_colrv1_paint(layer_list.Paint[layer], gc)
+        elif paint.Format == PaintFormat.PaintSolid: #2
+            color = self.get_color(paint.PaletteIndex, paint.Alpha)
+            path: PaintedPath = gc.path_items[-1]
+            path.style.fill_color = color
+            path.style.stroke_color = color
+        elif paint.Format == PaintFormat.PaintLinearGradient: #4
+            print("[PaintLinearGradient] ColorLine: ")
+            for stop in paint.ColorLine.ColorStop:
+                print("Stop: ", stop.StopOffset, " color: ", stop.PaletteIndex)
+                print("x0: ", paint.x0, " y0: ", paint.y0, " x1: ", paint.x1, " y1: ", paint.y1)
+        elif paint.Format == PaintFormat.PaintGlyph: #10
+            path = PaintedPath()
+            glyph_set = self.base_font.ttfont.getGlyphSet()
+            pen = PathPen(path, glyphSet=glyph_set)
+            glyph = glyph_set[paint.Glyph]
+            glyph.draw(pen)
+            gc.add_item(path)
+            self.draw_colrv1_paint(paint.Paint, gc)
+        else:
+            print("Unknown PaintFormat: ", paint.Format)
+
+        
+        
 
 class CBDTColorFont(Type3Font):
 
@@ -195,11 +253,11 @@ class CBDTColorFont(Type3Font):
     def glyph_exists(self, glyph_name):
         return glyph_name in self.base_font.ttfont["CBDT"].strikeData[0]
 
-    def load_glyph_image(self, glyph_name):
+    def load_glyph_image(self, glyph: Type3FontGlyph):
         ppem = self.base_font.ttfont["CBLC"].strikes[0].bitmapSizeTable.ppemX
-        glyph = self.base_font.ttfont["CBDT"].strikeData[0][glyph_name]
-        glyph_bitmap = glyph.data[9:]
-        metrics = glyph.metrics
+        g = self.base_font.ttfont["CBDT"].strikeData[0][glyph.glyph_name]
+        glyph_bitmap = g.data[9:]
+        metrics = g.metrics
         if isinstance(metrics, SmallGlyphMetrics):
             x_min = round(metrics.BearingX * self.upem / ppem)
             y_min = round((metrics.BearingY - metrics.height) * self.upem / ppem)
@@ -300,9 +358,9 @@ def get_color_font_object(fpdf: "FPDF", base_font: "TTFFont") -> Type3Font:
     if "COLR" in base_font.ttfont:
         if base_font.ttfont["COLR"].version == 0:
             LOGGER.warning("Font %s is a COLRv0 color font", base_font.name)
-            return COLRFont(fpdf, base_font)
-        LOGGER.warning("Font %s is a COLRv1 color font", base_font.name)
-        return None
+        else:
+            LOGGER.warning("Font %s is a COLRv1 color font", base_font.name)
+        return COLRFont(fpdf, base_font)
     if "SVG " in base_font.ttfont:
         LOGGER.warning("Font %s is a SVG color font", base_font.name)
         return SVGColorFont(fpdf, base_font)

fpdf/fonts.py

@@ -622,6 +622,9 @@ def get_glyph(
         if unicode == 0x00:
             glyph_id = next(iter(self.font.cmap))
             return Glyph(glyph_id, (0x00,), ".notdef", 0)
+        if unicode == 0x20:
+            glyph_id = next(iter(self.font.cmap))
+            return Glyph(glyph_id, (0x20,), "space", self.font.cw[0x20])
         return None
 
     def get_all_glyph_names(self):

fpdf/output.py

@@ -111,6 +111,7 @@ def __init__(self, font3: "Type3Font"):
         self.first_char = min(g.unicode for g in font3.glyphs)
         self.last_char = max(g.unicode for g in font3.glyphs)
         self.resources = None
+        self.to_unicode = None
 
     @property
     def char_procs(self):
@@ -760,7 +761,48 @@ def _add_fonts(self, image_objects_per_index, gfxstate_objs_per_name):
                     glyph.obj_id = self._add_pdf_obj(
                         PDFContentStream(contents=glyph.glyph, compress=False), "fonts"
                     )
+                bfChar = []
+                def format_code(unicode):
+                    if unicode > 0xFFFF:
+                        # Calculate surrogate pair
+                        code_high = 0xD800 | (unicode - 0x10000) >> 10
+                        code_low = 0xDC00 | (unicode & 0x3FF)
+                        return f"{code_high:04X}{code_low:04X}"
+                    return f"{unicode:04X}"
+
+                for glyph, code_mapped in font.subset.items():
+                    if len(glyph.unicode) == 0:
+                        continue
+                    bfChar.append(
+                        f'<{code_mapped:02X}> <{"".join(format_code(code) for code in glyph.unicode)}>\n'
+                    )
+
+                to_unicode_obj = PDFContentStream(
+                    "/CIDInit /ProcSet findresource begin\n"
+                    "12 dict begin\n"
+                    "begincmap\n"
+                    "/CIDSystemInfo\n"
+                    "<</Registry (Adobe)\n"
+                    "/Ordering (UCS)\n"
+                    "/Supplement 0\n"
+                    ">> def\n"
+                    "/CMapName /Adobe-Identity-UCS def\n"
+                    "/CMapType 2 def\n"
+                    "1 begincodespacerange\n"
+                    "<00> <FF>\n"
+                    "endcodespacerange\n"
+                    f"{len(bfChar)} beginbfchar\n"
+                    f"{''.join(bfChar)}"
+                    "endbfchar\n"
+                    "endcmap\n"
+                    "CMapName currentdict /CMap defineresource pop\n"
+                    "end\n"
+                    "end"
+                )
+                self._add_pdf_obj(to_unicode_obj, "fonts")
+                
                 t3_font_obj = PDFType3Font(font.color_font)
+                t3_font_obj.to_unicode = pdf_ref(to_unicode_obj.id)
                 t3_font_obj.generate_resources(
                     image_objects_per_index, gfxstate_objs_per_name
                 )

test/color_font/cbdt_noto_color_emoji.pdf

@@ -20,7 +20,7 @@ def test_twemoji(tmp_path):
     pdf.cell(text="Top 10 emojis:", new_x="right", new_y="top")
     pdf.set_font("Twemoji", "", 24)
     pdf.cell(text=test_text, new_x="lmargin", new_y="next")
-    assert_pdf_equal(pdf, HERE / "colrv0-twemoji.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "colrv0-twemoji.pdf", tmp_path)
 
 
 def test_twemoji_shaping(tmp_path):
@@ -38,7 +38,7 @@ def test_twemoji_shaping(tmp_path):
     pdf.set_font("Twemoji", "", 24)
     pdf.set_text_shaping(True)
     pdf.multi_cell(w=pdf.epw, text=combined_emojis, new_x="lmargin", new_y="next")
-    assert_pdf_equal(pdf, HERE / "colrv0-twemoji_shaping.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "colrv0-twemoji_shaping.pdf", tmp_path)
 
 
 def test_twemoji_text(tmp_path):
@@ -50,4 +50,4 @@ def test_twemoji_text(tmp_path):
     pdf.set_fallback_fonts(["Twemoji"])
     pdf.add_page()
     pdf.multi_cell(w=pdf.epw, text=text)
-    assert_pdf_equal(pdf, HERE / "colrv0-twemoji_text.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "colrv0-twemoji_text.pdf", tmp_path)

test/color_font/cbdt_noto_color_emoji_shaping.pdf

@@ -22,7 +22,7 @@ def test_sbix_compyx(tmp_path):
     pdf.ln()
     pdf.multi_cell(w=pdf.epw, text=LOREM_IPSUM.lower(), align="J")
 
-    assert_pdf_equal(pdf, HERE / "sbix_compyx.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "sbix_compyx.pdf", tmp_path)
 
 
 def test_sbix_bungee(tmp_path):
@@ -40,4 +40,4 @@ def test_sbix_bungee(tmp_path):
     pdf.ln()
     pdf.multi_cell(w=pdf.epw, text=LOREM_IPSUM.upper(), align="J")
 
-    assert_pdf_equal(pdf, HERE / "sbix_bungee.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "sbix_bungee.pdf", tmp_path)

test/color_font/cbdt_noto_emoji_text.pdf

@@ -39,7 +39,7 @@ def test_svg_bungee(tmp_path):
     pdf.ln()
     pdf.multi_cell(w=pdf.epw, text=LOREM_IPSUM.upper(), align="J")
 
-    assert_pdf_equal(pdf, HERE / "svg_bungee.pdf", tmp_path, generate=True)
+    assert_pdf_equal(pdf, HERE / "svg_bungee.pdf", tmp_path)
 
 
 def test_twitter_emoji_shaping(tmp_path):