Update app.py

app.py

@@ -10,7 +10,7 @@ import tempfile
 import os
 import glob
 from fontmake.font_project import FontProject
-from defcon import Font, Glyph
+from defcon import Font, Glyph, Point
 from fontTools.pens.svgPathPen import SVGPathPen
 from svgpathtools import parse_path, Path, Line, CubicBezier, QuadraticBezier, Arc
 from svgpathtools.path import Path as SvgPath
@@ -89,9 +89,7 @@ def build_ufo_from_glyphs(glyphs):
     font = Font()
     font.info.familyName = "TipTopType"
     font.info.styleName = "Regular"
-    # Définir les unités par em (standard pour les polices)
     font.info.unitsPerEm = 1000
-    # Définir d'autres propriétés de la police
     font.info.ascender = 800
     font.info.descender = -200
     font.info.capHeight = 700
@@ -105,91 +103,54 @@ def build_ufo_from_glyphs(glyphs):
         glyph.unicode = ord(letter)
         pen = glyph.getPen()
         try:
-            # Analyser le chemin SVG
             path = parse_path(path_data)
-            # Créer un nouveau chemin SVG pour normaliser et simplifier
-            normalized_path = SvgPath()
+            normalized_path = []
             for segment in path:
                 if segment.length() == 0:
                     continue
-                # Commencer un nouveau sous-chemin
-                if not normalized_path or not normalized_path[-1].end == segment.start:
-                    normalized_path.append(Line(start=segment.start, end=segment.start))
-                # Ajouter le segment au chemin normalisé
-                if isinstance(segment, Line):
-                    normalized_path.append(Line(start=normalized_path[-1].end, end=segment.end))
-                elif isinstance(segment, CubicBezier):
-                    normalized_path.append(CubicBezier(
-                        start=normalized_path[-1].end,
-                        control1=segment.control1,
-                        control2=segment.control2,
-                        end=segment.end
-                    ))
-                elif isinstance(segment, QuadraticBezier):
-                    # Convertir la courbe quadratique en courbe cubique
-                    start = normalized_path[-1].end
-                    end = segment.end
-                    control = segment.control
-                    # Approximation simple: diviser la courbe quadratique en deux segments cubiques
-                    control1 = start + (control - start) * 2/3
-                    control2 = end + (control - end) * 2/3
-                    normalized_path.append(CubicBezier(
-                        start=start,
-                        control1=control1,
-                        control2=control2,
-                        end=end
-                    ))
-                elif isinstance(segment, Arc):
-                    # Convertir l'arc en une série de courbes cubiques
-                    # Pour simplifier, nous allons approximer l'arc avec une ligne droite
-                    normalized_path.append(Line(start=normalized_path[-1].end, end=segment.end))
-            # Dessiner le chemin normalisé dans le glyphe
+                normalized_path.append(segment)
             if normalized_path:
-                # Calculer les limites du chemin pour centrer et mettre à l'échelle
-                bounds = normalized_path.bbox()
+                bounds = None
+                for segment in normalized_path:
+                    if bounds is None:
+                        bounds = segment.bbox()
+                    else:
+                        bounds |= segment.bbox()
                 if bounds and (bounds.width > 0) and (bounds.height > 0):
-                    # Définir la largeur du glyphe (par exemple, 80% de 1000 unités)
                     glyph_width = 800
-                    glyph_height = 1000  # unités par em
-                    # Calculer le facteur d'échelle pour que le glyphe tienne dans la hauteur
+                    glyph_height = 1000
                     scale_factor = glyph_height * 0.8 / bounds.height
-                    # Calculer le décalage pour centrer le glyphe horizontalement
                     offset_x = (glyph_width - bounds.width * scale_factor) / 2
-                    offset_y = -bounds.bottom * scale_factor  # décalage pour positionner la base sur la ligne de base
-                    # Appliquer la transformation aux points du chemin
-                    for segment in normalized_path:
-                        # Appliquer la transformation aux points du segment
-                        def transform_point(point):
-                            x = point.real
-                            y = point.imag
-                            # Appliquer la mise à l'échelle et le décalage
-                            new_x = x * scale_factor + offset_x
-                            new_y = y * scale_factor + offset_y
-                            return (new_x, -new_y)  # Inverser Y car les systèmes de coordonnées sont différents
-                        start_point = transform_point(segment.start)
-                        if len(normalized_path) == 1 or segment == normalized_path[0]:
-                            pen.moveTo(start_point)
-                        if isinstance(segment, Line):
-                            end_point = transform_point(segment.end)
-                            pen.lineTo(end_point)
-                        elif isinstance(segment, CubicBezier):
-                            control1 = transform_point(segment.control1)
-                            control2 = transform_point(segment.control2)
-                            end_point = transform_point(segment.end)
-                            pen.curveTo(control1, control2, end_point)
-                    # Fermer le chemin si nécessaire
-                    if normalized_path.isclosed():
-                        pen.closePath()
-            # Définir la largeur du glyphe
+                    offset_y = -bounds.bottom * scale_factor
+                    def transform_point(point):
+                        x = point.real
+                        y = point.imag
+                        new_x = x * scale_factor + offset_x
+                        new_y = y * scale_factor + offset_y
+                        return Point((new_x, -new_y))
+                    if normalized_path:
+                        start_segment = normalized_path[0]
+                        start_point = transform_point(start_segment.start)
+                        pen.moveTo(start_point)
+                        for segment in normalized_path:
+                            if isinstance(segment, Line):
+                                end_point = transform_point(segment.end)
+                                pen.lineTo(end_point)
+                            elif isinstance(segment, CubicBezier):
+                                control1 = transform_point(segment.control1)
+                                control2 = transform_point(segment.control2)
+                                end_point = transform_point(segment.end)
+                                pen.curveTo(control1, control2, end_point)
+                        if normalized_path and normalized_path[-1].end == normalized_path[0].start:
+                            pen.closePath()
             glyph.width = glyph_width
             print(f"Glyph {letter} created with SVG path.")
         except Exception as e:
             print(f"Error injecting SVG for {letter}: {e}")
-            # En cas d'erreur, dessiner un rectangle pour visualiser le problème
-            pen.moveTo((100, 0))
-            pen.lineTo((900, 0))
-            pen.lineTo((900, 1000))
-            pen.lineTo((100, 1000))
+            pen.moveTo(Point((100, 0)))
+            pen.lineTo(Point((900, 0)))
+            pen.lineTo(Point((900, 1000)))
+            pen.lineTo(Point((100, 1000)))
             pen.closePath()
             glyph.width = 1000
         font.insertGlyph(glyph)
@@ -206,26 +167,20 @@ def save_otf_font(glyphs, font_name="TipTopType-Regular.otf"):
             font = build_ufo_from_glyphs(glyphs)
             font.save(ufo_path)
             print(f"UFO file saved at: {ufo_path}")
-
             output_dir = os.path.join(tmpdir, "out")
             os.makedirs(output_dir, exist_ok=True)
-
             project = FontProject()
             project.run_from_ufos([ufo_path], output=["otf"], output_dir=output_dir)
             print("Fontmake ran successfully.")
-
             otf_files = glob.glob(os.path.join(output_dir, "**/*.otf"), recursive=True)
             if not otf_files:
                 print("No OTF files generated by fontmake.")
                 return None
-
             generated_path = otf_files[0]
             print(f"OTF file generated at: {generated_path}")
-
             final_path = os.path.join(tempfile.gettempdir(), font_name)
             os.replace(generated_path, final_path)
             print(f"OTF file moved to: {final_path}")
-
             return final_path
     except Exception as e:
         print(f"Error in save_otf_font: {e}")