31016-1 (Трехмерная графика. Теория)

Трехмерная графика

Краткие теоретические сведения.

Каждая точка пространства (кроме начальной точки О) может быть задана четверкой одновременно не равных нулю чисел ((x,y,z,1) или, более обще, (hx,hy,hz,h), где ). Эта четверка определена однозначно с точностью до общего множителя. Предложенный подход дает возможность воспользоваться матричной записью и в более сложных , трехмерных задачах.

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

A. Матрицы вращения в пространстве.

Матрица вращения вокруг оси абсцисс на угол q:

Матрица вращения вокруг оси ординат на угол w:

Матрица вращения вокруг оси аппликат на угол x:

Б. Матрица растяжения (сжатия):

здесь a>0 - коэффициент растяжения (сжатия) вдоль оси абсцисс,b>0-коэффициент растяжения (сжатия) вдоль оси ординат,y>0-коэффициент растяжения (сжатия) вдоль оси аппликат.

В. Матрица отражения .

Матрица отражения относительно плоскости xOy:

Матрица отражения относительно плоскости yOz:

Матрица отражения относительно плоскости zOx:

Г. Матрица переноса :

Здесь (r,q,v)-вектор переноса.

Заметим, что, как и в двумерном случае , все выписанные матрицы не вырождены.

Ортографическая проекция - картинная плоскость совпадает с одной из координатных плоскостей или параллельна ей. Матрица проектирования вдоль оси Х на плоскость YOZ имеет вид

В случае , если плоскость проектирования параллельна координатной плоскости, необходимо умножить матрицу [Px] на матрицу сдвига . Имеем

Аналогично записываются матрицы проектирования вдоль 2-х координатных осей:

Аксонометрическая проекция - проектирующие прямые перпендикулярны картинной плоскости .

Различают три вида проекций в зависимости от взаимного расположения плоскости проектирования и координатных осей:

триметрия-нормальный вектор картинной плоскости образует с ортами координатных осей попарно различные углы(рис.15);

диметрия-два угла между нормалью картинной плоскости и координатными осями равны (рис. 16).

- изометрия-все три угла между нормалью картинной плоскости и координатными осями равны (рис. 17).

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

Перспективные (центральные) проекции строятся более сложно . Предположим что центр проектирования лежит на оси Z - C (0,0,c) а плоскость проектирования совпадает с координатной плоскостью XOY (рис. 19) . Возьмем в пространстве произвольную точку M(x,y,z), проведем через нее и точку С прямую и запишем ее параметрические уравнения . Имеем:

X`= xt , Y`=yt, Z`= c+(z-c)t

Найдем координаты точки пересечения этой прямой с плоскостью XOY. Из того , что z`=0, получаем

Тот же самый результат мы получим, привлекая матрицу

В самом деле,

Mатрица проектирования, конечно, вырождена ; матрица же соответствующего перспективного преобразования(без проектирования) имеет следующий вид

Язык С++ предоставляет очень удобные средства, позволяющие заметно упростить работу с векторами и преобразованиями в пространстве.

Рассмотрим реализацию работы с векторами.

// Файл vector.h

#ifndef __VECTOR__#define __VECTOR__#include class Vector{public: double x, y, z; Vector () {}; Vector ( double v ) { x = y = z = v; };

Vector ( const Vector& v ) { x = v.x; y = v.y; z = v.z; };

Vector ( double vx, double vy, double vz ) { x = vx; y = vy; z = vz; };

Vector& operator = ( const Vector& v ) { x = v.x; y = v.y; z = v.z;

return *this; }

Vector& operator = ( double f ) { x = y = z = f; return *this; };

Vector operator - () const;

Vector& operator += ( const Vector& );

Vector& operator -= ( const Vector& );

Vector& operator *= ( const Vector& );

Vector& operator *= ( double );

Vector& operator /= ( double );

friend Vector operator + ( const Vector&, const Vector& );

friend Vector operator - ( const Vector&, const Vector& );

friend Vector operator * ( const Vector&, const Vector& );

friend Vector operator * ( double, const Vector& );

friend Vector operator * ( const Vector&, double );

friend Vector operator / ( const Vector&, double );

friend Vector operator / ( const Vector&, const Vector& );

friend double operator & ( const Vector& u, const Vector& v )

{ return u.x * v.x + u.y * v.y + u.z * v.z; };

friend Vector operator ^ ( const Vector&, const Vector& );

double operator ! () { return (double) sqrt ( x * x + y * y + z * z ); };

double& operator [] ( int n ) { return *( &x + n ); };

int operator < ( double v ) { return x < v && y < v && z < v; };

int operator > ( double v ) { return x > v && y > v && z > v; };

};

class Ray

{

public:

Vector Org;

Vector Dir;

Ray () {};

Ray ( Vector& o, Vector& d ) { Org = o, Dir = d; };

Vector Point ( double t ) { return Org + Dir * t; };

};

inline Vector Vector :: operator - () const

{

return Vector ( -x, -y, -z );

}

inline Vector operator + ( const Vector& u, const Vector& v )

{

return Vector ( u.x + v.x, u.y + v.y, u.z + v.z );

}

inline Vector operator - ( const Vector& u, const Vector& v )

{

return Vector ( u.x - v.x, u.y - v.y, u.z - v.z );

}

inline Vector operator * ( const Vector& u, const Vector& v )

{

return Vector ( u.x * v.x, u.y * v.y, u.z * v.z );

}

