Sekunden als Punkte, Ringe gestaffelt, silberner Rand weg

Filipe: "ich will aber dass die sekunden wie punkte sind, die minuten
breiter und die stunden noch breiter … den silbernen rand weg bitte den
will ich nicht … es soll nichts verschwommen aussehen oder so, im
gegenteil, richtig scharf und perfekt."

DER SILBERNE RING IST WEG. Er war die breiteste Flaeche der ganzen Uhr
und damit das Erste, was das Auge traf -- ausgerechnet der Teil, der
nichts anzeigt. Jetzt dunkles Metall; die drei Bahnen sind das Hellste
im Bild. Die Skalenstriche bleiben, sie geben Mass ohne zu fuellen.

DIE SEKUNDE IST EINE PUNKTREIHE. Sechzig Punkte, einer je Sekunde --
der schnellste Wert wird zaehlbar statt nur gewachsen. Das ist auch
ehrlicher: Die Sekunde SPRINGT, ein durchgehender Bogen behauptet einen
fliessenden Wert.

DIE BREITEN STAFFELN SICH: 3,2 / 5 / 7 statt 3 / 3,4 / 4. Die alten
Werte waren rechnerisch verschieden und im Bild nicht zu unterscheiden
-- ein Unterschied unter einem Pixel ist keiner. Jetzt liest man die
Ringe an ihrer STAERKE: je langsamer, desto schwerer.

SCHAERFE STATT NEBEL: Die weichen Scheine lagen mit 7 bis 9 px Radius
ueber den Bahnen wie Dunst. Jetzt 1,5 px -- sie liegen als KANTE an
statt als Wolke. Die Tiefe kommt aus dem Versatz der Lagen, so wie im
Rest dieser Uhr auch.

DREIMAL AN DERSELBEN STELLE DANEBEN, UND JEDES MAL IM BILD GESEHEN:

  1. Der Sekunden-Schweif stand noch im Dokument und war per CSS
     ausgeblendet -- das griff nicht, und ohne `dasharray` zeichnete er
     einen durchgehenden roten Ring um die ganze Uhr. Ein Element, das
     nie sichtbar sein soll, gehoert nicht ins Dokument. Ausblenden ist
     kein Entfernen.
  2. Dann das Punktmuster: n Paare plus Schluss-Luecke sind 2n+1 Werte.
     Bei ungerader Anzahl verdoppelt SVG die Liste und vertauscht dabei
     Striche und Luecken.
  3. Also eine Null angehaengt (`rest 0`) -- Anzahl gerade, Fehler
     blieb. Denn in `dasharray` wechseln sich Strich und Luecke ab: Nach
     2n Werten sitzt der naechste an UNGERADER Stelle und ist ein
     Strich. Der Rest wurde weiter gezeichnet. Richtig ist die Null
     ZUERST (`0 rest`), dann landet die Luecke an gerader Stelle.

UND DIE PRUEFUNG MUSSTE MIT. `pruef-start-ansicht` verglich die
REIHENFOLGE der Farbkanaele im Kachel-Licht. Das setzt voraus, dass die
Kanaele deutlich verschieden sind -- seit der neuen Palette stimmt das
nicht mehr: "Aufgaben" ist Tuerkis (G=191, B=163), gemessen 63 gegen 65.
ZWEI Stufen von 255. Die Reihenfolge kippt dort durch Rundung, und die
Pruefung meldete einen Fehler, wo keiner war.

Sie misst jetzt den FARBWINKEL -- dieselbe Frage ("ist es dieser Ton?"),
ohne die Voraussetzung. 40 Grad Toleranz; die Kachelfarben liegen nach
der Neuberechnung gut 60 Grad auseinander. Dazu eine GEGENPROBE je
Kachel: Der gemessene Ton wird gegen den Gegenton auf dem Farbkreis
gehalten und muss dort anschlagen. Eine Pruefung, die immer bestaetigt,
bestaetigt nichts.

Gemessen: Farbwinkel-Abstaende 13° / 16° / 7° von 40 erlaubten.
pruef-start-ansicht EXIT=0, 140 -> 143 Pruefungen (die drei Gegenproben
sind dazugekommen, keine ist verschwunden). pruef-css-klassen EXIT=0.

Co-Authored-By: Claude Opus 5 <[email protected]>

server/pruef-start-ansicht.mjs

@@ -750,18 +750,68 @@ console.log("\n=== Das Licht folgt dem Zeiger");
       ok(gemessen.punkte > 50 && gemessen.spanne >= 6,
         `"${name}": auf der Oberkante liegt ueberhaupt Farbe `
         + `(${gemessen.punkte} Punkte, Spanne ${gemessen.spanne})`);
