Recomposed
Canvas

Path.op(): Formen kombinieren ohne Clip-Gymnastik

Oct 19, 2026 · 4 min read

Path.op(): Formen kombinieren ohne Clip-Gymnastik

Die Intuition

Muss eine Kerbe aus einer Karte ausgeschnitten werden, oder sollen zwei überlappende Blobs zu einer Umrisslinie verschmolzen werden? clip() fühlt sich wie das passende Werkzeug an, ist aber nicht dafür gebaut:

  • clip() schränkt immer nur ein, was bereits gezeichnet wurde, auf eine -Form. Es kann zwei Formen nicht zu einer neuen Umrisslinie verschmelzen, und es kann weder "nur die Überlappung" noch "A minus B" als echten, wiederverwendbaren Path erzeugen.
  • Der übliche Workaround ist, es vorzutäuschen: die Karte zeichnen und dann einen Kreis in Hintergrundfarbe darüber malen, um einen Biss aus dem Rand zu simulieren. Das sieht richtig aus, bis ein border() hinzukommt, der weiterhin das vollständige abgerundete Rechteck nachzeichnet und den Kreis dabei komplett ignoriert, weil sich am zugrunde liegenden Path nie etwas geändert hat. Hit-Testing und PathMeasure liegen aus demselben Grund genauso falsch.
  • Path.op() berechnet geometrisch einen echten neuen Path aus zwei Quell-Paths und einer booleschen Regel. Die Kerbe (oder die Verschmelzung, oder die Überlappung) wird zu echten Umrissdaten, nicht zu einer visuellen Annäherung.

Eine Kerbe ausschneiden: clip() kann nicht subtrahieren, Path.op() schon

val card = Path().apply {
    addRoundRect(RoundRect(0f, 0f, 300f, 160f, cornerRadius = CornerRadius(16f)))
}
val notch = Path().apply {
    addOval(Rect(center = Offset(150f, 0f), radius = 24f))
}
 
// Faking it: paint a background-colored circle over the edge.
// Looks right with no border. Add one, and it still traces the
// untouched rounded rect, because `card` itself never changed.
drawPath(card, color = Color.White)
drawCircle(color = pageBackground, radius = 24f, center = Offset(150f, 0f))
drawPath(card, color = Color.Black, style = Stroke(width = 2f)) // ignores the notch
 
// Path.op(): the notch is cut from the actual outline.
val cut = Path()
cut.op(card, notch, PathOperation.Difference)
drawPath(cut, color = Color.White)
drawPath(cut, color = Color.Black, style = Stroke(width = 2f)) // follows the notch
FIG. 01
Faked notch (left): border ignores it. Path.op() Difference (right): border follows the real cut.

cut ist ein echter Path: ihn zu stroken, darauf zu clippen, gegen ihn hit-zu-testen oder ihn an PathMeasure zu übergeben, jede dieser Operationen sieht die Kerbe, weil sie in den eigenen Punktdaten des Paths sitzt, nicht darüber gemalt ist.

Vier Operationen, ein Formenpaar

Derselbe Mechanismus beantwortet mehr als nur "eine Kerbe ausschneiden". Zwei überlappende Kreise, vier unterschiedliche Ergebnisse, je nachdem, welche PathOperation gewählt wird:

val a = Path().apply { addOval(Rect(0f, 0f, 200f, 200f)) }
val b = Path().apply { addOval(Rect(100f, 0f, 300f, 200f)) }
val result = Path().apply { op(a, b, operation) }

Dieselben zwei Kreise, derselbe Funktionsaufruf, nur operation ändert sich:

operationresult behält
PathOperation.Unionalles, was von einem der beiden Kreise abgedeckt wird
PathOperation.Intersectnur die linsenförmige Überlappung
PathOperation.DifferenceKreis a, mit der herausgebissenen Überlappung
PathOperation.Xoralles, was von genau einem Kreis abgedeckt wird, nicht von beiden

Drag circle B left or right. The filled shape is op(a, b, PathOperation.Union): everything covered by either circle. Union: everything covered by either circle.

Union und Intersect sind symmetrisch: a und b zu vertauschen liefert in beiden Fällen dasselbe Ergebnis. Difference ist das nicht: es bedeutet immer "erstes Argument minus zweites". PathOperation.ReverseDifference existiert speziell dafür, umzudrehen, welche Form subtrahiert wird, ohne die Argumente neu zu ordnen, nützlich, wenn a und b benannte Variablen sind, die man nicht quer durch die Codebasis vertauschen möchte.

Das Fundamentale

