Шикин Е.В., Боресков А.В. Компьютерная графика. Динамика, реалистические изображения

Подождите немного. Документ загружается.

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

151

t = ClosestDist;

return ClosestObj;

}

#pragma argsused // turn off parameter no used warning

Vector Environment :: ShadeBackground ( Ray& ray )

{

return Background;

}

////////////////////////// Functions ////////////////////

void SetCamera ( Vector& Org, Vector& Dir, Vector& UpDir )

{

Eye = Org; // eye point

EyeDir = Dir; // viewing direction

Vx = Normalize ( UpDir ^ Dir ); // build orthogonal basis of image plane

Vy = Normalize ( Dir ^ Vx ); // EyeDir orthgonal to this basic ( image plane

)

}

///////////////////////////////////////////////////////

// get a pixel ray for a given screen point ( x, y ) //

///////////////////////////////////////////////////////

void Camera ( double x, double y, Ray& ray )

{

ray.Org = Eye;

ray.Dir = Normalize ( EyeDir + Vx * x + Vy * y );

}

/////////////////////////////////////////

// Trace a given ray through the scene //

/////////////////////////////////////////

Vector Trace ( Medium& CurMed, double Weight, Ray& ray )

{

GObject * Obj;

double t = INFINITY;

Vector Color;

Level++;

TotalRays ++;

if ( ( Obj = Scene > Intersect ( ray, t ) ) != NULL ) // ray hit some object

{

Color = Shade ( CurMed, Weight, ray.Point ( t ), ray.Dir, Obj );

if ( CurMed.Betta > Threshold )

Color *= exp ( t * CurMed.Betta );

}

else

Color = Scene > ShadeBackground ( ray );

Level;

return Color;

}

/////////////////////////////////////////////////////////////

// compute light coming from point p in the direction View //

// using Whitted's illumination model //

/////////////////////////////////////////////////////////////

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

152

Vector Shade ( Medium& CurMed, double Weight, Vector& p, Vector& View, GObject * Obj

)

{

SurfaceData txt;

Ray ray;

Vector Color;

Vector l; // light vector

double Sh; // light shadow coeff.

Vector h; // vector between View and light vector

double ln, vn;

int Entering = 1; // flag whether we're entering or

leaving object

Obj > FindTexture ( p, txt );

if ( ( vn = View & txt.n ) > 0 ) // force ( View, n ) > 0

{

txt.n = txt.n;

vn = vn;

Entering = 0;

}

ray.Org = p; // since all rays will be cast from here

Color = Ambient * txt.Color * txt.Ka; // get ambient light

for ( int i = 0; i < Scene > LightsCount; i++ )

if ( ( Sh = Scene > Light [i] > Shadow ( p, l ) ) > Threshold )

if ( ( ln = l & txt.n ) > Threshold ) // if light is visible

{

if ( txt.Kd > Threshold ) // compute direct diffuse light

Color += Scene > Light [i] > Color * txt.Color * ( txt.Kd

* Sh * ln );

if ( txt.Ks > Threshold ) // compute direct specular light,

via Phong shading

{ // compute halfvector between View and l

h = Normalize ( l  View );

Color += Scene > Light [i] > Color * ( txt.Ks *

Sh * pow ( txt.n & h, txt.p));

}

doublerWeight = Weight * txt.Kr; // weight of reflected ray

doubletWeight = Weight * txt.Kt; // weight of transmitted ray

// check for reflected ray

if ( rWeight > Threshold && Level < MaxLevel )

{

ray.Dir = View  txt.n * ( 2 * vn ); // get reflected ray direction

Color += txt.Kr * Trace ( CurMed, rWeight, ray );

}

// check for transmitted ray

if ( tWeight > Threshold && Level < MaxLevel )

{ // relative index of refraction

doubleEta = CurMed.nRefr / ( Entering ? txt.Med.nRefr : Air.nRefr );

doubleci =  vn; // cosine of incident angle

doublectSq = 1 + Eta*Eta*( ci*ci  1 ); // squared cosine of transm. angle

if ( ctSq > Threshold ) // not a Total Internal Reflection

{

ray.Dir = View * Eta + txt.n * ( Eta*ci  sqrt ( ctSq ) );

if ( Entering ) // ray enters object ( txt.Med )

Color += txt.Kr * Trace ( txt.Med, tWeight, ray );

else // ray leaves object ( Air )

Color += txt.Kr * Trace ( Air, tWeight, ray );

}

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

153

}

return Color;

}

Файлы Render.cpp и Render.h содержат модуль, обеспечивающий трассировку сцены и

запись построенного изображения в файл формата TGA (функция RenderScene).

//File Render.h

#ifndef __RENDER__

#define __RENDER__

#include <stdlib.h>

void RenderScene ( double, double, int, int, char * );

void DistributedRenderScene ( double, double, int, int, int, int, char * );

void AdaptiveDistributedRenderScene ( double, double, int, int, int, int, double,

char * );

#endif

!//File Render.cpp

#include <alloc.h>

#include <conio.h>

#include <dos.h>

#include <fcntl.h>

#include <io.h>

#include <mem.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys\stat.h>

#include "Tracer.h"

#include "Draw.h"

#include "Render.h"

#include "Targa.h"

long far * TicksPtr = ( long far * ) 0x46CL;

void RenderScene ( double HalfWidth, double HalfHeight, int nx, int ny, char *

PicFileName )

{

double x, y; // sample point

double hx = 2.0 * HalfWidth / nx; // pixel width

double hy = 2.0 * HalfHeight / ny; // pixel height

Ray ray; // pixel ray

Vector Color;

int i, j;

long Ticks = * TicksPtr;

TargaFile * tga = new TargaFile ( PicFileName, nx, ny );

RGB c;

SetMode ( 0x13 );

SetPreviewPalette ();

for ( i = 0, y = HalfHeight; i < ny; i++, y = hy )

{

for ( j = 0, x =  HalfWidth; j < nx; j++, x += hx )

{

Camera ( x, y, ray );

Color = Trace ( Air, 1.0, ray );

Clip ( Color );

c.Red = Color.x * 255;

c.Green = Color.y * 255;

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

154

c.Blue = Color.z * 255;

tga > PutPixel ( c );

DrawPixel ( j, i, Color );

}

Ticks = * TicksPtr;

if ( Ticks < 0l )

Ticks = Ticks;

delete tga;

getch ();

SetMode ( 0x03 );

printf ( "\nEnd tracing." );

DrawTargaFile ( PicFileName );

printf ( "\nElapsed time : %d sec. ", (int)(Ticks/18) );

}

void DistributedRenderScene ( double HalfWidth, double HalfHeight, int nx, int ny,

int nxSub, int nySub, char * PicFileName )

{

double x, y; // sample point

Ray ray; // pixel ray

double hx = 2.0 * HalfWidth / nx; // pixel width

double hy = 2.0 * HalfHeight / ny; // pixel height

double hxSub = hx / nxSub;

double hySub = hy / nySub;

int i, j;

int PrimarySamples = nxSub * nySub; // # of samples taken for each pixel

Vector Color;

Vector LineBuffer [800];

long Ticks = * TicksPtr;

TargaFile * tga = new TargaFile ( PicFileName, nx, ny );

RGB c;

SetMode ( 0x13 );

SetPreviewPalette ();

for ( i = 0, y = HalfHeight; i < ny; i++, y = hy )

{

for ( j = 0, x =  HalfWidth; j < nx; j++, x += hx )

{

doublex1 = x  0.5 * hx;

doubley1 = y  0.5 * hy;

Color = 0;

for ( int iSub = 0; iSub < nxSub; iSub++ )

for ( int jSub = 0; jSub < nySub; jSub++ )

{

Camera ( x1 + hxSub*( iSub+Rnd() ), y1 + hySub*(

jSub+Rnd()), ray );

Color += Trace ( Air, 1.0, ray );

}

Color /= PrimarySamples;

Clip ( Color );

c.Red = Color.x * 255;

c.Green = Color.y * 255;

c.Blue = Color.z * 255;

tga > PutPixel ( c );

DrawPixel ( j, i, Color );

}

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

155

Ticks = * TicksPtr;

if ( Ticks < 0l )

Ticks = Ticks;

delete tga;

getch ();

SetMode ( 0x03 );

printf ( "\nEnd tracing." );

DrawTargaFile ( PicFileName );

printf ( "\nElapsed time : %d sec. ", (int)(Ticks/18) );

}

void AdaptiveDistributedRenderScene ( double HalfWidth, double HalfHeight, int nx,

int ny, int nxSub, int nySub, double Variance, char * PicFileName )

{

doublex, y; // sample point

Ray ray; // pixel ray

doublehx = 2.0 * HalfWidth / nx; // pixel size

doublehy = 2.0 * HalfHeight / ny;

doublehxSub = hx / nxSub;

doublehySub = hy / nySub;

doubleDisp; // dispersion squared

int i, j;

VectorColor;

VectorSum;

VectorMean;

int Count;

long Ticks = * TicksPtr;

TargaFile * tga = new TargaFile ( PicFileName, nx, ny );

RGB c;

SetMode ( 0x13 );

SetPreviewPalette ();

for ( i = 0, y = HalfHeight; i < ny; i++, y = hy )

{

for ( j = 0, x =  HalfWidth; j < nx; j++, x += hx )

{

doublex1 = x  0.5 * hx;

doubley1 = y  0.5 * hy;

doubled;

Sum = 0;

Disp = 0;

Count = 0;

{

for ( int iSub = 0; iSub < nxSub; iSub++ )

for ( int jSub = 0; jSub < nySub; jSub++ )

{

Camera ( x1 + hxSub*( iSub+Rnd() ), y1 + hySub*(

jSub+Rnd()), ray );

Color = Trace ( Air, 1.0, ray );

Sum += Color;

Disp += Color & Color;

Count++;

}

Mean = Sum / Count;

d = ( Disp / Count  ( Mean & Mean ) ) * Count / ( Count  1 );

} while ( d >= Variance && Count < 99 );

Clip ( Mean );

c.Red = Mean.x * 255;

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

156

c.Green = Mean.y * 255;

c.Blue = Mean.z * 255;

tga > PutPixel ( c );

DrawPixel ( j, i, Mean );

}

Ticks = * TicksPtr;

if ( Ticks < 0l )

Ticks = Ticks;

delete tga;

getch ();

SetMode ( 0x03 );

printf ( "\nEnd tracing." );

DrawTargaFile ( PicFileName );

printf ( "\nElapsed time : %d sec. ", (int)(Ticks/18) );

}

Для поддержки возможности вывода в несжатый 24битовый формат TGA служит класс

TargaFile, определяемый файлами Targa.h и Targa.cpp

!//File Targa.h

#ifndef __TARGA__

#define __TARGA__

struct TargaHeader

{

char TextSize;

char MapType;

char DataType;

int MapOrg;

int MapLength;

char CMapBits;

int XOffset;

int YOffset;

int Width;

int Height;

char DataBits;

char ImType;

};

#ifndef __RGB__

#define __RGB__

struct RGB

{

char Red;

char Green;

char Blue;

};

#endif

class TargaFile // basic class for writing TGA image files

{

public:

TargaFile ( char *, int, int, char * = "" );

~TargaFile ();

void PutPixel ( RGB );

private:

TargaHeader Hdr;

RGB * Buffer;

int BufSize;

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

157

int pos;

int file;

void Flush ();

};

#endif

!//File Targa.cpp

#include <fcntl.h>

#include <io.h>

#include <string.h>

#include <sys\stat.h>

#include "Targa.h"

TargaFile :: TargaFile ( char * name, int width, int height, char * comment )

{

_chmod ( name, 1, 0 ); // reset file's attributes

unlink ( name ); // remove file

file = open ( name, O_WRONLY | O_BINARY | O_CREAT, S_IWRITE );

BufSize = 1000;

Buffer = new RGB [BufSize];

pos = 0;

memset ( &Hdr, '\0', sizeof ( Hdr ) );

Hdr.DataType = 2;

Hdr.Width = width;

Hdr.Height = height;

Hdr.DataBits = 24;

Hdr.ImType = 32;

if ( comment [0] != '\0' )

Hdr.TextSize = strlen ( comment ) + 1;

write ( file, &Hdr, sizeof ( Hdr ) );

if ( Hdr.TextSize > 0 )

write ( file, comment, Hdr.TextSize );

}

TargaFile :: ~TargaFile ()

{

if ( pos > 0 )

Flush ();

delete Buffer;

close ( file );

}

void TargaFile :: PutPixel ( RGB color )

{

Buffer [pos].Red = color.Blue; // swap red & blue colors

Buffer [pos].Green = color.Green;

Buffer [pos].Blue = color.Red;

if ( ++pos >= BufSize ) // flush buffer if full

Flush ();

}

void TargaFile :: Flush ()

{

write ( file, Buffer, pos * sizeof ( RGB ) );

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

158

pos = 0;

}

При этом в процесс трассировки включен предварительный показ уже просчитанной

части сцены в процессе работы. Для этого используется специальная палитра из 256 цветов, в

которой по 3 бита отдается под красный и зеленые цвета, а оставшиеся 2 бита  под синий. как

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

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

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

затратам, так и по качеству получаемого изображения. Ниже рассматривается простейший

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

отводится по 5 бит  каждый цвет определяется тогда 15 битами и возможны 32 тысячи цветов)

и выборе 256 наиболее часто используемых цветов.

При выборе наиболее часто встречающихся цветов под каждый возможный цвет

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

действительно были использованы и при помощи стандартной процедуры быстрой сортировки

qsort определяются искомые 256 цветов.

Функции, непосредственно отвечающие за рисование, содержатся в файлах Draw.h и

Draw.cpp.

!//File Draw.h

#include <dos.h>

#include "vector.h"

#ifndef __DRAW__

#define __DRAW__

#ifndef __RGB__

#define __RGB__

struct RGB

{

char Red;

char Green;

char Blue;

};

#endif

void SetMode ( int );

void SetPalette ( RGB far * );

void SetPreviewPalette ();

void DrawPixel ( int, int, Vector& );

void BuildImagePalette ( char far *, RGB * );

void DrawImageFile ( char * );

void DrawTargaFile ( char * );

#endif

!//File Draw.cpp

#include <alloc.h>

#include <conio.h>

#include <fcntl.h>

#include <io.h>

#include <mem.h>

#include <stdio.h>

#include "Vector.h"

#include "Tracer.h"

#include "Draw.h"

#include "Targa.h"

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

159

void SetMode ( int Mode )

{

asm {

mov ax, Mode

int 10h

}

void SetPalette ( RGB far * Palette )

{

asm {

push es

mov ax, 1012h

mov bx, 0 // first color to set

mov cx, 256 // # of colors

les dx, Palette // ES:DX == table of color values

int 10h

pop es

}

void SetPreviewPalette ()

{

RGB Pal [256];

int i;

for ( i = 0; i < 256; i++ )

{

Pal [i].Red = ( 63 * ( i & 7 ) ) / 7;

Pal [i].Green = ( 63 * ( ( i >> 3 ) & 7 ) ) / 7;

Pal [i].Blue = ( 63 * ( ( i >> 6 ) & 3 ) ) / 3;

}

SetPalette ( Pal );

}

void DrawPixel ( int x, int y, Vector& Color )

{

int r = Color.x * 7 + 0.5;

int g = Color.y * 7 + 0.5;

int b = Color.z * 3 + 0.5;

pokeb ( 0xA000, x + y*320, r + ( g << 3 ) + ( b << 6 ) );

}

struct ColorData

{

int Hue; // color value

int Freq; // it's frequency

};

int ColorDataComp ( const void * v1, const void * v2 )

{

return ( (ColorData *) v2 ) > Freq  ( (ColorData *) v1 ) > Freq;

}

void BuildImagePalette ( char far * ColorTrans, RGB * Palette )

{

ColorData * ColorTable = new ColorData [8192];

int MinDist;

int d;

unsigned i, j;

int r, g, b;

int index;

int ColorsCount;

ОСНОВЫ МЕТОДА ТРАССИРОВКИ ЛУЧЕЙ

160

if ( ColorTable == NULL )

{

printf ( "\nNo memory for ColorTable" );

exit ( 1 );

}

// prepare used colors table ( color, frequency )

for ( ColorsCount = 0, i = 0; i < 32768; i++ )

if ( ColorTrans [i] > 0 && ColorsCount < 8192 )

{

ColorTable [ColorsCount].Hue = i;

ColorTable [ColorsCount].Freq = ColorTrans [i];

ColorsCount++;

}

// sort table on frequency

qsort ( ColorTable, ColorsCount, sizeof ( ColorData ), ColorDataComp );

memset ( Palette, 0, 256*3 );

for ( i = 0; i < 256 && i < ColorsCount; i++ )

{ // build 5bit values [0..31]

Palette [i].Red = 2 * ( ColorTable [i].Hue & 0x1F );

Palette [i].Green = 2 * ( ( ColorTable [i].Hue >> 5 ) & 0x1F );

Palette [i].Blue = 2 * ( ( ColorTable [i].Hue >> 10 ) & 0x1F );

}

// find darkest color

for ( MinDist = 1024, i = 0; i < 256; i++ )

{

int d = (int)Palette [i].Red + (int)Palette [i].Green + (int)Palette

[i].Blue;

if ( d < MinDist )

{

MinDist = d;

index = i;

}

if ( index != 0 ) // and make it background

{

RGB tmp = Palette [0];// swap Palette [0] and Palette [index]

Palette [0] = Palette [index];

Palette [index] = tmp;

}

_fmemset ( ColorTrans, 0, 32768 ); // init translation to palette color 0

for ( i = 0; i < ColorsCount; i++ ) // for every used color find closest palette

match

{ // get rgb for ColorTable [i]

r = 2 * ( ColorTable [i].Hue & 0x1F );

g = 2 * ( ( ColorTable [i].Hue >> 5 ) & 0x1F );

b = 2 * ( ( ColorTable [i].Hue >> 10 ) & 0x1F );

// scan palette for closest match

for ( MinDist = 1024, j = 0; j < 256; j++ )

{

d = abs ( r  Palette [j].Red ) + abs ( g  Palette [j].Green ) + abs (

b  Palette [j].Blue );

if ( d < MinDist )

{

MinDist = d;

index = j;

}

ColorTrans [ColorTable [i].Hue] = index;

}