Какова идея определения прямоугольников с двумя точками? [закрыто]

Не то, чтобы это не имело смысла, но это работает неловко в 99% случаев.

Часто в 2D-графике прямоугольники инициализируются, сохраняются и управляются как пара точек. Ни на каком конкретном языке,

class Rect:
   p1, p2: point

Имеет смысл определить прямоугольник как два значения x и два значения y, например:

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

С двумя точками, если в каком-то месте исходного кода вы хотите использовать значение y верхней части, вы должны будете сказать rect.p1.y (хммм, остановитесь и подумайте, это p1 или p2), но с четырьмя значениями в качестве простых элементов данных это ясно и понятно: rect.ytop (не нужно думать!) Использование двух точек означает, что при работе с вертикалью вам необходимо запутать горизонталь; есть посторонняя связь между независимыми элементами.

Как возникла эта двухточечная идея и почему она сохраняется? Есть ли у него преимущество над голыми координатами x и y?

ДОБАВЛЕННОЕ ПРИМЕЧАНИЕ: Этот вопрос относится к прямоугольникам, выровненным по XY, таким как диспетчеры окон и наборы инструментов GUI, а не к контексту произвольных фигур в приложении для рисования и рисования.

Считаете ли вы, что он менее подвержен ошибкам?

Если вы используете (Point1, Point2), тогда очень ясно, что вы указываете. Если вы укажете 2 балла, единственно возможная ошибка заключается в том, что пользователь смешал свои x и y при построении точек, поскольку порядок точек не имеет значения.

Если вы предоставите 4 целых числа, то, если кто-то не обращает на это внимания, он может предоставить (x1, x2, y1, y2), когда вы захотите (x1, y1, x2, y2) или наоборот. Кроме того, некоторые API, такие как структура Rect WCF, определяют прямоугольник как (x, y, width, height), что может привести к путанице в отношении значения (1, 2, 3, 4). Это (x, y, w, h) или (x1, y1, x2, y2) или (x1, x2, y1, y2)?

В общем, (Point1, Point2) кажется мне немного безопаснее.

Мне всегда нравилось определять прямоугольник как точку + ширина и высота, где точка - это верхний левый угол прямоугольника.

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

А затем добавьте любые методы, которые вам нужны, чтобы получить другие метрики. Как версия Java

На самом деле, прямоугольник не определяется двумя точками. Прямоугольник может быть определен только двумя точками, если он параллелен осям.

Существует несколько способов представления прямоугольников, параллельных осям:

1. Две диагонально противоположные точки
2. Одна угловая точка, высота и ширина
3. Центральная точка, половина высоты и ширины (необычно, но иногда полезно).
4. Как две координаты X и две координаты Y

Для (1) многие библиотеки используют соглашение, чтобы определить, какие две точки используются - например, topLeft и bottomRight.

Выбор представления может быть обусловлен первоначальной целью определения прямоугольника, но я предполагаю, что оно часто произвольно . Представления эквивалентны в информации, которую они несут. Однако они отличаются простотой, с которой можно вычислять свойства прямоугольника, и удобством выполнения операций с прямоугольником.

Преимущества определения (1) перед другими включают:

• Согласованность API с другими полигонами, линиями и т. Д.
• topLeft, bottomRight может быть передан любому методу, который принимает точки
• Методы класса Point могут быть вызваны на topLeft, bottomRight
• Большинство свойств могут быть получены легко, например. bottomLeft, topRight, ширина, высота, центр, длина диагонали и т. д.

Ну, p1: Pointи в любом случае у p2: Pointкаждой будет две intкоординаты , так разве ваш класс не означает одно и то же?

И если вы храните эти две точки как первоклассные Pointобъекты, разве вы не получите от них немного больше полезности? В большинстве известных мне графических систем координат точки подклассируются таким образом, чтобы создать иерархию объектов: point -> circle -> ellipseи так далее.

Поэтому, если вы создаете объект, который не использует Pointкласс, вы отделите этот объект от остальной части иерархии классов.

Вот почему я люблю Delphi TRect. Он определяется как вариантная запись (структура объединения на языке C), которую можно интерпретировать как точку TopLeft и BottomRight или целые числа Top, Left, Bottom и Right, в зависимости от того, что более удобно в данный момент.

Конечно, если вы определите свой прямоугольник как:

class Rect
{
    Point bottomLeft;
    Point topRight;
}

тогда вы сразу знаете, какая точка есть какая.

Еще лучше было бы добавить дополнительные свойства, которые позволяли бы вам манипулировать прямоугольником любыми способами, необходимыми для вашего приложения. Это просто обновит базовую структуру данных.

Добавив преобразование в форму, вы можете сориентировать свой прямоугольник так, как вам нравится. Вам все еще понадобится ограничивающий прямоугольник с выравниванием по оси для быстрого принятия / отклонения проверок :)

