Update app.py

app.py

@@ -13,13 +13,14 @@ from fontmake.font_project import FontProject
 from defcon import Font, Glyph
 from fontTools.pens.svgPathPen import SVGPathPen
 from svgpathtools import parse_path, Path, Line, CubicBezier, QuadraticBezier, Arc
+from svgpathtools.path import Path as SvgPath
 
 # ------------------------
 # MODELE
 # ------------------------
 def load_model():
-    tokenizer = AutoTokenizer.from_pretrained("ChevalierJoseph/typtop3")
-    model = AutoModelForCausalLM.from_pretrained("ChevalierJoseph/typtop3")
+    tokenizer = AutoTokenizer.from_pretrained("ChevalierJoseph/typtop")
+    model = AutoModelForCausalLM.from_pretrained("ChevalierJoseph/typtop")
     return tokenizer, model
 
 # ------------------------
@@ -80,43 +81,119 @@ 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
+    font.info.xHeight = 500
+
     for letter, path_data in glyphs:
         glyph = Glyph()
         glyph.name = letter
         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()
+
             for segment in path:
                 if segment.length() == 0:
                     continue
-                # Commencer un nouveau contour
-                start_point = (segment.start.real, segment.start.imag)
-                pen.moveTo(start_point)
-                # Dessiner la courbe ou la ligne selon le type de segment
+
+                # 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):
-                    end_point = (segment.end.real, segment.end.imag)
-                    pen.lineTo(end_point)
+                    normalized_path.append(Line(start=normalized_path[-1].end, end=segment.end))
                 elif isinstance(segment, CubicBezier):
-                    control1 = (segment.control1.real, segment.control1.imag)
-                    control2 = (segment.control2.real, segment.control2.imag)
-                    end_point = (segment.end.real, segment.end.imag)
-                    pen.curveTo(control1, control2, end_point)
+                    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
-                    # Pour simplifier, nous allons approximer avec une ligne droite
-                    end_point = (segment.end.real, segment.end.imag)
-                    pen.lineTo(end_point)
+                    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):
-                    # Les arcs sont plus complexes à convertir
-                    # Pour simplifier, nous allons approximer avec une ligne droite
-                    end_point = (segment.end.real, segment.end.imag)
-                    pen.lineTo(end_point)
-            pen.closePath()
-            glyph.width = 600
+                    # 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
+            if normalized_path:
+                # Calculer les limites du chemin pour centrer et mettre à l'échelle
+                bounds = normalized_path.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
+                    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
+            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.closePath()
+            glyph.width = 1000
         font.insertGlyph(glyph)
     print(f"Total glyphs in font: {len(font)}")
     return font