Геометрические свойства нескольких изображений. Внутренняя калибровка камеры

05.04.2019

В компьютерной графике определенны понятия различных матриц. Это мировая матрица (World Matrix), матрица вида (View Matrix) и матрица проекции (Projection Matrix). С помощью данных матриц в исходном коде программы производятся матричные преобразования над моделями. Матричные преобразования подразумевают под собой умножение каждой вершины объекта на одну из матриц, а точнее последовательное умножение всех вершин объекта на каждую из трех матриц. Такой подход позволяет корректно представить модель в трехмерном пространстве вашего двухмерного монитора. Техника прохода модели через три перечисленные матрицы представляет суть механизма работы с графическими данными в трехмерной плоскости монитора.

Мировая матрица

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

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

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

Мировая матрица

где cos - угол вращения в радианах.

Вращение вершины вокруг оси Y выглядит так:

Вращение вершины вокруг оси Y

А вращение вокруг оси Z происходит по следующей формуле:

вращение вокруг оси Z

Трансляция вершины позволяет переместить эту саму вершину с координатами x, y, z в новую точку с новыми координатами x1, y1, z1. В математической записи это выглядит так:

X1 = x + Tx y1 = y + Ty z1 = z + Tz

Трансляция вершины в матричной записи выглядит следующим образом:

Трансляция вершины в матричной записи

где Tx, Ty и Tz - значения смещения по осям X, Y и Z.

Масштабировать вершину в пространстве (удалять или приближать) с координатами x, y, z в новую точку с новыми значениями x1, y1, z1, можно посредством следующей записи:

X1 = x * S y1 = y * S z1 = z * S

В матричной записи это выражается следующим образом:

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

где Sx, Sy, Sz - значения коэффициентов растяжения или сжатия по осям X, Y, Z.

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

Матрица вида

Матрица вида – задает местоположение камеры в пространстве и это вторая по счету матрица, на которую умножаются вершины объекта. Эта матрица способствует определению направления просмотра трехмерной сцены. Трехмерная сцена – это все то, что вы видите на экране монитора. Это как в театре, где вы сидите в портере или на галерке и наблюдаете за действиями на сцене. Так вот сидя в портере у вас будет одно местоположение камеры, а сидя на галерке уже совсем другое.

Фактически эта матрица позволяет определять жанр игры. Например, игра DOOM от первого лица – это можно сказать первые ряды портера в театре, тогда как игра Warcraft – это галерка на балконе. Матрица вида предназначена для определения положения камеры в пространстве, и вы можете смещать позицию камеры влево, вправо, вверх, вниз, удалять, приближать ее и так далее.

Матрица проекции

Матрица проекции – это более сложная матрица, которая создает проекцию трехмерного объекта на плоскость двумерного экрана монитора. С помощью этой матрицы определяются передняя и задняя области отсечения трехмерного пространства, что позволяет регулировать пространство отсечения невидимых на экране объектов, а заодно и снизить нагрузку процессора видеокарты. На рисунке изображен механизм проекции объекта в плоскости и отсечение пространства.

Матрица проекции

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

Табл.3.3.Матрицы проектирующих преобразований и проецирования

Ортографическая проекция на XOY		Ортографическая проекция на YOZ

Ортографическая проекция на XOZ		Ортографическая проекция на плоскость x=p

Матрица триметрического преобразования на плоскость XOY

Матрица изометрического преобразования на плоскость XOY

Матрица изометрического проецирования на плоскость XOY

Матрица косоугольной проекции на XOY	Матрица свободной проекции на XOY

Матрица кабинетной проекции на XOY	Матрица перспективного преобразования с одной точкой схода (картинная плоскость перпендикулярна оси абсцисс)

Матрица перспективного преобразования с одной точкой схода (картинная плоскость перпендикулярна оси ординат)		Матрица перспективного преобразования с одной точкой схода (картинная плоскость перпендикулярна оси аппликат)

Матрица перспективного преобразования с двумя точками схода (картинная плоскость параллельна оси ординат)		Матрица перспективного преобразования с тремя точками схода (картинная плоскость произвольного положения)

Изометрия, диметрия и триметрия получаются комбинацией поворотов, за которыми следует проекция из бесконечности. Если нужно описать проекцию на плоскость XOY, то сначала необходимо осуществить преобразование поворота на угол относительно оси ординат, затем на уголотносительно оси абсцисс. В табл.3.3 приведена матрица триметрического преобразования. Для получения матрицы диметрического преобразования, при котором, например, коэффициенты искажения по осям абсцисс и ординат будут равными, взаимосвязь между углами поворотов должна подчиняться зависимости

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

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

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

Перспективные проекции (табл.3.3) также представлены перспективными преобразованиями и перспективными проекциями на плоскость XOY. V X , V Y и V Z являются центрами проецирования - точками на соответствующих осях. –V X , -V Y , -V Z будут точками, в которых сходятся пучки прямых, параллельных соответствующим осям.

Система координат наблюдателя представляет собой левую систему координат (рис.3.3), в которой ось z e направлена из точки зрения вперед, ось x e направлена вправо, а ось y e – вверх. Такое правило принято для совпадения осей x e и y e с осями x s и y s на экране. Определение значений координат экрана x s и y s для точки Р приводит к необходимости деления на координату z e . Для построения точного перспективного образа необходимо выполнять деление на координату глубины каждой точки.

В табл.3.4 приведены значения дескриптора вершин S(X,Y,Z) модели (рис.2.1), подвергнутой преобразованиям поворотов и изометрическому преобразованию.

Табл.3.4.Дескрипторы вершин модели

Исходная модель				M(R(z,90))xM(R(y,90))

Двигатель не двигает корабль.
Корабль остается на месте, а
двигатели двигают вселенную
вокруг него.

Футурама

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

Гомогенные координаты

В предыдущих уроках мы предполагали, что вершина расположена по координатам (x, y, z). Давайте-ка добавим еще одну координату – w. Отныне вершины у нас будут по координатам (x, y, z, w)

Вскоре вы поймете, что к чему, но пока примите это как данность:

Если w==1, тогда вектор (x,y,z,1) – это позиция в пространстве
Если w==0, тогда вектор (x,y,z,0) – это направление.

Запомните это как аксиому без доказательств!!!

И что это нам дает? Ну, для вращения ничего. Если вы вращаете точку или направление, то получите один и тот же результат. Но если вы вращаете перемещение(когда вы двигаете точку в определенном направлении), то все кардинально меняется. А что значит «переместить направление»? Ничего особенного.

Гомогенные координаты позволяют нам оперировать единым матаппаратом для обоих случаев.

Матрицы Трансформаций

Введение в матрицы

Если по простому, то матрица, это просто массив чисел с фиксированным количеством строк и столбцов.

Например, матрица 2 на 3 будет выглядеть так:

В 3д графике мы пользуемся почти всегда матрицами 4х4. Это позволяет нам трансформировать наши (x,y,z,w) вершины. Это очень просто – мы умножаем вектор позиции на матрицу трансформации.

Матрица*Вершину = трансформированная вершина

Все не так страшно как выглядит. Укажите пальцем левой руки на a, а пальцем правой руки на x. Это будет ax. Переместите левый палец на следующее число b, а правый палец вниз на следующее число – y. У нас получилось by. Еще раз – cz. И еще раз – dw. Теперь суммируем все получившиеся числа – ax+by +cz +dw . Мы получили наш новый x. Повторите то же самое для каждой строки и вы получите новый вектор (x,y,z,w).

Однако это довольно скучная операция, так что пусть её за нас будет выполнять компьютер.

В С++ при помощи библиотеки GLM:

glm::mat4 myMatrix;

glm::vec4 myVector;

glm :: vec 4 transformedVector = myMatrix * myVector ; // Не забываем про порядок!!! Это архиважно!!!

В GLSL:

mat4 myMatrix;

vec4 myVector;

// заполняем матрицу и вектор нашими значениями… это мы пропускаем

vec 4 transformedVector = myMatrix * myVector ; // точно так же как и в GLM

(Чего-то мне кажется, что вы не скопировали этот кусок кода к себе в проект и не попробовали…ну же, попробуйте, это интересно!)

Матрица перемещений

Матрица перемещения, это, наверное, самая простая матрица из всех. Вот она:

Тут X, Y, Z – это значения, которые мы хотим добавить к нашей позиции вершины.

Итак, если нам нужно переместить вектор (10,10,10,1) на 10 пунктов, по позиции Х, то:
(Попробуйте это сами, ну пожаааалуйста!)

…И у нас получится (20,10,10,1) в гомогенном векторе. Как вы, я надеюсь, помните, 1 значит, что вектор представляет собой позицию, а не направление.

А теперь давайте попробуем таким же образом трансформировать направление (0,0,-1,0):

И в итоге у нас получился тот же вектор (0,0,-1,0).
Как я и говорил, двигать направление не имеет смысла.

Как же нам закодить это?

В С++ при помощи GLM:

#include // после

glm::mat4 myMatrix = glm::translate(10.0f, 0.0f, 0.0f );

glm::vec4 myVector(10.0f, 10.0f, 10.0f, 0.0f );

glm :: vec 4 transformedVector = myMatrix * myVector ; // и какой у нас получится результат?

А в GLSL: В GLSL так редко кто делает. Чаще всего с помощью функции glm::translate(). Сначала создают матрицу в С++, а затем отправляют её в GLSL, и уже там делают лишь одно умножение:

vec4 transformedVector = myMatrix * myVector;

Единичная матрица(Identity Matrix)

Это специальная матрица. Она не делает ничего. Но я упоминаю её, так как важно знать, что умножение A на 1.0 в результате дает А:

glm::mat4 myIdentityMatrix = glm::mat4(1.0f);

Матрица Масштабирования

Матрица масштабирования так же достаточно проста:

Поэтому если вам хочется увеличить вектор(позицию или направление, не важно) в два раза по всем направлениям:

А координата w не поменялась. Если вы спросите: «А что такое масштабирование направления?». Полезно не часто, но иногда полезно.

(заметьте, что масштабирование единичной матрицы с (x,y,z) = (1,1,1))

С++:

// Используйте #include и #include

glm::mat4 myScalingMatrix = glm::scale(2.0f, 2.0f ,2.0f);

Матрица Вращения

А вот эта матрица достаточно сложная. Поэтому я не буду останавливаться на подробностях её внутренней реализации. Если сильно хочется, лучше почитайте (Matrices and Quaternions FAQ)

В С ++:

// Используйте #include и #include

glm::vec3 myRotationAxis(??, ??, ??);

glm::rotate(angle_in_degrees, myRotationAxis);

Совмещенные Трансформации

Теперь мы знаем как вращать, перемещать и масштабировать наши вектора. Хорошо бы узнать, как объединить все это. Это делается просто умножением матриц друг на друга.

TransformedVector = TranslationMatrix * RotationMatrix * ScaleMatrix * OriginalVector;

И снова порядок!!! Сначала нужно изменить размер, потом прокрутить и лишь потом сдвинуть.

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

Сделайте шаг вперед(не свалите компьютер со стола) и повернитесь влево
Повернитесь влево и сделайте один шаг вперед.

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

Не правильный способ:

Перемещаем корабль на (10,0,0). Его центр теперь на 10 по Х от центра.
Увеличиваем размер нашего корабля в 2 раза. Каждая координата умножается на 2 относительно центра который далеко… И в итоге у нас получается корабль необходимого размера но по позиции 2*10=20. Что не совсем то, чего мы хотели.

Правильный способ:

Увеличиваем размер корабля в 2 раза. Теперь у нас есть большой корабль расположенный по центру.
Перемещаем корабль. Размер корабля не изменился и он расположен в нужном месте.

Умножение матрицы на матрицу выполняется почти так же, как и умножение матрицы на вектор. Не будем вдаваться в подробности, а любопытствующие пусть почитают это из специализированных источников. Мы же просто будем полагаться на библиотеку GLM.
ВС++:
glm::mat4 myModelMatrix = myTranslationMatrix * myRotationMatrix * myScaleMatrix;
glm::vec4 myTransformedVector = myModelMatrix * myOriginalVector;
В GLSL:
mat4 transform = mat2 * mat1;
vec4 out_vec = transform * in_vec;

Матрицы Модели, Вида и Проекции

Для иллюстраций предполагаем, что мы уже умеем рисовать в OpenGL любимую 3д модель программы Blender – голову обезьяны Сюзанны.

Матрицы Модели, Вида и Проекции очень удобный метод разделения трансформаций. Если сильно хочется, вы можете не использовать их(мы же не использовали их в уроках 1 и 2). Но я настойчиво рекомендую вам пользоваться ими. Просто почти все 3д библиотеки, игры итд используют их для разделения трансформаций.