Das ist boolesche Path-Kombination: zwei Formen als Mengen abgedeckter Punkte behandeln und sie mit Mengenoperationen kombinieren. Union behält Punkte in einer der beiden Formen, Intersect behält Punkte in beiden, Difference behält Punkte in der ersten Form, aber nicht in der zweiten, und Xor behält Punkte in genau einer. Das Ergebnis wird als echte Geometrie berechnet, eine neue Folge von Punkten und Kurven, nicht als visueller Effekt, der über die Originale gelegt wird.

Anderswo: dasselbe Fundamentale, anderes Framework

  • Figma / Illustrator Pathfinder: dieselben vier Operationen, unter den Namen Union, Subtract, Intersect und Exclude. Subtract entspricht Difference, Exclude entspricht Xor, und Designer greifen genau zu diesem Panel, um dasselbe Kerben-Ausschneiden und Formen-Verschmelzen zu tun, um das es in diesem Beitrag geht.
  • SwiftUI / Core Graphics: auffällig fehlend. CGPath, UIBezierPath und SwiftUIs Path haben kein eingebautes Union, Subtract, Intersect oder Xor, iOS-Entwickler greifen zu einer Drittanbieter-Bibliothek wie VectorBoolean oder fallen auf genau den "eine Form darüber malen"-Fake zurück, den dieser Beitrag zu Beginn entkräftet, weil die Plattform das Echte nie ausgeliefert hat.
  • Blenders Boolean-Modifier, OpenSCADs union()/difference()/ intersection(): dieselbe Mathematik, von 2D-Paths auf 3D-Volumen gehoben, unter ihrem formalen Namen, Constructive Solid Geometry (CSG). Eine in eine Karte geschnittene Kerbe und ein durch eine 3D-gedruckte Halterung gebohrtes Loch sind dieselbe Mengenoperation, nur eine Dimension weiter.
  • Shapely (Python): .union(), .difference(), .intersection() und .symmetric_difference() auf Polygon-Objekten, verwendet für GIS und räumliche Überlappungsabfragen statt für UI, aber es sind dieselben vier Operationen unter ihren wörtlichen mengentheoretischen Namen.

Grenzfälle

Der Boolean-Rückgabewert signalisiert eine fehlgeschlagene Berechnung, nicht ein leeres Ergebnis. op() gibt false zurück, wenn überhaupt nicht berechnet werden kann, typischerweise weil einer der Eingabe-Paths einen nicht-endlichen Punkt enthält, nicht weil die resultierende Form zufällig leer ist. Zwei Kreise zu schneiden, die sich nicht überlappen, ist ein völlig gültiger Aufruf, der true zurückgibt und einen leeren Path hinterlässt, genau wie das Schneiden beliebiger anderer disjunkter Formen.

Der bisherige Inhalt des Empfängers wird ersetzt, nicht eingemischt. result.op(a, b, operation) setzt result auf das Ergebnis der Kombination von a und b; was result vor dem Aufruf enthielt, wird verworfen, nicht in die Berechnung eingearbeitet. Einen langlebigen Path als Ziel wiederzuverwenden erfordert kein vorheriges reset(), bedeutet aber auch, dass man sich nicht darauf verlassen kann, dass alte Inhalte erhalten bleiben. Um ein Ergebnis über mehrere Operationen hinweg aufzubauen, wird die Ausgabe des vorherigen Aufrufs als einer der zwei Eingabe-Paths des nächsten Aufrufs zurückgespeist, statt op() wiederholt auf demselben Objekt aufzurufen und zu erwarten, dass es sich akkumuliert.

Die Füllregel bestimmt weiterhin zuerst jede Quellform. Bevor die boolesche Mathematik läuft, muss "liegt dieser Punkt innerhalb von Path a" für a und b einzeln beantwortet werden, dieselbe Frage nach selbstüberschneidenden Paths, die jede Füllregel beantwortet. Ein selbstüberschneidender Quell-Path wird weiterhin zuerst von seiner Füllregel aufgelöst, bevor op() ihn überhaupt mit der anderen Form kombiniert.

Mentales Modell zum tatsächlichen Gebrauch

Path.op() täuscht keinen Schnitt oder eine Verschmelzung mit geschichtetem Zeichnen vor, es berechnet eine neue, echte Umrisslinie. Greif darauf zurück, sobald die gewünschte Form keine ist, die direkt gezeichnet werden kann, aber eine, die als "A und B, kombiniert durch eine Mengenoperation" beschrieben werden kann: Stroke, Clip, Hit-Test und PathMeasure sehen am Ende alle dieselbe Form wie man selbst.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach