Вопрос
Поиск хорошего способа сделать это поставил меня в тупик на некоторое время: предположим, у меня есть поле выбора с набором точек в нем. Перетаскивая углы, вы можете масштабировать (расстояние между) точками в поле. Теперь для поля с выравниванием по оси это легко. Возьмите угол в качестве точки привязки (вычесть этот угол от каждой точки, масштабировать его, а затем добавить его снова в точку) и умножить каждый точку х и у множителя, с которой коробка получила больше.
Но теперь возьмите прямоугольник, который не выровнен по осям x и y. Как вы масштабируете точки внутри этого поля, когда перетаскиваете его углы?
Решение
Вы выбираете один угол прямоугольника в качестве источника. Два связанных с ним ребра будут основой ( u
и v
, которые должны быть перпендикулярны друг другу). Сначала вам нужно их нормализовать.
Вычтите начало координат из координат и рассчитайте скалярное произведение с вектором масштабирования ( u
) и другим вектором ( v
). Это даст вам информацию о том, сколько u
и v
вносит вклад в координату.
Затем вы масштабируете нужный вам компонент. Чтобы получить окончательную координату, нужно просто умножить (теперь масштабированные) компоненты на соответствующий вектор и сложить их вместе.
Например:
Points: p1 = (3,5) and p2 = (6,4)
Selection corners: (0,2),(8,0),(9,4),(1,6)
selected origin = (8,0)
u = ((0,2)-(8,0))/|(0,2)-(8,0)| = <-0.970, 0.242>
v = <-0.242, -0.970>
( v
равно u
, но с перевернутыми координатами, и одна из них отрицается)
p1´ = p1 - origin = (-5, 5)
p2´ = p2 - origin = (-2, 4)
p1_u = p1´ . u = -0.970 * (-5) + 0.242 * 5 = 6.063
p1_v = p1´ . v = -0.242 * (-5) - 0.970 * 5 = -3.638
Scale p1_u by 0.5: 3.038
p1_u * u + p1_v * v + origin = <5.941, 4.265>
Same for p2: <7.412, 3.647>
Как вы, возможно, можете видеть, они переместились в сторону строки (8,0)
- (9,4)
, поскольку мы масштабировали на 0,5 с помощью (0,8)
в качестве источника.
Изменить . Оказалось, что объяснить это немного сложнее, чем я ожидал.
В коде Python это может выглядеть примерно так:
def scale(points, origin, u, scale):
# normalize
len_u = (u[0]**2 + u[1]**2) ** 0.5
u = (u[0]/len_u, u[1]/len_u)
# create v
v = (-u[1],u[0])
ret = []
for x,y in points:
# subtract origin
x, y = x - origin[0], y - origin[1]
# calculate dot product
pu = x * u[0] + y * u[1]
pv = x * v[0] + y * v[1]
# scale
pu = pu * scale
# transform back to normal space
x = pu * u[0] + pv * v[0] + origin[0]
y = pu * u[1] + pv * v[1] + origin[1]
ret.append((x,y))
return ret
>>> scale([(3,5),(6,4)],(8,0),(-8,2),0.5)
[(5.9411764705882355, 4.2647058823529411), (7.4117647058823533, 3.6470588235294117)]
Другие советы
Любое поле находится внутри круга.
Вы находите круг, который связывает прямоугольник, находите его центр и делаете то же самое, что и с прямоугольником, выровненным по оси.
Допустим, прямоугольник определен как набор из четырех точек (P1, P2, P3 и P4). Для простоты скажем, что вы перетаскиваете P1, а P3 - противоположный угол (тот, который вы используете в качестве якоря).
Давайте обозначим положение мыши как M, а новые точки, которые вы хотите вычислить, как N1, N2 и N4. P3, конечно, останется прежним.
Ваш коэффициент масштабирования может быть просто вычислен с использованием векторного вычитания и векторного точечного произведения:
scale = ((M - P3) dot (P1 - P3)) / ((P1 - P3) dot (P1 - P3))
И три новые точки можно найти с помощью скалярного умножения и сложения векторов:
N1 = scale*P1 + (1 - scale)*P3
N2 = scale*P2 + (1 - scale)*P3
N4 = scale*P4 + (1 - scale)*P3
edit: я вижу, что MizardX уже ответил на вопрос, поэтому мой ответ здесь, чтобы помочь с этим трудным объяснением. Надеюсь, это поможет!
edit: вот алгоритм непропорционального масштабирования. В этом случае N1 равно M (точка, перетаскиваемая за мышью), поэтому единственными интересными точками являются N2 и N4:
N2 = ((M - P3) dot (P2 - P3)) / ((P2 - P3) dot (P2 - P3)) * (P2 - P3) + P3
N4 = ((M - P3) dot (P4 - P3)) / ((P4 - P3) dot (P4 - P3)) * (P4 - P3) + P3
где * представляет скалярное умножение
edit: Вот код C ++, который отвечает на вопрос. Я уверен, что этот вопрос давно устарел, но это была интересная проблема, и мне было весело писать код.
#include <vector>
class Point
{
public:
float x;
float y;
Point() { x = y = 0; }
Point(float nx, float ny) { x = nx; y = ny; }
};
Point& operator-(Point& A, Point& B) { return Point(A.x-B.x, A.y-B.y); }
Point& operator+(Point& A, Point& B) { return Point(A.x+B.x, A.y+B.y); }
Point& operator*(float sc, Point& P) { return Point(sc*P.x, sc*P.y); }
float dot_product(Point A, Point B) { return A.x*B.x + A.y*B.y; }
struct Rect { Point point[4]; };
void scale_points(Rect box, int anchor, Point mouse, vector<Point> points)
{
Point& P3 = box.point[anchor];
Point& P2 = box.point[(anchor + 1)%4];
Point& P1 = box.point[(anchor + 2)%4];
Point& P4 = box.point[(anchor + 3)%4];
Point A = P4 - P3;
Point aFactor = dot_product(mouse - P3, A) / dot_product(A, A) * A;
Point B = P2 - P3;
Point bFactor = dot_product(mouse - P3, B) / dot_product(B, B) * B;
for (int i = 0; i < points.size(); i++)
{
Point P = points[i] - P3;
points[i] = P3 + dot_product(P, aFactor) + dot_product(P, bFactor);
}
}