Матрица Модели

Данная модель, как и наш любимый треугольничек, задана набором вершин. X, Y, Z координаты заданы относительно центра объекта. Так вот, если вершина расположена по координатам (0,0,0), то она находится в центре всего объекта

Теперь мы имеем возможность двигать нашу модель. Например, потому, что пользователь управляет ей с помощью клавиатуры и мыши. Это сделать очень просто: масштабирование*вращение*перемещение и все. Вы применяете вашу матрицу ко всем вершинам в каждом кадре(в GLSL а не в C++) и все перемещается. Все что не перемещается – расположено в центре «мира».

Вершины находятся в мировом пространстве Черная стрелка на рисунке показывает, как мы переходим из пространства модели, в мировое пространство(Все вершины были заданы относительно центра модели, а стали заданы относительно центра мира)

Эту трансформацию можно отобразить следующей диаграммой:

Матрица Вида

Давайте еще раз прочитаем цитату из футурамы:

«Двигатель не двигает корабль. Корабль остается на месте, а двигатели двигают вселенную вокруг него.»

То же самое можно применить и к фотоаппарату. Если вы хотите сфотографировать гору под каким-нибудь углом, то можно передвинуть фотокамеру…или гору. В реальной жизни это невозможно, но очень легко и удобно в компьютерной графике.

По умолчанию наша камера находится в центре Мировых Координат. Чтобы двигать наш мир нужно создать новую матрицу. К примеру нам нужно переместить нашу камеру на 3 единицы вправо(+Х). Это то же самое, что переместить весь мир на 3 единицы влево(-Х). И пока ваши мозги плавятся, давайте попробуем:

// Используйте #include и #include

glm::mat4 ViewMatrix = glm::translate(-3.0f, 0.0f ,0.0f);

Картинка ниже демонстрирует это: мы переходим от Мирового пространства(все вершины заданы относительно центра мира как мы это делали в предыдущей секции) к пространству камеры(все вершины заданы относительно камеры).

И прежде чем ваша голова совсем взорвется, посмотрите на прекрасную функцию из нашей старой доброй GLM:

glm::mat4 CameraMatrix = glm::LookAt(

cameraPosition , // Позиция камеры в мировых координатах

cameraTarget , // точка на которую мы хотим посмотреть в мировых координатах

upVector // скорее всего glm :: vec 3(0,1,0), а (0,-1,0) будет все показывать вверх ногами, что иногда тоже прикольно.

Вот иллюстрация к вышесказанному:

Но к нашей радости, это еще не все.

Матрица Проекции

Сейчас мы имеем координаты в пространстве камеры. Это значит, что после всех этих трансформаций, вершина которой посчастливилось оказаться в x==0 и y==0 будет отрендерена в центре экрана. Но мы же не можем пользоваться лишь координатами X,Y, чтобы понять куда рисовать вершину: дистанция к камере(Z) должна тоже учитываться! Если у нас есть две вершины, то одна из них будет более ближе к центру экрана чем другая, так как у неё больше координата Z.

Это называется перспективная проекция:

И к большому счастью для нас, матрица 4х4 может представлять собой и перспективные трансформации:

glm::mat4 projectionMatrix = glm::perspective(

FoV , // Горизонтальное Поле Вида в градусах. Или величина приближения . Как будто « линза » на камере . Обычно между 90(суперширокий, как рыбий глаз) и 30(как небольшая подзорная труба)

4.0 f / 3.0 f , // Соотношение сторон. Зависит от размера вашего окна. Например, 4/3 == 800/600 == 1280/960, знакомо, не правда ли?

0.1 f , // Ближнее поле отсечения. Его нужно задавать как можно большим, иначе будут проблемы с точностью.

100.0 f // Дальнее поле отсечения. Нужно держать как можно меньшим.

);

Повторим то что мы сейчас сделали:

Мы ушли от пространства камеры(все вершины заданы в координатах относительно камеры) в гомогенное пространство(все вершины в координатах маленького куба(-1,1). Все что находится в кубе – находится на экране.)

И финальная диаграмма:

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

После умножения на проекционную матрицу у нас выходит следующее:

На предыдущей картинке поле вида превратилось в идеальный куб(с координатами вершин от -1 до 1 по всем осям.), а все объекты деформированы в перспективе. Все голубые объекты которые близко к камере – стали большими, а которые дальше – маленькими. Так же как и в жизни!

Вот какой вид у нас открывается из «объектива»:

Однако оно квадратное, и нужно применить еще одно математическое преобразование, чтобы подогнать картинку под размеры окна.

Для того, чтобы вращать объекты (или камеру), необходима серьезная математическая база, с помощью которой будут расчитываться координаты всех объектов при выводе на "плоский" экран компьютера. Сразу хочу сказать, что не стоит пугаться, все математические библиотеки уже написаны за нас, мы будем их только использовать. В любом случае, следующий текст пропускать не нужно, независимо от уровня знаний математики.

1. Матрицы, общие понятия

Что такое матрицы? Вспоминаем высшую математику: матрица ¬- это набор чисел с заранее известной размерностью строк и столбцов.

Матрицы можно складывать, умножать на число, перемножать друг с другом и много еще чего интересного, но этот момент мы пропустим, т.к. он достаточно подробно изложен в любом учебнике по высшей математике (учебники можно поискать на google.com). Мы будем пользоваться матрицами как программисты, мы их заполняем и говорим, что с ними делать, все расчеты произведет математическая библиотека Direct3D, поэтому нужно включить в проект заголовочный модуль d3dx9.h (и библиотеку d3dx9.lib).

Наша задача - создать объект, т.е. заполнить матрицу координатами вершин объекта. Каждая вершина - это вектор (X, Y, Z) в трехмерном пространстве. Теперь, чтобы произвести какое-то действие, нужно взять наш объект (то есть матрицу) и умножить на матрицу преобразования, результат этой операции - новый объект, заданный в виде матрицы.

В Direct3D определены и используются три основные матрицы: мировая матрица, матрица вида и матрица проекции. Рассмотрим их подробнее.

Мировая матрица (World Matrix) - позволяет производить вращение, трансформацию и масштабирование объекта, а также наделяет каждый из объектов своей локальной системой координат.

Функции для работы с мировой матрицей:

D3DXMatrixRotationX(), D3DXMatrixRotationY(), D3DXMatrixRotationZ() - вращение точки относительно одной из осей;

D3DXMatrixTranslation() - перемещение точки в другое положение;

D3DXMatrixScale() - масштабирование.

Матрица вида (View Matrix) - определяет местоположение камеры просмотра сцены и может состоять из любых комбинаций трансляции и вращения.
D3DXMatrixLookAtLH()и D3DXMatrixLookAtRH() определяет положение камеры и угла просмотра для левостороней и правостороней систем координат соответственно.

Матрица проекции (Projection Matrix) - создает проекцию 3D сцены на экран монитора. С ее помощью объект трансформируется, начало координат переносится в переднюю часть, а также определяется передняя и задняя плоскости отсечения.

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

2. Создание объекта

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

Окно Windows (инициализация окна, сообщения, …)
Инициализация 3D (загрузка координат объектов, удаление ресурсов, …)
Рендер сцены (матрицы, рисование примитивов, …)

В результате у нас будет 3 файла - window.cpp, init3d.h, render.h с таким содержанием: init3d.h - переносим глобальный переменные и структуры, объявление функций, функции InitDirectX(), InitBufferVertex(), Destroy3D() render.h - переносим функцию RenderScene() все, что осталось, касается главного окна, это будет файл - window.cpp .

Добавляем заголовочный файл и библиотеку для использования матричных функций

#include // или C:\DXSDK\Include\d3dx9.h #pragma comment(lib, "d3dx9.lib") //или C:\\DXSDK\\Lib\\d3dx9.lib

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

#include

Изменим формат представления вершин:

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ/D3DFVF_DIFFUSE) struct CUSTOMVERTEX { FLOAT x, y, z; DWORD color; };

Будем использовать не преобразованный тип вершин, т.к. преобразования будем делать матрицами.
Изменяем код функции InitDirectX(). В эту функцию необходимо добавить установку двух режимов отображения.
Отключаем режим отсечения для того, чтобы при вращении можно было видеть все стороны объекта:

PDirectDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

На данный момент мы не пользуемся освещением, а закрашиваем вершины в определенный цвет, поэтому отключаем освещение:

PDirectDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

Упростим наше сердце, представив его в виде трех треугольников. Будем использовать локальную систему координат.

CUSTOMVERTEX stVertex= { { -1.0f, 0.5f, 0.0f, 0x00ff0000 }, { -0.5f, 1.0f, 0.0f, 0x00ff0000 }, { 0.0f, 0.5f, 0.0f, 0x00ff0000 }, { 0.0f, 0.5f, 0.0f, 0x000000ff }, { 0.5f, 1.0f, 0.0f, 0x000000ff }, { 1.0f, 0.5f, 0.0f, 0x000000ff }, { -1.0f, 0.5f, 0.0f, 0x0000ff00 }, { 1.0f, 0.5f, 0.0f, 0x0000ff00 }, { 0.0f, -1.0f, 0.0f, 0x0000ff00 }, };

3. Создание матриц преобразования

Напишем в файле render.h функцию SetupMatrix() в которой будут происходить все действия над матрицами.

Создадим матрицы:

D3DXMATRIX MatrixWorld; - мировая матрица

D3DXMATRIX MatrixView; - матрица вида

D3DXMATRIX MatrixProjection; - матрица проекции
Установка мировой матрицы

Для того, чтобы объект вращался, необходимо получить системное время и каждое "мгновение" изменять угол между локальной системой координат и мировой ситемой координат. Вращать будем относительно оси Х, поэтому используем функцию D3DXMatrixRotationX. После расчета мировой матрицы необходимо применить ее значения с помощью функции SetTransform:

UINT iTime=timeGetTime()%5000; FLOAT fAngle=iTime*(2.0f*D3DX_PI)/5000.0f; D3DXMatrixRotationX(&MatrixWorld, fAngle); pDirectDevice->SetTransform(D3DTS_WORLD, &MatrixWorld); Установка матрицы вида

Устанавливаем камеру в нужном месте и направляем ее на объект

D3DXMatrixLookAtLH(&MatrixView, - результат выполнения функции

&D3DXVECTOR3(0.0f, 0.0f, -8.0f), - точка, в которой находится камера

&D3DXVECTOR3(0.0f, 0.0f, 0.0f), - точка, в которую мы смотрим

&D3DXVECTOR3(0.0f, 1.0f, 0.0f)); - верх объекта

После расчета необходимо применить полученные значения.

Графический вывод обычно осущестсвляется в некоторую прямоугольную область экрана или окна. В OpenGL-визуализации эта область называется порт вывода. Именно в этой прямоугольной области будет размещено библиотекой сформированное изображение. Его размеры определяются относительно левого верхнего угла окна и измеряются в пикселах. Для определения порта вывода приложение должно отследить событие изменения размеров окна и определить порт вывода с использованием функции:

void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);

Аргументы (x, y) определяют положение верхнего левого угла порта вывола, а width и height -- его размеры. По умолчанию библиотека растягивает порт вывода на всё OpenGL-окно.

Координатная система

Прежде чем быть отображённой на экране вершина, заданная в системе координат сцены должна пройти процесс проецирования. Для описания и проведения преобразований систем координат в библиотеке OpenGL используется матричный аппарат. Сама система координат и ее преобразования описываются матрицами в так называемых однородных координатах.

Во-первых, вершина преобразуется в матрицу 1X4, в которой первые три элемента представляют собой координаты x, y, z. Четвёртое число - масштабный коэффициент w, который обычно равен 1.0. Вершина домножается на видовую матрицу, которая описывает преобразования видовой системы координат. Получаем вершину в координатах вида. Она в свою очередь домножается на матрицу проекций и получаем вершину в координатах проекции. На этом этапе некоторве вершины отбрасываются (из-за непопадания в объём визуализации). Затем вершины нормализуются для передачи перспективы (если координата w не равна 1.0). Окончательное проецирование вершины на двумерную поверхность экрана выполняется библиотекой OpenGL самостоятельно и вмешаться в этот процесс нельзя.

Матрица проекций

Матрица проекций отвечает за то, какой объём пространства будет визуализироваться, каким образом вершины графических примитивов будут спроецированы на двумерную поверхность экрана монитора. Преобразования матрицы проекций ведут к тому, что все изображение будет изменяться (масштабироваться, перемещаться или вращаться). В OpenGL возможно использование двух режимов матрицы проекций: перспективная и ортографическая.

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

Матрица преспективной проекции определяется с использованием функции:

void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

(left, bottom, -near) и (right, top, -near) определяют координаты ближней отсекающей рамки; near и far имеют всегда положительные значения и определяют расстояние от точки зрения до ближней и дальней отсекающих рамок.

Для задания матрицы перспективной проекции также можно использовать функцию gluPerspective(), которая имеет другие аргументы

void gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble near, GLdouble far);

Аргумент fovy (field of view) определяет поле зрения, а aspect -- отношение ширины отсекающей рамки к высоте. near и far имеют всегда положительные значения и определяют расстояние от точки зрения до ближней и дальней отсекающих рамок.

Перспективное проецирование обычно используется в играх и приложениях, где требуется добиться высокой реалистичности объектов, подожей на визуализацию глазом. Для двумерной и трехмерной визуализации научных и технических данных обычно используется ортографическая проекция. Рассмотрим установку ортографической проекции сначала для двумерной визуализации. При ортографической проекции объём пространства, который визуализируется представляет собой параллелепипед:

Особенностями ортографической проекции является то, что расстояние от камеры до объектов не влияет на итоговое изображение.

Для установки и последующего изменения матрицы проекций следует выполнить функцию glMatrixMode(GL_PROJECTION). Для начала также следует отменить все предыдущие установки и преобразования, сделав матрицу проекций единичной с помошью функции glLoadIdentity(). Матрица ортографической проекции устанавливается с использованием функции, которая имеет следующий прототип:

void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);

(left, bottom, -near) и (right, top, -near) -- точки, определяющие ближнюю отсекающую рамку. (left, bottom, -far) и (right, top, -far) -- точки, определяющие дальнюю отсекающую рамку. После применения этой команды направление проецирования параллельно оси z в сторону отрицательных значений

//Функция изменения размеров и установки координат
void Reshape(int width, int height)
{
//Установка порта вывода
glViewport(0, 0, width, height);

//Режим матрицы проекций
glMatrixMode(GL_PROJECTION);
//Единичная матрица
glLoadIdentity();

//Установка двумерной ортографической системы координат
glOrtho(-50., 50., -50., 50., -1., 1.);

//Режим видовой матрицы
glMatrixMode(GL_MODELVIEW);
}

Специально для двумерной визуализации можно использовать функцию, которая имеет следующий прототип:

void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);

Эта функция аналогична glOrtho(), при вызове которой аргумент near=-1.0, а far=1.0. В процессе двумерной визуализации z-координата у вершин имеет значение 0, то есть объекты находятся на средней плоскости.

При необходимости сохранения пропорций установку системы координат необходимо осуществлять с учетом отношения ширины и высоты окна.

//Установка ортографической системы координат
double aspect=width/double(height);
if(width>=height)
{
gluOrtho2D(-50.*aspect, 50.*aspect, -50., 50.);
}
else
{
gluOrtho2D(-50., 50., -50./aspect, 50./aspect);
}

Видовая матрица

Видовая матрица отвечает за систему координат создаваемой трехмерной модели. В процессе создания модели видовая матрица может многократно изменяться для того, чтобы видоизменить изображение отдельных графических примитивов (превратить квадрат в прямоугольник, куб в параллелепипед, сферу в эллипсоид). Для установки и последующего изменения видовой матрицы следует выполнить функцию glMatrixMode(GL_MODELVIEW). Для начала также следует отменить все предыдущие установки и преобразования, сделав матрицу проекций единичной с помошью функции glLoadIdentity(). Если координаты вершин объекта задаются при его создании, то дополнительные преобразования системы координат не требуются. Однако часто это сложно или просто невозможно.

OpenGL предоставляет три функции для выполнения преобразования системы координат: glTranslated(), glRotated() и glScaled(). Эти команды генерируют матрицы переноса, поворота и масштабирования, которые домножаются на видовую матрицу с помощью функции glMultMatrix(). Как видите OpenGL берёт на себя матричные операции и выполняет их по специальным, быстрым алгоритмам с максимальной эффективностью. Например:

Перенос

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

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

Осуществляется с использованием функции, которая имеет следующий прототип:

Если аргумент больше 1, то объект при отображении будет увеличенным. Если аргумент меньше 1, то объект при отображении будет уменьшенным. Если аргумент отрицательный, то объект при отображении будет ещё и отраженным. Нулевое значение аргумента допускается, но будет приводить ктому, что размеры объекта будут нулевыми.

Поворот

Осуществляется с использованием функции, которая имеет следующий прототип:

void glRotated(double angle, double x, double y, double z); glRotated(30.,0.,0.,1.); //Поворот вокруг z
glBegin(GL_LINE_LOOP);
//Установка вершин
glVertex2d(-2., 2.);
glVertex2d(2., 2.);
glVertex2d(2., -2.);
glVertex2d(-2., -2.);
glEnd();

Первый аргумент определяет угол поворота, а остальные три -- координаты вектора, вокруг которого осуществляется вращение.

Стек матриц

Полезным механизмом при построении сложных изображений является стек матриц. С использованием функций glPushMatrix() и glPopMatrix() можно запомнить текущую матрицу в стеке и восстановить ее после каких либо изменений в системе координат.

Дисплейные списки

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

Каждый дисплейный список должен иметь идентификатор. Это может быть произвольное целое число, которое вы можете назначить сами. Во избежание конфликтов идентификаторов списков библиотека OpenGL рекомендует воспользоваться функцией

GLuint glGenLists(GLsizei range);

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

Для того, чтобы начать формировать список, необходимо вызвать функцию

void glNewList (GLuint list, GLenum mode);

Первый аргумент задает идентификатор формируемого списка, а второй определяет будет ли список только сформирован (GL_COMPILE) или сразу же и отображен (GL_COMPILE_AND_EXECUTE). Далее могут следовать команды OpenGL которые требуется сохранить в списке. Не все команды могут быть в него включены.

Формирование списка заканчивается функцией:

void glEndList (void);

После формирования дисплейные списки сохраняются во внутренней структуре данных OpenGL-окна и будут удалены, когда окно будет закрыто или разрушено.

Для выполнения дисплейного списка используется команда:

void glCallList (GLuint list);

которая в качестве аргумента принимает идентификатор списка.

Вызов функции glCallList() можно осуществить в любом мемте программы, когда требуется выполнение сохраненных в списке команд.

Рассмотрим пример:

void Draw(void)
{
//Очистка цветового буфера

glColor3d(1.0, 1.0, 0.0);

glBegin(GL_LINES);
glVertex2d(-50., .0);
glVertex2d(50., .0);

For(int i=-50; i<50; i++)
{
glVertex2d(i, .0);
if(i % 5)
{
glVertex2d(i, -1.);
}
else if(i % 10)
{
glVertex2d(i, -2.);
}
else
{
glVertex2d(i, -3.);
}
}
glEnd();

glBegin(GL_LINES);
glVertex2d(.0, -50.);
glVertex2d(.0, 50.);
for(int j=-50; j<50; j++)
{
glVertex2d(.0, j);
if(j % 5)
{
glVertex2d(-1., j);
}
else if(j % 10)
{
glVertex2d(-2., j);
}
else
{
glVertex2d(-3., j);
}
}
glEnd();
//Завершить выполнение команд
glFlush();
}

void Draw(void)
{
//Очистка цветового буфера
glClear(GL_COLOR_BUFFER_BIT);
//Установка цвета отображения
glColor3d(1.0, 1.0, 0.0);

//Формирование оси
int axis = glGenLists(1);
if (axis != 0)
{
glNewList(axis, GL_COMPILE);
glBegin(GL_LINES);
glVertex2d(0., .0);
glVertex2d(100., .0);

For(int i=0.; i<97; i++)
{
glVertex2d(i, .0);
if(i % 5)
{
glVertex2d(i, 1.);
}
else if(i % 10)
{
glVertex2d(i, 2.);
}
else
{
glVertex2d(i, 3.);
}
}
glEnd();
//Формирование стрелки можно добавить позже
glBegin(GL_LINE_STRIP);
glVertex2d(97., 1.);
glVertex2d(100.,.0);
glVertex2d(97., -1.);
glEnd();
glEndList();
}
//Рисование горизонтальной оси
glPushMatrix();
glTranslated(-50.,0.,0.);
glRotated(180.,1.,0.,0.);
glCallList(axis);
glPopMatrix();

//Рисование вертикальной оси
glPushMatrix();
glTranslated(0.,-50.,0.);
glRotated(90.,0.,0.,1.);
glCallList(axis);
glPopMatrix();

//Завершить выполнение команд
glFlush();
}