L'intuition
Besoin de découper une encoche dans une carte, ou de fusionner deux blobs
qui se chevauchent en un seul contour ? clip() semble être l'outil pour
ça, mais il n'a pas été conçu pour ça :
clip()ne fait que restreindre ce qui est déjà dessiné à une forme . Il ne peut pas fusionner deux formes en un nouveau contour, et il ne peut pas produire "juste le chevauchement" ou "A moins B" comme un vrai path réutilisable.- La solution de contournement habituelle consiste à truquer le résultat :
dessiner la carte, puis peindre un cercle de la couleur du fond
par-dessus pour simuler une bouchée prise sur le bord. Ça a l'air juste
jusqu'à ce qu'on ajoute un
border(), qui continue de tracer le rectangle arrondi complet, en ignorant totalement le cercle, parce que rien dans le path sous-jacent n'a jamais changé. Le hit-testing etPathMeasurese trompent de la même façon, pour la même raison. Path.op()calcule un véritable nouveauPath, géométriquement, à partir de deux paths source et d'une règle booléenne. L'encoche (ou la fusion, ou le chevauchement) devient une vraie donnée de contour, pas une approximation visuelle.
- →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.
Découper une encoche : clip() ne peut pas soustraire, Path.op() le peut
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 est un vrai path : tracez-le, clippez-le, faites du hit-testing
contre lui, ou passez-le à PathMeasure, et chacune de ces opérations
voit l'encoche, parce qu'elle se trouve dans les données de points du
path lui-même, pas peinte par-dessus.
Quatre opérations, une seule paire de formes
Le même mécanisme répond à bien plus que "découper une encoche". Deux
cercles qui se chevauchent, quatre résultats différents, selon le seul
PathOperation que vous choisissez :
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) }Les deux mêmes cercles, le même appel, seul operation change :
operation | result conserve |
|---|---|
PathOperation.Union | tout ce qui est couvert par l'un des deux cercles |
PathOperation.Intersect | uniquement le chevauchement en forme de lentille |
PathOperation.Difference | le cercle a, avec le chevauchement retiré |
PathOperation.Xor | tout ce qui est couvert par exactement un cercle, pas les deux |
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 et Intersect sont symétriques : échanger a et b donne le
même résultat dans les deux cas. Difference ne l'est pas : ça signifie
toujours "premier argument moins second". PathOperation.ReverseDifference
existe précisément pour vous permettre d'inverser la forme soustraite sans
réordonner les arguments, utile quand a et b sont des variables nommées
que vous ne voulez pas échanger dans le code.
Le fondamental
C'est la combinaison booléenne de paths : traiter deux formes comme des ensembles de points couverts et les combiner avec des opérations ensemblistes. Union conserve les points dans l'une ou l'autre forme, intersect conserve les points dans les deux, difference conserve les points dans la première forme mais pas dans la seconde, et xor conserve les points dans exactement une. Le résultat est calculé comme une géométrie réelle, une nouvelle séquence de points et de courbes, pas un effet visuel superposé aux originaux.
Ailleurs : même fondamental, framework différent
- Figma / Illustrator Pathfinder : les mêmes quatre opérations, sous
les noms Union, Subtract, Intersect et Exclude. Subtract correspond à
Difference, Exclude àXor, et les designers utilisent exactement ce panneau pour faire le même découpage d'encoche et la même fusion de formes dont parle cet article. - SwiftUI / Core Graphics : étonnamment absent.
CGPath,UIBezierPathet lePathde SwiftUI n'ont pas d'union, de subtract, d'intersect ou de xor intégrés — les développeurs iOS se tournent vers une bibliothèque tierce comme VectorBoolean, ou retombent exactement sur le truc "peindre une forme par-dessus" que cet article démonte dès son introduction, parce que la plateforme n'a jamais livré le vrai outil. - Le modificateur Boolean de Blender,
union()/difference()/intersection()d'OpenSCAD : les mêmes mathématiques, exactement, promues des paths 2D aux volumes 3D, sous leur nom formel, la géométrie solide constructive (CSG). Une encoche découpée dans une carte et un trou percé dans un support imprimé en 3D sont la même opération ensembliste, à une dimension d'écart. - Shapely (Python) :
.union(),.difference(),.intersection(), et.symmetric_difference()sur des objets polygon, utilisés pour le SIG et les requêtes de chevauchement spatial plutôt que pour l'UI, mais ce sont les mêmes quatre opérations sous leurs noms littéraux issus de la théorie des ensembles.
Cas limites
La valeur de retour Boolean signale un échec de calcul, pas un
résultat vide. op() renvoie false quand il ne peut pas calculer du
tout, typiquement parce qu'un des paths d'entrée contient un point non
fini, pas parce que la forme résultante se trouve être vide.
L'intersection de deux cercles qui ne se chevauchent pas est un appel
parfaitement valide qui renvoie true et vous laisse avec un path vide,
comme pour l'intersection de n'importe quelles autres formes disjointes.
Le contenu antérieur du récepteur est remplacé, pas fusionné.
result.op(a, b, operation) définit result comme étant le résultat
de la combinaison de a et b ; ce que result contenait avant l'appel
est écarté, pas intégré au calcul. Réutiliser un Path de longue durée
comme destination ne nécessite pas d'appeler reset() au préalable, mais
cela signifie aussi que vous ne pouvez pas compter sur la persistance de
l'ancien contenu. Pour construire un résultat à travers plusieurs
opérations, réinjectez la sortie de l'appel précédent comme l'un des deux
paths d'entrée de l'appel suivant, plutôt que d'appeler op() à
répétition sur le même objet en espérant qu'il accumule.
La règle de remplissage régit toujours chaque forme source en premier.
Avant que les calculs booléens ne s'exécutent, "ce point est-il à
l'intérieur du path a" doit être résolu pour a et b individuellement,
la même question de path auto-intersectant à laquelle répond n'importe
quelle règle de remplissage. Un path source auto-intersectant est toujours
résolu par sa règle de remplissage avant que op() ne le combine avec
l'autre forme.
Le modèle mental à retenir
Path.op() ne simule pas une découpe ou une fusion par un dessin
superposé, il calcule un nouveau contour réel. Utilisez-le chaque fois
que la forme que vous voulez n'est pas une forme que vous pouvez dessiner
directement, mais une forme que vous pouvez décrire comme "A et B,
combinés par une opération ensembliste" : le trait, le clip, le
hit-testing et PathMeasure finissent tous par voir la même forme que
vous.



