Recomposed
Canvas

Path.op(): Combinando Formas Sem Ginástica de Clip

Oct 19, 2026 · 5 min read

Path.op(): Combinando Formas Sem Ginástica de Clip

A intuição

Precisa recortar um entalhe em um cartão, ou mesclar duas formas sobrepostas em um único contorno? clip() parece a ferramenta certa para o trabalho, mas ele não foi feito para isso:

  • clip() sempre se limita a restringir o que já foi desenhado a uma forma de . Ele não consegue mesclar duas formas em um novo contorno, e não consegue produzir "apenas a sobreposição" ou "A menos B" como um path real e reutilizável.
  • A solução alternativa de sempre é falsificar o resultado: desenhar o cartão e, em seguida, pintar um círculo da cor do fundo por cima para simular uma mordida na borda. Isso funciona até você adicionar um border(), que continua traçando o retângulo arredondado completo, ignorando o círculo por completo, porque nada no path subjacente realmente mudou. O hit-testing e o PathMeasure erram pelo mesmo motivo.
  • Path.op() computa um novo Path de verdade, geometricamente, a partir de dois paths de origem e uma regra booleana. O entalhe (ou a mesclagem, ou a sobreposição) se torna dado real de contorno, não uma aproximação visual.

Recortando um entalhe: clip() não consegue subtrair, Path.op() consegue

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 é um path real: aplique stroke nele, recorte com ele, faça hit-testing contra ele, ou alimente-o para o PathMeasure, e cada um desses vai enxergar o entalhe, porque ele está nos próprios dados de pontos do path, não pintado por cima.

Quatro operações, um único par de formas

O mesmo mecanismo responde a mais do que "recortar um entalhe". Dois círculos sobrepostos, quatro resultados diferentes, dependendo apenas de qual PathOperation você escolhe:

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) }

Os mesmos dois círculos, a mesma forma de chamada, apenas operation muda:

operationresult mantém
PathOperation.Uniontudo coberto por qualquer um dos círculos
PathOperation.Intersectapenas a sobreposição em forma de lente
PathOperation.Differenceo círculo a, com a sobreposição mordida fora
PathOperation.Xortudo coberto por exatamente um círculo, não os dois

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 e Intersect são simétricas: trocar a por b dá o mesmo resultado nos dois sentidos. Difference não é: sempre significa "o primeiro argumento menos o segundo". PathOperation.ReverseDifference existe justamente para você inverter qual forma é subtraída sem reordenar os argumentos, útil quando a e b são variáveis nomeadas que você não quer trocar de lugar pelo código.

O fundamento

Isso é combinação booleana de paths: tratar duas formas como conjuntos de pontos cobertos e combiná-las com operações de conjuntos. Union mantém pontos em qualquer uma das formas, intersect mantém pontos em ambas, difference mantém pontos na primeira forma mas não na segunda, e xor mantém pontos em exatamente uma. O resultado é computado como geometria real, uma nova sequência de pontos e curvas, não um efeito visual empilhado sobre os originais.

Em outros lugares: o mesmo fundamento, frameworks diferentes

  • Figma / Illustrator Pathfinder: as mesmas quatro operações, sob os nomes Union, Subtract, Intersect e Exclude. Subtract é Difference, Exclude é Xor, e designers recorrem exatamente a esse painel para fazer o mesmo recorte de entalhes e mesclagem de formas de que este post trata.
  • SwiftUI / Core Graphics: notavelmente ausente. CGPath, UIBezierPath e o Path do SwiftUI não têm union, subtract, intersect ou xor embutidos — desenvolvedores iOS recorrem a uma biblioteca de terceiros como VectorBoolean, ou caem na mesma falsificação de "pintar uma forma por cima" que este post desmonta logo no início, porque a plataforma nunca entregou a coisa de verdade.
  • Boolean modifier do Blender, union()/difference()/ intersection() do OpenSCAD: a mesma matemática, promovida de paths 2D para volumes 3D, sob seu nome formal, geometria sólida construtiva (CSG). Um entalhe recortado em um cartão e um furo perfurado através de um suporte impresso em 3D são a mesma operação de conjunto, com uma dimensão a mais.
  • Shapely (Python): .union(), .difference(), .intersection(), e .symmetric_difference() em objetos de polígono, usados para GIS e consultas de sobreposição espacial em vez de UI, mas são as mesmas quatro operações sob seus nomes literais da teoria dos conjuntos.

Casos de borda

O valor de retorno Boolean sinaliza uma falha no cálculo, não um resultado vazio. op() retorna false quando não consegue computar de jeito nenhum, tipicamente porque um dos paths de entrada contém um ponto não finito, não porque a forma resultante por acaso está vazia. Intersectar dois círculos que não se sobrepõem é uma chamada perfeitamente válida que retorna true e deixa você com um path vazio, assim como intersectar quaisquer outras formas disjuntas.

O conteúdo anterior do receptor é substituído, não mesclado. result.op(a, b, operation) define result como o resultado de combinar a e b; o que quer que result contivesse antes da chamada é descartado, não incorporado ao cálculo. Reutilizar um Path de vida longa como destino não exige um reset() antes, mas também significa que você não pode contar com o conteúdo antigo permanecer. Para construir um resultado ao longo de várias operações, alimente a saída da chamada anterior de volta como um dos dois paths de entrada da próxima chamada, em vez de chamar op() repetidamente no mesmo objeto esperando que ele acumule.

A regra de preenchimento ainda rege cada forma de origem primeiro. Antes de a matemática booleana rodar, "este ponto está dentro do path a" precisa ser respondida para a e b individualmente, a mesma pergunta sobre paths autointersectantes que qualquer regra de preenchimento responde. Um path de origem autointersectante ainda é resolvido pela sua regra de preenchimento antes de op() combiná-lo com a outra forma.

Modelo mental para usar de verdade

Path.op() não falsifica um recorte ou uma mesclagem com desenho empilhado, ele computa um novo contorno, real. Recorra a ele sempre que a forma que você quer não for uma que você pode desenhar diretamente, mas for uma que você pode descrever como "A e B, combinados por uma operação de conjunto": stroke, clip, hit-test e PathMeasure acabam todos enxergando a mesma forma que você.

Keep reading

Related reads

Receba novos posts no seu e-mail