inline Vector operator * ( const Vector& u, double f )

{

return Vector ( u.x * f, u.y * f, u.z * f );

}

inline Vector operator * ( double f, const Vector& v )

{

return Vector ( f * v.x, f * v.y, f * v.z );

}

inline Vector operator / ( const Vector& u, const Vector& v )

{

return Vector ( u.x / v.x, u.y / v.y, u.z / v.z );

}

inline Vector operator / ( const Vector& u, double f )

{

return Vector ( u.x / f, u.y / f, u.z / f );

}

inline Vector& Vector :: operator += ( const Vector& v )

{

x += v.x;

y += v.y;

z += v.z;

return *this;

}

inline Vector& Vector :: operator -= ( const Vector& v )

{

x -= v.x;

y -= v.y;

z -= v.z;

return *this;

}

inline Vector& Vector :: operator *= ( const Vector& v )

{

x *= v.x;

y *= v.y;

z *= v.z;

return *this;

}

inline Vector& Vector :: operator *= ( double v )

{

x *= v;

y *= v;

z *= v;

return *this;

}

inline Vector& Vector :: operator /= ( double v )

{

x /= v;

y /= v;

z /= v;

return *this;

}

inline Vector Normalize ( Vector& v ) { return v / !v; }

Vector RndVector ();

Vector& Clip ( Vector& v );

#endif

----------------------------------------------------------------------------

// Файл vector.срр

#include

#include

#include "vector.h"

Vector operator ^ ( const Vector& u, const Vector& v )

{

return Vector ( u.y * v.z - u.z * v.y,

u.z * v.x - u.x * v.z,

u.x * v.y - u.y * v.x );

}

Vector RndVector ()

{

Vector v ( rand () - 0.5 * RAND_MAX,

rand () - 0.5 * RAND_MAX,

rand () - 0.5 * RAND_MAX );

return Normalize ( v );

}

Vector& Clip ( Vector& v )

{

if ( v.x < 0.0 ) v.x = 0.0;

else

if ( v.x > 1.0 ) v.x = 1.0;

if ( v.y < 0.0 ) v.y = 0.0;

else

if ( v.y > 1.0 ) v.y = 1.0;

if ( v.z < 0.0 ) v.z = 0.0;

else

if ( v.z > 1.0 ) v.z = 1.0;

return v;

}

С этой целью создается класс Vector, содержащий в себе компоненты вектора, и для этого класса переопределяются основные знаки операций.

- - унарный минус и поэлементное вычитание векторов;

+ - поэлементное сложение векторов;

* - умножение вектора на число;

* - поэлементное умножение векторов;

/ - деление вектора на число;

/ - поэлементное деление векторов;

& - скалярное произведение векторов;

^ - векторное произведение;

! - длина вектора;

[] - компонента вектора.

При этом стандартные приоритеты операций сохраняются.

Кроме этих операций определяются также некоторые простейшие функции для работы с векторами:

Normalize – нормирование вектора;

RndVector – получение почти равномерно распределенного случайного единичного вектора;

Clip – отсечение вектора.

С использованием этого класса можно в естественной и удобной форме записывать сложные векторные выражения.

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

//Файл matrix.h

#ifndef __MATRIX__

#define __MATRIX__

#include "vector.h"

class Matrix

{

public:

double x [4][4];

Matrix () {};

Matrix ( double );

Matrix& operator += ( const Matrix& );

Matrix& operator -= ( const Matrix& );

Matrix& operator *= ( const Matrix& );

Matrix& operator *= ( double );

Matrix& operator /= ( double );

void Invert ();

void Transpose ();

friend Matrix operator + ( const Matrix&, const Matrix& );

friend Matrix operator - ( const Matrix&, const Matrix& );

friend Matrix operator * ( const Matrix&, double );

friend Matrix operator * ( const Matrix&, const Matrix& );

friend Vector operator * ( const Matrix&, const Vector& );

};

Matrix Translate ( const Vector& );

Matrix Scale ( const Vector& );

Matrix RotateX ( double );

Matrix RotateY ( double );

Matrix RotateZ ( double );

Matrix Rotate ( const Vector&, double );

Matrix MirrorX ();

Matrix MirrorY ();

Matrix MirrorZ ();

#endif

//---------------------------------------------------------------------------

// Файл matrix.cpp

#include #include "matrix.h"Matrix :: Matrix ( double v ){ int j; for ( int i = 0; i < 4; i++ ) for ( j = 0; j < 4; j++ ) x [i][j] = ( i == j ) ? v : 0.0; x [3][3] = 1;}void Matrix :: Invert ()

{

Matrix Out ( 1 );

for ( int i = 0; i < 4; i++ ) {

double d = x [i][i];

if ( d != 1.0 ) {

for ( int j = 0; j < 4; j++ ) {

Out.x [i][j] /= d;

x [i][j] /= d;

}

}

for ( int j = 0; j < 4; j++ ) {

if ( j != i ) {

if ( x[j][i] != 0.0 ) {

double mulby = x[j][i];

for ( int k = 0; k < 4; k++ ) {

x [j][k] -= mulby * x [i][k];

Out.x [j][k] -= mulby * Out.x [i][k];

}

}

}

}

}

*this = Out;

}

void Matrix :: Transpose ()

{

double t;

int j;

for ( int i = 0; i < 4; i++ )

for ( j = 0; j < 4; j++ )

if ( i != j ) {

t = x [i][j];