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 undPathMeasureliegen aus demselben Grund genauso falsch. Path.op()berechnet geometrisch einen echten neuenPathaus 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.
- →Clipping Fundamentals: Canvas Clip Stack vs. Layer + Outline MaskWhat clip() actually is, a stencil in front of paint operations, which is exactly the tool this post shows the limits of.
- →PathMeasure: Position and Direction at Any Distance Along a PathPath.op() hands back a real Path, and a real Path is exactly what PathMeasure needs to walk, stroke-reveal, or sample by distance.
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 notchcut 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:
operation | result behält |
|---|---|
PathOperation.Union | alles, was von einem der beiden Kreise abgedeckt wird |
PathOperation.Intersect | nur die linsenförmige Überlappung |
PathOperation.Difference | Kreis a, mit der herausgebissenen Überlappung |
PathOperation.Xor | alles, 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 entsprichtXor, 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,UIBezierPathund SwiftUIsPathhaben 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.



