Отметим, что маштабирование производится относительно начала координат.

Масштабирование относительно других точек рассмотрим ниже.

Если S_x!= S_y неоднородное масштабирование.

Если S_x = S_y однородное масштабирование.

Уравнение масштабирования

|S_x 0 0 | [x'y'1]=[x,y,1]|0 S_y 0 | |0 0 1 |

или P' = P ^. S(S_x,S_y)

Последовательные масштабирования приводят к матрице

|S_x1S_x2 0 0 | | 0 S_y1S_y2 0 | | 0 0 1 |

Масштабирование

S(Sx,Sy,Sz)

=

| Sx       | |   Sy     | |     Sz   | |         |

 

Свойства матрицы масштабирования.

Умножение слева элементарной матрицы масштабирования на прямоугольную матрицу A приводит к умножению соответствующей строки матрицы A на число λ.

Умножение справа элементарной матрицы масштабирования на прямоугольную матрицу A приводит к умножению соответствующего столбца матрицы A на число λ.

 

Матрица поворота.

Поворот

Объект может быть повернут, ели координаты каждой его точки будут подвергнуты преобразованию

x' = х ^. cosθ-y ^. sinθ
у' = х ^. sinθ-y ^. cosθ

В матричной форме

[x' у']=[x у]

| cosθ sinθ | | -sinθ cosθ |

или Р ' = Р ^. R

Положительным считаются углы, измеряемые против движения часовой стрелки от X к Y.

В случае отрицательных углов можно воспользоваться тождествами

cos(-θ)= cos(θ)
sin(-θ)=-sin(θ)

Поворот производится относительно начала координат

Однородные координаты

Преобразования переноса, масштабирования и поворота в матричной форме записываются как

P' = P + T
P' = P ^. S
P' = P ^. R

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

Это можно сделать, представив точки в однородных координатах. Однородные координаты были введены в геометрии.

Точка Р(х,у) записывается как P(Wx,Wy,W) для любого масштабного множителя W не равного нулю. Переход от однородных к декартовым координатам x=X/W y=Y/W.

Уравнение поворота

| cosθ sinθ 0 | [x'y'1]=[x,y,1]|-sinθ cosθ 0 | | 0 0 1 |

или P' = P ^. R(θ)

 

Поворот плоскости и его матричное представление

Ниже речь пойдет о поворотах плоскости. С плоскостью все получается относительно несложно. Если мы делаем поворот относительно начала координат, то для задания вращения используется один угол (φ).

Прим. Принято считать направление вращения против часовой стрелки положительным. При этом удобно считать, что угол φ находится в интервале [–π; π].

Чтобы получить преобразование координат при повороте, возьмем произвольный вектор r, задающий некоторую точку. Его координаты:

При повороте на угол φ:

Т.о. при повороте на угол φ координаты x и y подвергаются преобразованию, написанному выше.

Прим. Здесь фактически была использована полярная система координат.

Матричное представление поворота плоскости

Написанное выше преобразование координат удобно представить в виде матрицы:

Прим. Умножение матриц производится по принципу строка на столбец. Поэтому количество столбцов (элементов в строке) в матрице слева должно совпадать с количеством строк (элементов в столбце) в матрице справа.

Какие преимущества дает матричное представление? Заметим, что если умножить две матрицы, задающие повороты на углы α и β, то получится матрица поворота на угол α + β. Это легко проверить, перемножив соответствующие матрицы и использовав формулы для косинуса и синуса суммы.

Программная реализация

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

Для начала нам понадобится инструментарий (framework) для работы с матрицами:

Matrix.cpp

#include <math.h>
#include <memory.h>
#include "matrix.h"
#include "geometry.h"

void SetRotationMatrix(double alpha, Matrix &matrix)
{
matrix[0] = cos(alpha);
matrix[1] = -sin(alpha);
matrix[2] = sin(alpha);
matrix[3] = cos(alpha);
}

 

void MultiplyMatrices(Matrix &dest, Matrix &left, Matrix &right)
{
double ldet = left[0] * left[3] - left[1] * left[2];
double rdet = right[0] * right[3] - right[1] * right[2];
Matrix _dest;
_dest[0] = left[0] * right[0] + left[1] * right[2];
_dest[1] = left[0] * right[1] + left[1] * right[3];
_dest[2] = left[2] * right[0] + left[3] * right[2];
_dest[3] = left[2] * right[1] + left[3] * right[3];
memcpy(dest, _dest, sizeof(Matrix));
}

void ApplyMatrixtoPoint(Matrix rot, _Point &point)
{
double _x, _y;
_x = point.x;
_y = point.y;
point.x = _x * rot[0] + _y * rot[1];
point.y = _x * rot[2] + _y * rot[3];
}

Matrix.h

#include "geometry.h"

 

typedef double Matrix[4];

 

void SetRotationMatrix(double alpha, Matrix &matrix);
void MultiplyMatrices(Matrix &dest, Matrix &left, Matrix &right);
void ApplyMatrixtoPoint(Matrix rot, _Point &point);

 

Прим. Следует обратить ваше внимание на функцию MultiplyMatrices. Во многих случаях в роли dest и left выступает одна и та же матрица. Поэтому, если сразу записывать в dest, то получится некорректно.

 

Появляется модуль geometry.h и тип ’’точка’’ (_Point):

 

#ifndef _POINT
struct _Point
{
double x, y;
};
#define _POINT
#endif

 

Достаточно существенно меняется модуль draw.cpp. Ниже он приведен целиком.

Draw.cpp

#include <windows.h>
#include "geometry.h"
#include "matrix.h"

 

int Width, Height;
Matrix current_rot;

 

const int MARGIN = 10;

 

void InitRotation()
{
SetRotationMatrix(0.0, current_rot);
}

void AddRotation(double alpha)
{
Matrix additional_rot;
SetRotationMatrix(alpha, additional_rot);
MultiplyMatrices(current_rot, current_rot, additional_rot);
}

void SetWindowSize(int _Width, int _Height)
{
Width = _Width;
Height = _Height;
}

_Point T(_Point point)
{
_Point TPoint;
TPoint.x = MARGIN + (1.0 / 2) * (point.x + 1) * (Width - 2 * MARGIN);
TPoint.y = MARGIN + (-1.0 / 2) * (point.y - 1) * (Height - 2 * MARGIN);
return TPoint;
}

void Draw(HDC hdc)
{
_Point triangle[3];
triangle[0].x = 0.0;
triangle[0].y = 0.5;
triangle[1].x = 0.5;
triangle[1].y = 0.0;
triangle[2].x = -0.5;
triangle[2].y = -0.5;
for (int i = 0; i < 3; i++)
{
ApplyMatrixtoPoint(current_rot, triangle[i]);
triangle[i] = T(triangle[i]);
}
for (int i = 0; i <= 3; i++)
{
int j = i % 3;
if (i == 0)
{
MoveToEx(hdc, triangle[j].x, triangle[j].y, NULL);
}
else
{
LineTo(hdc, triangle[j].x, triangle[j].y);
}
}
}

Draw.h

void Draw(HDC hdc);
void SetWindowSize(int _Width, int _Height);
void InitRotation();
void AddRotation(double alpha);

И наконец в модуле main.cpp добавляется обработчик WM_KEYPRESSED:

case WM_KEYDOWN:
int KeyPressed;
KeyPressed = int(wParam);
if (KeyPressed == VK_RIGHT)
{
AddRotation(-PI / 10);
}

if (KeyPressed == VK_LEFT)
{
AddRotation(PI / 10);
}
InvalidateRect(hWnd, NULL, FALSE);
break;

ИЛИ

Матрицей поворота (или матрицей направляющих косинусов) называется ортогональная матрица, которая используется для выполнения собственного ортогонального преобразования в евклидовом пространстве. При умножении матрицы поворота на вектор длина вектора сохраняется, при этом определитель матрицы поворота положителен (и равен 1).

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