-      /* Die REIHENFOLGE der Kanaele muss uebereinstimmen. Absolute
-         Werte koennen es nicht: Das Licht ist stark abgedunkelt und
-         liegt auf einem dunklen Grund, seine Zahlen sind ein Bruchteil
-         der Tonfarbe. Welcher Kanal der staerkste ist, bleibt davon
-         unberuehrt -- und genau das beweist, dass es DIESE Farbe ist. */
-      const reihe = (v) => [0, 1, 2].sort((a, c) => v[c] - v[a]).join("");
-      const sollReihe = reihe(b.soll);
-      const istReihe = reihe(p);
-      ok(sollReihe === istReihe,
+      /* DER FARBWINKEL, NICHT DIE REIHENFOLGE DER KANAELE (08.09.2026).
+
+         Hier stand ein Vergleich der Kanal-REIHENFOLGE: Welcher Kanal
+         ist der staerkste, welcher der zweite. Der Gedanke war richtig
+         -- absolute Werte taugen nicht, weil das Licht stark
+         abgedunkelt auf dunklem Grund liegt.
+
+         Er hat aber eine Voraussetzung, die niemand aufgeschrieben
+         hatte: Die Kanaele muessen deutlich verschieden sein. Seit die
+         Kachelfarben am 08.09.2026 neu gerechnet wurden, trifft das
+         nicht mehr ueberall zu. "Aufgaben" ist jetzt Tuerkis (#18bfa3)
+         mit G=191 und B=163 -- nach Abdunklung gemessen 63 gegen 65.
+         ZWEI Stufen von 255. Die Reihenfolge kippt dort durch
+         Rundung, und die Pruefung meldete einen Fehler, wo keiner war.
+
+         Der Farbwinkel misst dasselbe, nur ohne diese Voraussetzung:
+         Er sagt, WELCHE Farbe es ist, unabhaengig von Helligkeit und
+         Saettigung -- genau die Frage. 40 Grad Toleranz, weil das Licht
+         sich mit dem dunklen Untergrund mischt; verwechselbare Toene
+         der Palette liegen weiter auseinander (der kleinste Abstand
+         zweier Kachelfarben betraegt nach der Neuberechnung 0,097 in
+         OKLab, das sind hier gut 60 Grad).
+
+         Die Gegenprobe unten beweist, dass sie weiterhin anschlaegt. */
+      const winkel = (v) => {
+        const [r, g, bl] = v.map((x) => x / 255);
+        const max = Math.max(r, g, bl), min = Math.min(r, g, bl), d = max - min;
+        if (d < 0.004) return null;                 // grau, kein Ton
+        let h;
+        if (max === r) h = ((g - bl) / d) % 6;
+        else if (max === g) h = (bl - r) / d + 2;
+        else h = (r - g) / d + 4;
+        return ((h * 60) % 360 + 360) % 360;
+      };
+      const abstand = (a, c) => {
+        if (a === null || c === null) return 999;
+        const d = Math.abs(a - c);
+        return d > 180 ? 360 - d : d;
+      };
+      const sollWinkel = winkel(b.soll), istWinkel = winkel(p);
+      const ab = abstand(sollWinkel, istWinkel);
+      ok(ab <= 40,
         `das Licht auf "${name}" traegt den Ton der Kachel `
-        + `(${b.ton}: ${b.soll.join("/")} → gemessen ${p[0]}/${p[1]}/${p[2]}, `
-        + `Reihenfolge ${istReihe} gegen ${sollReihe})`);
+        + `(Farbwinkel ${sollWinkel === null ? "grau" : Math.round(sollWinkel) + "°"} `
+        + `gegen ${istWinkel === null ? "grau" : Math.round(istWinkel) + "°"}, `
+        + `Abstand ${Math.round(ab)}° von 40 erlaubt) `
+        + `(${b.ton}: ${b.soll.join("/")} → gemessen ${p[0]}/${p[1]}/${p[2]})`);
+
+      /* GEGENPROBE, einmal je Kachel: Eine Pruefung, die immer
+         bestaetigt, bestaetigt nichts. Der gemessene Ton wird gegen
+         eine ABSICHTLICH falsche Farbe gehalten -- den Gegenton auf dem
+         Farbkreis. Schlaegt das nicht an, misst die Pruefung nichts.
+
+         Der Gegenton ist der haerteste Fall: Er ist so weit entfernt,
+         wie zwei Farben ueberhaupt sein koennen. Wuerde die Toleranz
+         einmal versehentlich auf 180 Grad hochgesetzt, faellt es hier
+         sofort auf. */
+      const falsch = sollWinkel === null ? 180 : (sollWinkel + 180) % 360;
+      ok(abstand(falsch, istWinkel) > 40,
+        `  und sie erkennt den Gegenton als falsch `
+        + `(${Math.round(falsch)}° gegen gemessen `
+        + `${istWinkel === null ? "grau" : Math.round(istWinkel) + "°"})`);
     }
 
     await seite.mouse.move(2, 2);