Spigoli e illuminazione obliqua nella vista 3D

La prima versione era poco leggibile: l'ombreggiatura usava solo
l'inclinazione frontale, quindi le facce complanari di un pezzo piatto
uscivano tutte dello stesso grigio e la forma non si distingueva.

Due correzioni:

- luce direzionale obliqua invece che frontale, con una rampa di
  luminosita' piu' ampia, cosi' le facce orientate diversamente si
  separano davvero;
- soprattutto, gli spigoli. Sopra alle superfici si disegnano ora gli
  spigoli vivi (due facce che formano un angolo netto) e la silhouette
  (faccia visibile contro faccia nascosta). Sono le linee che rendono
  riconoscibile un pezzo meccanico, le stesse che traccerebbe un
  disegnatore.

Per distinguere uno spigolo vivo da una suddivisione interna della
tassellatura servono le facce adiacenti, che un STL non fornisce perche'
ripete i vertici a ogni triangolo. Mesh.indexed() li fonde e ricostruisce
la topologia: sul pezzo di prova 912 ripetizioni diventano 144 vertici
reali, 304 facce e 456 spigoli, senza bordi liberi. La mesh risulta
chiusa e la caratteristica di Eulero indica cinque fori passanti, come il
pezzo.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

creoparams/mesh.py

@@ -68,6 +68,38 @@ class Mesh:
                       + a[2]*(b[0]*c[1]-b[1]*c[0])) / 6
         return abs(total)
 
+    def indexed(self, tolerance: int = 5):
+        """Vertici unici, facce e spigoli, con le facce adiacenti a ciascuno.
+
+        Un STL ripete i vertici a ogni triangolo: fondendoli possiamo sapere
+        quali facce condividono uno spigolo, e quindi distinguere gli spigoli
+        vivi del pezzo dalle suddivisioni interne della tassellatura. Sono
+        quelli che rendono leggibile un modello meccanico.
+        """
+        lookup, vertices, faces = {}, [], []
+        for triangle in self.triangles:
+            face = []
+            for vertex in triangle:
+                key = tuple(round(c, tolerance) for c in vertex)
+                index = lookup.get(key)
+                if index is None:
+                    index = len(vertices)
+                    lookup[key] = index
+                    vertices.append([round(c, 4) for c in vertex])
+                face.append(index)
+            if len(set(face)) == 3:          # scarta i triangoli degeneri
+                faces.append(face)
+
+        edges = {}
+        for number, (a, b, c) in enumerate(faces):
+            for pair in ((a, b), (b, c), (c, a)):
+                key = (min(pair), max(pair))
+                edges.setdefault(key, []).append(number)
+
+        edge_list = [[a, b, adj[0], adj[1] if len(adj) > 1 else -1]
+                     for (a, b), adj in edges.items()]
+        return vertices, faces, edge_list
+
     def to_dict(self) -> dict:
         lo, hi = self.bounds
         return {