Qual é a ideia por trás da definição de retângulos com dois pontos? [fechadas]

Não é que isso não faça sentido, mas funciona mal em 99% das vezes.

Geralmente, os retângulos gráficos 2D são inicializados, armazenados e manipulados como um par de pontos. Em nenhum idioma específico,

class Rect:
   p1, p2: point

Faz mais sentido definir um retângulo como dois valores x e dois valores y, assim:

class Rect
   xleft, xright: int
   ytop, ybottom: int

Com dois pontos, se em algum lugar do código-fonte você quiser usar o valor y do topo, você deve dizer rect.p1.y (hmmm, pare e pense, é p1 ou p2), mas com os quatro valores como membros simples dos dados, é claro e direto: rect.ytop (não é necessário pensar!) O uso de dois pontos significa que, ao lidar com a vertical, é necessário emaranhar a horizontal; há uma relação estranha entre elementos independentes.

Como surgiu essa ideia de dois pontos e por que persiste? Tem algum benefício sobre as coordenadas nuas x e y?

NOTA ADICIONADA: Esta pergunta está no contexto de retângulos alinhados com XY, como em gerenciadores de janelas e kits de ferramentas da GUI, não no contexto de formas arbitrárias no aplicativo de desenho e pintura.

Você considerou menos propenso a erros?

Se você usar (Ponto1, Ponto2), ficará muito claro o que você está especificando. Se você fornecer 2 pontos, o único erro possível é que o usuário misturou seus x e y ao construir os pontos, pois a ordem dos pontos não importa.

Se você fornecer 4 números inteiros, se alguém não estiver prestando atenção, eles poderão fornecer (x1, x2, y1, y2) quando você desejar (x1, y1, x2, y2) ou vice-versa. Além disso, algumas APIs, como a estrutura Rect do WCF, definem um retângulo como (x, y, largura, altura), o que pode causar confusão sobre o que (1, 2, 3, 4) significa. Isso é (x, y, w, h) ou (x1, y1, x2, y2) ou (x1, x2, y1, y2)?

Em suma, (Ponto1, Ponto2) parece um pouco mais seguro para mim.

Eu sempre gostei de definir um retângulo como um ponto + largura e altura, onde o ponto é o canto superior esquerdo do retângulo.

class Rect {
  float x, y;
  float width, height;
}

E adicione os métodos necessários para buscar as outras métricas. Como a versão Java

Na verdade, um retângulo não é definido por 2 pontos. Um retângulo só pode ser definido por dois pontos se for paralelo aos eixos.

Existem várias maneiras de representar retângulos paralelos aos eixos:

1. Dois pontos diagonalmente opostos
2. Um ponto de canto, altura e largura
3. Ponto central, meia altura e largura (incomum, mas às vezes útil).
4. Como duas coordenadas X e duas coordenadas Y

Para (1), muitas bibliotecas usam uma convenção para determinar quais dois pontos são usados ​​- topLeft e bottomRight, por exemplo.

A escolha da representação pode ser orientada pelo objetivo original da definição do retângulo, mas imagino que ela seja frequentemente arbitrária . As representações são equivalentes nas informações que elas carregam. Porém, diferem na facilidade com que as propriedades do retângulo podem ser calculadas e na conveniência com que as operações podem ser executadas no retângulo.

Os benefícios da definição (1) sobre outros incluem:

• Consistência da API com outros polígonos, linhas etc.
• topLeft, bottomRight pode ser passado para qualquer método que aceite pontos
• Os métodos da classe Point podem ser chamados em topLeft, bottomRight
• A maioria das propriedades pode ser derivada facilmente, por exemplo. bottomLeft, topRight, largura, altura, centro, comprimento diagonal etc.

Bem, p1: Pointe p2: Pointcada uma delas terá duas intcoordenadas , de qualquer maneira, então sua classe não equivale à mesma coisa?

E se você armazenar esses dois pontos como Pointobjetos de primeira classe , não terá mais utilidade deles? Na maioria dos sistemas de coordenadas gráficas que eu conheço, os pontos são subclassificados dessa maneira para criar uma hierarquia de objetos: point -> circle -> ellipsee assim por diante.

Portanto, se você criar um objeto que não usa a Pointclasse, você o separou do restante da hierarquia de classes.

É por isso que eu gosto do Delphi TRect. É definido como um registro variante (estrutura de união em C-speak) que pode ser interpretado como um ponto TopLeft e BottomRight, ou inteiros Top, Left, Bottom e Right, o que for mais conveniente no momento.

Certamente, se você definir seu retângulo como:

class Rect
{
    Point bottomLeft;
    Point topRight;
}

então você sabe imediatamente qual é o ponto.

Melhor ainda seria adicionar propriedades extras que permitissem manipular o retângulo da maneira que fosse necessária para o seu aplicativo. Isso simplesmente atualizaria a estrutura de dados subjacente.

Ao adicionar uma transformação à forma, você pode orientar seu retângulo da maneira que desejar. Você ainda precisaria de uma caixa delimitadora alinhada ao eixo para verificações rápidas de aceitação / rejeição :)

