Recomposed
Canvas

Path.op() : Combiner des formes sans acrobaties de clip

Oct 19, 2026 · 5 min read

Path.op() : Combiner des formes sans acrobaties de clip

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 et PathMeasure se trompent de la même façon, pour la même raison.
  • Path.op() calcule un véritable nouveau Path, 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.

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 notch
FIG. 01
Faked notch (left): border ignores it. Path.op() Difference (right): border follows the real cut.

cut 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 :

operationresult conserve
PathOperation.Uniontout ce qui est couvert par l'un des deux cercles
PathOperation.Intersectuniquement le chevauchement en forme de lentille
PathOperation.Differencele cercle a, avec le chevauchement retiré
PathOperation.Xortout 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, UIBezierPath et le Path de 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.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail