Para gráficos, prefiro não preferir números inteiros. Muitos sistemas usam números inteiros para a pintura da interface do usuário (afinal, os pixels são ints), mas o macOS, por exemplo, usa float para tudo. O macOS conhece apenas pontos e um ponto pode ser traduzido para um pixel, mas, dependendo da resolução do monitor, pode ser traduzido para outra coisa. Nas telas de retina, meio ponto (0,5 / 0,5) é pixel. Ainda assim, nunca notei que as interfaces do macOS são significativamente mais lentas que as outras. Afinal, todas as APIs 3D (OpenGL ou Direct3D) também funcionam com carros alegóricos e as bibliotecas gráficas modernas costumam tirar proveito da aceleração da GPU.
Agora você disse que a velocidade é a sua principal preocupação, ok, vamos em velocidade. Antes de executar qualquer algoritmo sofisticado, primeiro faça um teste simples. Crie uma caixa delimitadora alinhada ao eixo em torno do seu polígono. Isso é muito fácil, rápido e já pode proteger muitos cálculos. Como isso funciona? Itere todos os pontos do polígono e encontre os valores mínimo / máximo de X e Y.
Por exemplo, você tem os pontos (9/1), (4/3), (2/7), (8/2), (3/6). Isso significa que Xmin é 2, Xmax é 9, Ymin é 1 e Ymax é 7. Um ponto fora do retângulo com as duas arestas (2/1) e (9/7) não pode estar dentro do polígono.
// p is your point, p.x is the x coord, p.y is the y coord
if (p.x < Xmin || p.x > Xmax || p.y < Ymin || p.y > Ymax) {
// Definitely not within the polygon!
}
Este é o primeiro teste a ser executado em qualquer ponto. Como você pode ver, este teste é ultra rápido, mas também é muito grosseiro. Para lidar com pontos que estão dentro do retângulo delimitador, precisamos de um algoritmo mais sofisticado. Existem algumas maneiras de como isso pode ser calculado. O método que funciona também depende do fato de o polígono poder ter furos ou sempre ser sólido. Aqui estão exemplos de sólidos (um convexo, um côncavo):
E aqui está um com um buraco:
O verde tem um buraco no meio!
O algoritmo mais fácil, que pode lidar com todos os três casos acima e ainda é bastante rápido, é chamado de conversão de raios . A idéia do algoritmo é bastante simples: desenhe um raio virtual de qualquer lugar fora do polígono até o seu ponto e conte quantas vezes ele atinge um lado do polígono. Se o número de acertos for par, está fora do polígono, se for ímpar, está dentro.
O algoritmo do número do enrolamento seria uma alternativa, é mais preciso para os pontos estarem muito próximos de uma linha poligonal, mas também é muito mais lento. A conversão de raios pode falhar em pontos muito próximos ao lado de um polígono devido a problemas limitados de precisão e arredondamento de pontos flutuantes, mas, na realidade, isso dificilmente é um problema, como se um ponto estivesse tão próximo de um lado, geralmente não é visualmente possível para um visualizador para reconhecer se ele já está dentro ou fora.
Você ainda tem a caixa delimitadora acima, lembra? Basta escolher um ponto fora da caixa delimitadora e usá-lo como ponto de partida para o seu raio. Por exemplo, o ponto (Xmin - e/p.y)está fora do polígono, com certeza.
Mas o que é isso e? Bem, e(na verdade epsilon), dá à caixa delimitadora um pouco de preenchimento . Como eu disse, o traçado de raios falha se começarmos muito perto de uma linha poligonal. Como a caixa delimitadora pode ser igual ao polígono (se o polígono é um retângulo alinhado ao eixo, a caixa delimitadora é igual ao próprio polígono!), Precisamos de algum preenchimento para tornar isso seguro, é tudo. Quão grande você deve escolher e? Não muito grande. Depende da escala do sistema de coordenadas que você usa para desenhar. Se a largura da etapa do pixel for 1.0, basta escolher 1,0 (ainda assim, 0,1 também funcionaria)
Agora que temos o raio com suas coordenadas de início e fim, o problema muda de " é o ponto dentro do polígono " para "com que frequência o raio cruza um lado do polígono ". Portanto, não podemos apenas trabalhar com os pontos poligonais como antes, agora precisamos dos lados reais. Um lado é sempre definido por dois pontos.
side 1: (X1/Y1)-(X2/Y2)
side 2: (X2/Y2)-(X3/Y3)
side 3: (X3/Y3)-(X4/Y4)
:
Você precisa testar o raio contra todos os lados. Considere o raio como um vetor e cada lado como um vetor. O raio tem que atingir cada lado exatamente uma vez ou nunca. Não pode atingir o mesmo lado duas vezes. Duas linhas no espaço 2D sempre se cruzam exatamente uma vez, a menos que sejam paralelas; nesse caso, nunca se cruzam. No entanto, como os vetores têm um comprimento limitado, dois vetores podem não ser paralelos e ainda nunca se cruzarem, porque são muito curtos para se encontrarem.
// Test the ray against all sides
int intersections = 0;
for (side = 0; side < numberOfSides; side++) {
// Test if current side intersects with ray.
// If yes, intersections++;
}
if ((intersections & 1) == 1) {
// Inside of polygon
} else {
// Outside of polygon
}
Até aqui tudo bem, mas como você testa se dois vetores se cruzam? Aqui está um código C (não testado), que deve fazer o truque:
#define NO 0
#define YES 1
#define COLLINEAR 2
int areIntersecting(
float v1x1, float v1y1, float v1x2, float v1y2,
float v2x1, float v2y1, float v2x2, float v2y2
) {
float d1, d2;
float a1, a2, b1, b2, c1, c2;
// Convert vector 1 to a line (line 1) of infinite length.
// We want the line in linear equation standard form: A*x + B*y + C = 0
// See: http://en.wikipedia.org/wiki/Linear_equation
a1 = v1y2 - v1y1;
b1 = v1x1 - v1x2;
c1 = (v1x2 * v1y1) - (v1x1 * v1y2);
// Every point (x,y), that solves the equation above, is on the line,
// every point that does not solve it, is not. The equation will have a
// positive result if it is on one side of the line and a negative one
// if is on the other side of it. We insert (x1,y1) and (x2,y2) of vector
// 2 into the equation above.
d1 = (a1 * v2x1) + (b1 * v2y1) + c1;
d2 = (a1 * v2x2) + (b1 * v2y2) + c1;
// If d1 and d2 both have the same sign, they are both on the same side
// of our line 1 and in that case no intersection is possible. Careful,
// 0 is a special case, that's why we don't test ">=" and "<=",
// but "<" and ">".
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// The fact that vector 2 intersected the infinite line 1 above doesn't
// mean it also intersects the vector 1. Vector 1 is only a subset of that
// infinite line 1, so it may have intersected that line before the vector
// started or after it ended. To know for sure, we have to repeat the
// the same test the other way round. We start by calculating the
// infinite line 2 in linear equation standard form.
a2 = v2y2 - v2y1;
b2 = v2x1 - v2x2;
c2 = (v2x2 * v2y1) - (v2x1 * v2y2);
// Calculate d1 and d2 again, this time using points of vector 1.
d1 = (a2 * v1x1) + (b2 * v1y1) + c2;
d2 = (a2 * v1x2) + (b2 * v1y2) + c2;
// Again, if both have the same sign (and neither one is 0),
// no intersection is possible.
if (d1 > 0 && d2 > 0) return NO;
if (d1 < 0 && d2 < 0) return NO;
// If we get here, only two possibilities are left. Either the two
// vectors intersect in exactly one point or they are collinear, which
// means they intersect in any number of points from zero to infinite.
if ((a1 * b2) - (a2 * b1) == 0.0f) return COLLINEAR;
// If they are not collinear, they must intersect in exactly one point.
return YES;
}
Os valores de entrada são os dois pontos finais do vetor 1 ( v1x1/v1y1e v1x2/v1y2) e do vetor 2 ( v2x1/v2y1e v2x2/v2y2). Então você tem 2 vetores, 4 pontos, 8 coordenadas. YESe NOsão claros. YESaumenta interseções, NOnão faz nada.
E o COLLINEAR? Isso significa que ambos os vetores estão na mesma linha infinita, dependendo da posição e do comprimento, não se cruzam nem se interceptam em um número infinito de pontos. Não tenho certeza absoluta de como lidar com este caso, não o contaria como interseção de qualquer maneira. Bem, este caso é bastante raro na prática, devido a erros de arredondamento de ponto flutuante; código melhor provavelmente não testaria, == 0.0fmas sim algo como < epsilon, onde epsilon é um número bastante pequeno.
Se você precisar testar um número maior de pontos, certamente poderá acelerar um pouco a coisa toda, mantendo na memória as formas padrão das equações lineares dos lados dos polígonos, para que você não precise recalculá-las todas as vezes. Isso economizará duas multiplicações de ponto flutuante e três subtrações de ponto flutuante em cada teste, em troca de armazenar três valores de ponto flutuante por lado do polígono na memória. É uma troca típica de memória versus tempo de computação.
Por último, mas não menos importante: se você pode usar o hardware 3D para resolver o problema, existe uma alternativa interessante. Apenas deixe a GPU fazer todo o trabalho para você. Crie uma superfície de pintura que esteja fora da tela. Encha-o completamente com a cor preta. Agora deixe o OpenGL ou o Direct3D pintar seu polígono (ou mesmo todos os seus polígonos, se você quiser apenas testar se o ponto está em algum deles, mas você não se importa com qual deles) e preencher o (s) polígono (s) com um diferente cor, por exemplo, branco. Para verificar se um ponto está dentro do polígono, obtenha a cor desse ponto na superfície de desenho. Esta é apenas uma busca de memória O (1).
É claro que esse método só pode ser usado se a superfície do desenho não precisar ser grande. Se não puder caber na memória da GPU, esse método é mais lento do que na CPU. Se precisar ser enorme e sua GPU suportar shaders modernos, você ainda poderá usá-la implementando a transmissão de raios mostrada acima como shader de GPU, o que é absolutamente possível. Para um número maior de polígonos ou um grande número de pontos a serem testados, isso será recompensado, considere que algumas GPUs poderão testar 64 a 256 pontos em paralelo. Observe, no entanto, que transferir dados da CPU para a GPU e vice-versa é sempre caro, portanto, apenas para testar alguns pontos em alguns polígonos simples, em que os pontos ou os polígonos são dinâmicos e mudam com frequência, uma abordagem da GPU raramente paga fora.