No entanto, se seu modelo permitir retângulos em qualquer orientação sem aplicar uma transformação, "canto inferior esquerdo" e "canto superior direito" não terão significado, o que leva a "p1" e "p2" (ou algo equivalente).

acho que faz mais sentido que um retângulo seja representado por uma extensão xey de um ponto; você pode até fazer a localização apontar para o centro do retângulo, para que seja independente da rotação

mas provavelmente foi mais fácil codificá-lo como dois pontos!

Não gosto disso porque lançamos fora um grau de liberdade potencial, que essencialmente permite uma rotação arbitrária. Um retângulo 2D geral possui cinco incógnitas (graus de liberdade). Poderíamos especificá-los como as coordenadas de um ponto, os comprimentos dos dois lados que formam um vértice com esse ponto e o ângulo da horizontal da primeira linha (sendo o outro assumido um ângulo 90 graus maior). Um número infinito de outras possibilidades também pode ser usado, mas há cinco quantidades independentes que devem ser especificadas. Algumas escolhas levarão a álgebra mais fácil do que outras, dependendo do que for feito com elas.

Não é exatamente o mesmo que 2 pontos? Como isso é constrangedor ... a maioria das rotinas de desenho exige pontos, não componentes x / y separados.

Definir retângulos como pares de pontos permite reutilizar o ponto como um vértice para outra forma. Apenas um pensamento...

Eu acredito que é principalmente estabelecer uniformidade entre todas as formas primitivas.

Claro que você pode definir o retângulo de várias maneiras diferentes, mas como você define um triângulo, uma estrela ou um círculo de uma maneira que possa usar estruturas de dados semelhantes?

Todos os polígonos podem ser definidos por seus pontos, com uma pequena quantidade de lógica para determinar o que fazer com os pontos.

As bibliotecas gráficas operam principalmente nesses polígonos em termos de vértices e arestas, portanto, pontos e linhas entre eles, todos os cálculos funcionam nesses dois recursos, bem isso e facetas, mas isso é apenas uma função das arestas.

Em duas dimensões, armazenar um retângulo como dois pontos é mais claro do que definir um canto específico e uma largura e altura - considere largura ou altura negativa ou os cálculos necessários para determinar cada opção da outra.

Executar rotações em um retângulo definido por pontos também é muito mais simples do que aquele definido com um ponto mais largura e altura.

Eu esperaria que o encapsulamento tornasse essa diferenciação sem importância como usuário da classe.

Um retângulo deve ser definido como três pontos a serem bem definidos em 3 dimensões. Não tenho muita certeza do requisito para definir um retângulo em 4 ou mais dimensões.

É completamente arbitrário. Você precisa de quatro informações para desenhar um retângulo. O (s) designer (s) da biblioteca decidiu representá-lo com dois pontos (cada um com uma coordenada xy), mas poderia facilmente fazê-lo com x / y / m / h ou em cima / baixo / esquerda / direita.

Suponho que a verdadeira questão do OP seja: por que essa escolha específica foi feita?

A escolha dos parâmetros é importante apenas para os projetistas / codificadores de baixo nível.

Usuários de alto nível só precisam pensar em:

• IsPointInRect
• Área
• Interseção (ou recorte)
• HasOverlap (igual a Intersection.Area> 0)
• União (torna-se uma lista de retângulos)
• Subtração (uma lista de retângulos que representam o mesmo conjunto de pontos que está no retângulo A, mas não no retângulo B)
• Transformar
  • Mudanças em X e Y
  • Rotação (0, 90, 180, 270)
  • Escalonamento em X e Y (consulte a nota)
• Sintaxe simples para as propriedades Xmin, Xmax, Ymin, Ymax, Largura, Altura, para que o usuário não precise saber a escolha exata dos parâmetros.

Nota: Para minimizar a perda de precisão durante a transformação de escala, às vezes é apropriado implementar uma segunda classe Rect que usa coordenadas de ponto flutuante, para que os resultados intermediários possam ser armazenados com precisão em uma sequência de transformações e arredondados apenas para número inteiro no último passo.

Como @Steven diz, acho que deveria ser em termos de um (x, y) ponto e um vetor de tamanho (w, h). Isso ocorre porque é fácil cair em uma ambiguidade. Suponha que você tenha o seguinte retângulo preenchido começando no ponto (0,0).

  012
0 XXX
1 XXX
2 XXX

Claramente é a largura, a altura é (3,3), mas qual é o segundo ponto? É (2,2) ou (3,3)?

Essa ambiguidade pode causar todos os tipos de problemas.

Eu aprendi a maneira duros anos atrás que é melhor pensar de coordenadas gráficas como as linhas entre os pixels, não como as linhas de pixels são on . Dessa forma, não há ambiguidade.

Pa(x,y)*-----------------------------------*Pb(x,y)
       |                                   |
       |                                   |
       |                                   |
       |                                   |
       |                                   |
       |                                   |
Pc(x,y)*-----------------------------------*Pd(x,y)

Podemos definir ambos Pb & Pc assim:

Pb (Pd (x), Pa (y))

e

Pc (Pa (x), Pd (y))

Portanto, não há necessidade de definir todos os quatro pontos devido à simetria