Однако, если ваша модель допускает прямоугольники в любой ориентации без применения преобразования, тогда значения «нижний левый» и «верхний правый» не имеют значения, что приводит к «p1» и «p2» (или к чему-то эквивалентному).

я думаю, что имеет больше смысла для прямоугольника, который будет представлен экстентами x и y и точкой; Вы могли бы даже сделать точку расположения центром прямоугольника, чтобы она не зависела от вращения

но, вероятно, было проще всего кодировать его как две точки!

Мне это не нравится, потому что мы выбросили потенциальную степень свободы, которая, по сути, допускает произвольное вращение. Общий 2D-прямоугольник имеет пять неизвестных (степеней свободы). Мы могли бы указать их как координаты точки, длины двух сторон, которые образуют вершину с этой точкой, и угол от горизонтали первой линии (предполагается, что другая сторона имеет угол на 90 градусов больше). Можно также использовать бесконечное количество других возможностей, но есть пять независимых величин, которые должны быть указаны. Некоторые выборы приведут к более легкой алгебре, чем другие, в зависимости от того, что с ними сделано.

Разве это не то же самое, что 2 балла? Как это неловко ... большинству подпрограмм рисования нужны точки, а не отдельные компоненты x / y.

Определение прямоугольников как пар точек позволяет повторно использовать точку в качестве вершины для другой фигуры. Просто мысль...

Я считаю, что это главным образом для установления единообразия между всеми примитивами формы.

Конечно, вы можете определить прямоугольник многими различными способами, но как вы определяете треугольник, или звезду, или круг таким образом, чтобы можно было использовать похожие структуры данных?

Все полигоны могут быть определены их точками, с небольшим количеством логики, чтобы определить, что делать с точками.

Графические библиотеки в первую очередь оперируют этими полигонами в терминах вершин и ребер, поэтому точки и линии между ними, все вычисления работают с этими двумя признаками, хорошо это и грани, но это само по себе является просто функцией ребер.

В двух измерениях сохранение прямоугольника в виде двух точек более понятно, чем определение конкретного угла и ширины и высоты - учитывайте отрицательную ширину или высоту или расчеты, необходимые для определения каждого параметра из другого.

Выполнение поворотов в прямоугольнике, заданном точками, также намного проще, чем в определенном случае с точкой, шириной и высотой.

Я ожидаю, что инкапсуляция сделает эту дифференциацию неважной как пользователь класса.

Прямоугольник должен быть определен как три точки, которые должны быть четко определены в трех измерениях. Я не совсем уверен в требовании определения прямоугольника в 4 или более измерениях.

Это совершенно произвольно. Вам нужно четыре части информации, чтобы нарисовать прямоугольник. Разработчики библиотеки решили представить его двумя точками (каждая с координатой xy), но легко могли сделать это с помощью x / y / w / h или top / bottom / left / right.

Я полагаю, что настоящий вопрос ОП заключается в следующем: почему был сделан именно этот выбор?

Выбор параметров важен только для разработчиков / программистов низкого уровня.

Пользователям высокого уровня нужно думать только о:

• IsPointInRect
• Площадь
• Пересечение (или отсечение)
• HasOverlap (такой же, как Intersection.Area> 0)
• Союз (становится списком прямоугольников)
• Вычитание (список прямоугольников, представляющих тот же набор точек, который находится в прямоугольнике A, но не в прямоугольнике B)
• преобразование
  • Сдвиги в X и Y
  • Вращение (0, 90, 180, 270)
  • Масштабирование по X и Y (см. Примечание)
• Простой синтаксис для свойств Xmin, Xmax, Ymin, Ymax, Width, Height, так что пользователю не нужно знать точный выбор параметров.

Примечание. Чтобы минимизировать потерю точности при масштабном преобразовании, иногда целесообразно реализовать второй класс Rect, который использует координаты с плавающей запятой, чтобы промежуточные результаты могли быть точно сохранены в последовательности преобразований и округлены до целых чисел в последний шаг.

Как говорит @Steven, я думаю, что это должно быть с точки зрения одной (x, y) точки и вектора размера (w, h). Это потому, что легко попасть в неоднозначность. Предположим, у вас есть следующий заполненный прямоугольник, начиная с точки (0,0).

  012
0 XXX
1 XXX
2 XXX

Ясно, что это ширина, высота (3,3), но какова его вторая точка? Это (2,2) или (3,3)?

Эта двусмысленность может вызвать все виды проблем.

Я узнал с трудом лет назад , что лучше думать о графических координатах , как линии между пикселями, а не как линии пикселей на . Таким образом, нет никакой двусмысленности.

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

Мы можем определить Pb и Pc следующим образом:

Pb (Pd (х), Па (у))

и

Рс (Па (х), Pd (у))

Таким образом, нет необходимости определять все четыре точки из-за симметрии