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 oPathMeasureerram pelo mesmo motivo. Path.op()computa um novoPathde 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.
- →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.
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 notchcut é 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:
operation | result mantém |
|---|---|
PathOperation.Union | tudo coberto por qualquer um dos círculos |
PathOperation.Intersect | apenas a sobreposição em forma de lente |
PathOperation.Difference | o círculo a, com a sobreposição mordida fora |
PathOperation.Xor | tudo 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,UIBezierPathe oPathdo 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ê.



