Кодирование изображения бинарными деревьями

Размещено на http://www.allbest.ru/

Министерство образования и науки Российской Федерации

ИжГТУ

Кафедра вычислительной техники

Курсовая работа

по курсу «Технология программирования»

на тему: «Объектно-ориентированное программирование»

Вариант 18

Разработал студент группы 363 Хузин Б.А.

Принял к.т.н., доцент кафедры ВТ Гафаров Р.М.

Ижевск 2005

Введение

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

кодирование бинарный изображение pascal

1. Задание

Реализовать алгоритм кодирования и декодирования изображения по бинарному дереву.

2. Цель работы. Постановка задачи

1) Закодировать изображение по принципу бинарного дерева;

2) Восстановить изображение, используя тот же принцип.

Целью данной работы является исследование алгоритмов кодирования изображений и реализация определенного алгоритма на языке Pascal в рамках методики ООП. Программа должна позволять кодировать изображения бинарными деревьями. Сначала изображение подвергается анализу и разложению на уровни детализации (с сохранением коэффициентов для восстановления). Закодированное изображение передается (в виде потока бит) и декодируется: по мере поступления новых бит изображение детализируется, увеличивается разрешение.

3. Анализ и разработка алгоритма

Для реализации алгоритма необходимо разобраться в работе бинарных деревьев.

Бинарные деревья представляют собой структуру данных, которая широко используется в машинной графике и в обработке изображений. Ее применение дает наилучшие результаты если изображение представляет собой прямоугольник размерность которого 2ⁿ x 2^m точек. Данный прямоугольник можно разбить на два меньших по размеру прямоугольника: 2^n-1 2^m или 2ⁿ 2^m-1. Процесс такого разбиения можно повторять p раз пока размер прямоугольника не станет равен 1х1. Полученные уровни можно пронумеровать, начиная с 0, которым обозначается изображение в целом, вплоть до p, соответствующего одному пикселю. Каждый выделяемый прямоугольник можно пометить либо 0 либо 1, в зависимости от положения прямоугольника. В результате отдельные пиксели будут снабжены метками, состоящими из p символов. Эту структуру можно представить в виде дерева, вершины которого будут соответствовать отдельным прямоугольникам.

Рис. 1 Часть бинарного дерева

Вершины дерева соединяются, если прямоугольник, соответствующий одной из них, непосредственно содержится в прямоугольнике, соответствующем родительской вершине. Корень дерева (root) соответствует изображению в целом, листья - отдельным пикселям, а все остальные вершины характеризуются степенью исхода, равной 2. Дерево такого вида обычно называют деревом второй степени или бинарным деревом.

Допустим, есть изображение размером 2ⁿ x 2^m точек, где каждая точка характеризуется интенсивностью цвета (изображение в оттенках серого). Для построения соответствующего уровня дерева необходимо просмотреть пары соседних пикселей и проанализировать их (свертка по горизонтали). Пусть f₁ и f₂ - соответствующие уровни серого тона для каждого пикселя. Теперь можно определить два новых уровня:

- средний цвет соседних пикселей.

- коэффициент для восстановления.

При переходе от уровней серого тона f₁ и f₂ к уровню g не происходит никакой потери информации, поскольку значения f₁ и f₂ восстанавливаются по значению g, при помощи следующих формул:

Единственное затруднение связанно с тем, что для представления уровней g, может потребоваться больше битов, чем для уровней f.

Таким образом, получены две матрицы, размерность которых 2^n-1 2^m. Первая содержит информацию о среднем цвете соседних пикселей, а вторая информацию для восстановления исходного изображения. Далее можно точно таким же образом обработать матрицу №1, но парными считать пиксели не по горизонтали, а по вертикали. Чередуя обработку получающихся прямоугольников по горизонтали и по вертикали можно получить в конце матицу размером 1х1 содержащую информацию о среднем цвете всего изображения, и несколько матриц содержащих информацию об уточнении цвета от уровня к уровню.

Восстановление исходного изображения происходит в обратном порядке. Сначала поступает информация о среднем цвете всего изображения и выводится на экран, при этом происходит масштабирование до исходного размера изображения. Далее поступает информация о коэффициентах сжатия и происходит уточнение (детализация изображения), размер изображения становится 2х1. Последовательно поступает информация о коэффициентах сжатия для каждого следующего уровня. Таким образом, восстанавливается исходное изображение.

4. Алгоритм

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

· Исходное изображение: вводит на экран исходное изображение.

· Матрицы: хранят данные о разрешении изображения, количестве выделенной для них памяти и о количестве бит на цвет. И процедуры вычисления количества необходимой памяти и ее выделения и освобождения.

· Процесс кодирования и декодирования изображения: содержит процедуры для кодирования изображения по вертикали и горизонтали и соответствующие им процедуры декодирования.

В дополнение к перечисленным объектам в программе должна быть реализована процедура выделения необходимых битов из потока байт. Она обособленна от остальных процедур и может быть вызвана в любой из них. Максимальное количество бит, которое может быть выделено из потока равно 16. Эта процедура необходима, так как количество бит для задания цвета одного пикселя не всегда степень двойки.

В программе реализован вариант, когда количество бит для задания цвета одного пикселя равно 4. Это связанно с тем, что графические режимы, устанавливаемые в Turbo Pascal`e поддерживают режимы с индексированными цветами и не поддерживают других (стандартными методами).

Описание процедур:

DrawSourceImage(x,y: word) - рисует изображение на экране в зависимости от выбранного пользователем разрешения.

Далее происходит выделение памяти для хранения и обработки изображения (procedure MemAllocIMG). Затем изображение с экрана копируется в массив для хранения исходного изображения. Начинается процесс кодирования:

В процедуре BuildMipMapIMG происходит последовательное кодирование изображения по горизонтали (BuildMipMapIMG_hor) и по вертикали (BuildMipMapIMG_ver). Перед каждым блоком коэффициентов сжатия ставится специальный бит-флаг, который обозначает как прошло кодирование (горизонтально, вертикально). Таким образом кодирование происходит поочередно (горизонтально, вертикально), если возможно. Если по какой либо оси сжать больше нельзя, а по другой оси можно то сжатие происходит только для одной оси. Такой подход дает возможность для кодирования не только квадратных изображений, но и изображений прямоугольной формы. Хотя затрачиваются дополнительные биты для хранения ориентации восстанавливаемого прямоугольника.

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

Перед завершением программы происходит очистка выделенной памяти (MemFreeIMG), и программа прекращает работу.

5. Результаты моделирования программы на ЭВМ

Кодирование изображения

Декодирование изображения

6. Текст программы

uses Graph, CRT;

const

PAUSE: word = 16000;

type

TArray = array[0..0] of byte;

Parray = ^Tarray;

{}

TScreenEngine = object

procedure DrawSourceImage(x,y: word);

end;

Timage = object(TScreenEngine)

img_src: Parray;

size_src: word;

img_cod: Parray;

size_cod: word;

resX: word;

resY: word;

bits: byte;

procedure MemAllocIMG;

procedure MemFreeIMG;

end;

TBinaryIMG = object(Timage)

pos_cod: longint;

procedure BuildMipMapIMG_hor (nx,ny: word);

procedure BuildMipMapIMG_ver (nx,ny: word);

procedure BuildMipMapIMG;

procedure DecodeMipMapIMG;

procedure OutImage(Img: Parray; PosX,PosY: word);

procedure RescaleImage(Img: Parray; ResXcd,ResYcd,PosX,PosY: word);

end;

procedure Timage.MemAllocIMG;

var

levX,levY: byte;

A: longint;

begin

levX:=trunc(ln(ResX)/ln(2));

levY:=trunc(ln(ResY)/ln(2));

A:=((Longint(resx)*resy-1)*(bits+1)+levX+levY+bits);

size_cod:= A div 8 + 1;

size_src:= size_cod;

if (size_cod*2 <= MemAvail) then begin

GetMem(img_cod, size_cod);

GetMem(img_src, size_src);

end

else begin

Writeln('Low memory avail...');

Halt(1);

end;

end;

procedure Timage.MemFreeIMG;

begin

FreeMem(img_cod, size_cod);

FreeMem(img_src, size_src);

end;

function GetBitValue(mas: Parray; pos:Longint; numbit: byte): word;

var

W: word;

begB: word;

endB: word;

delta: word;

buff: Longint;

shift,i: word;

begin

W:=0;

buff:=0;

if (numbit <= 16) then begin

begB := pos div 8 + 1;

endB := (pos + numbit-1) div 8 + 1;

delta:= endB - begB + 1;

for i:=0 to (delta-1) do begin

buff := buff shl 8;

buff := buff + mas^[i+begB-1];

end;

shift := 7 - ((pos + numbit - 1) mod 8);

buff := buff shr shift;

buff := buff and ((1 shl numbit) - 1);

W:= buff;

end else writeln('Error... (num bits > 16)');

GetBitValue := W;

end;

procedure SetBitValue(mas: Parray; poss:Longint; numbit: byte; val: word);

var

W: word;

begB: word;

endB: word;

delta: word;

mask,tmp,buff: Longint;

shift,i: word;

begin

W:=0;

buff:=0;

if (numbit <= 16) then begin

begB := poss div 8 + 1;

endB := (poss + numbit-1) div 8 + 1;

delta:= endB - begB + 1;

for i:=0 to (delta-1) do begin

buff := buff shl 8;

buff := buff + mas^[i+begB-1];

end;

shift := 7 - ((poss + numbit - 1) mod 8);

tmp := val shl shift;

mask:= 1;

mask:= mask shl (numbit + shift);

mask:= mask - 1;

mask:= mask - ((1 shl shift) - 1);

buff:= buff and NOT(mask);

buff:= buff + tmp;

for i:=(delta-1) downto 0 do begin

mas^[i+begB-1]:= byte(buff);

buff:=buff shr 8;

end;

end else writeln('Error... (num bits > 16)');

end;

procedure TBinaryIMG.OutImage(Img: Parray; PosX,PosY: word);

var

i,j: word;

A,B: word;

pos: longint;

begin

pos:=0;

for i:= 0 to (ResY-1) do begin

for j:= 0 to (ResX-1) do begin

A := GetBitValue(Img, pos, bits);

pos:=pos+longint(bits);

PutPixel(j+PosX,i+PosY,A);

end;

end;

end;

procedure TBinaryIMG.RescaleImage(Img: Parray; ResXcd,ResYcd,PosX,PosY: word);

var

kx,ky,i,j,xx,yy: word;

A,B: word;

pos_tmp,pos: longint;

tmpIMG: Parray;

r: longint;

begin

r:= (longint(resX)*resY*bits) div 8 + 1;

GetMem(tmpIMG, r);

kx:=resX div resXcd;

ky:=resY div resYcd;

pos:=0;

pos_tmp:=0;

for i:= 0 to (resYcd-1) do begin

for j:= 0 to (resXcd-1) do begin

A := GetBitValue(Img, pos, bits);

pos:=pos+longint(bits);

for yy:=0 to (ky - 1) do begin

for xx:=0 to (kx - 1) do begin

pos_tmp:= (Longint(i)*resXcd)*(ky*kx*bits) + Longint(j)*(kx*bits);

pos_tmp:= pos_tmp + (Longint(yy)*resXcd)*(kx*bits) + Longint(xx)*(bits);

SetBitValue(tmpIMG, pos_tmp, bits, A);

end;

end;

end;

end;

OutImage(tmpImg,posx,posy);

FreeMem(tmpIMG, r);

end;

procedure TBinaryIMG.BuildMipMapIMG_hor (nx,ny: word);

var

pos_src: longint;

x,y: word;

G_t: word;

conv_A: word;

conv_B: word;

bt: word;

begin

pos_cod:= pos_cod+ longint(1) - (longint(1) + (longint(nx) shr 1)*longint(ny)*(bits+1));

SetBitValue(img_cod, pos_cod, 1, 0); {is horizontal svrt}

pos_cod:=pos_cod + longint(1);

pos_src:=0;

for y:=0 to (ny-1) do begin

for x:=0 to ((nx shr 1)-1) do begin

conv_A := GetBitValue(img_src, (2*x + nx*y)*bits, bits);

conv_B := GetBitValue(img_src, (2*x+1 + nx*y)*bits, bits);

G_t:= (conv_A + conv_B) div 2;

bt := (conv_A + conv_B) mod 2;

{G_t}

SetBitValue(img_src, pos_src, bits, G_t);

pos_src:=pos_src+bits;

{F-0}

SetBitValue(img_cod, pos_cod, bits, conv_A);{}

pos_cod:=pos_cod + bits;

{Bt-flag}

SetBitValue(img_cod, pos_cod, 1, bt);{}

pos_cod:=pos_cod + 1;{}

end;

end;

pos_cod:= pos_cod - 1 - (1 + (longint(nx) shr 1)*longint(ny)*(bits+1));{}

end;

procedure TBinaryIMG.BuildMipMapIMG_ver (nx,ny: word);

var

pos_src: longint;

x,y: word;

G_t: word;

conv_A: word;

conv_B: word;

bt: word;

begin

pos_cod:= pos_cod+ 1 - (1 + longint(nx)*(ny shr 1)*(bits+1));

SetBitValue(img_cod, pos_cod, 1, 1); {is vertical svrt}

pos_cod:=pos_cod + 1;

pos_src:=0;

for y:=0 to ((ny shr 1) - 1) do begin

for x:=0 to (nx - 1) do begin

conv_A := GetBitValue(img_src, (x + nx*(y*2))*bits, bits);

conv_B := GetBitValue(img_src, (x + nx*(y*2+1))*bits, bits);

G_t:= (conv_A + conv_B) div 2;

bt := (conv_A + conv_B) mod 2;

{G_t}

SetBitValue(img_src, pos_src, bits, G_t);

pos_src:=pos_src+bits;

{F-0}

SetBitValue(img_cod, pos_cod, bits, conv_A);

pos_cod:=pos_cod + bits;

{Bt-flag}

SetBitValue(img_cod, pos_cod, 1, bt);

pos_cod:=pos_cod + 1;{}

end;

end;

pos_cod:= pos_cod - 1 - (1 + longint(nx)*(ny shr 1)*(bits+1));{}

end;

procedure TBinaryIMG.BuildMipMapIMG;

var

{ pos_c: longint;}

x,y,i,j,t: word;

levX, levY: byte;

cof: Shortint;

begin

if (((resx mod 2) = 0) and ((resy mod 2) = 0)) then

begin

levX:= trunc(ln(resx)/ln(2));

levY:= trunc(ln(resy)/ln(2));

if (resx > 64) and (resy > 64) then cof:=1;

if (resx > 64) and (resy < 128) then cof:=0;

if (resx < 128) and (resy > 64) then cof:=0;

if (resx < 128) and (resy < 128) then cof:=-1;

pos_cod:= (Longint(resx)*resy-1)*(longint(bits)+1)+levX+levY + bits + cof;{}

x:=resx;

y:=resy;

repeat

if (x > 1) then begin

{***}

RescaleImage(img_src,x,y,280,1);

delay(PAUSE);

{***}

BuildMipMapIMG_hor(x, y);{}

x:=x shr 1;

end;

if (y > 1) then begin

{***}

RescaleImage(img_src,x,y,280,1);

delay(PAUSE);

{***}

BuildMipMapIMG_ver(x, y); {}

y:=y shr 1;

end;

until ((x < 2) and (y < 2));

{ closegraph;

writeln(pos);

readln;{}

pos_cod:=pos_cod-bits+1;

x := GetBitValue(img_src, 0, bits);

SetBitValue(img_cod, pos_cod, bits, x);

end else writeln('Image must be [2*n x 2*k] size...');

end;

procedure TBinaryIMG.DecodeMipMapIMG;

var

pos_src: longint;

pos_tmp: longint;

bitcount:longint;

bs,i,j,x,y,F0,G,Bt,Mode: word;

levX, levY: byte;

tmp_img: Parray;

begin

pos_cod:=0;{}

pos_src:=0;

levX:= trunc(ln(resx)/ln(2));

levY:= trunc(ln(resy)/ln(2));

bitcount:= (longint(resx)*resy-1)*(longint(bits)+1)+levX+levY+bits+1;

bs:= bitcount div 8 + 1;

GetMem(tmp_img, bs);

x:=1;

y:=1;

F0:= GetBitValue(img_cod, pos_cod, bits);

pos_cod:=pos_cod+bits;

SetBitValue(img_src, pos_src, bits, F0);

SetBitValue(tmp_img, pos_src, bits, F0);

repeat{}

{Print}

RescaleImage(img_src,x,y,280,1);

delay(PAUSE);

{end print}

Mode:= GetBitValue(img_cod, pos_cod, 1);

pos_cod:=pos_cod+1;

if (Mode = 0) then begin

{**********************}

pos_src:=0;

pos_tmp:=0;

for i:=1 to y do begin

for j:=1 to x do begin

F0:= GetBitValue(img_cod, pos_cod, bits);

pos_cod:=pos_cod+bits;

Bt:= GetBitValue(img_cod, pos_cod, 1);

pos_cod:=pos_cod+1;

G:= GetBitValue(img_src, pos_src, bits);

pos_src:=pos_src+bits;

SetBitValue(tmp_img, pos_tmp, bits, F0);

SetBitValue(tmp_img, pos_tmp+bits, bits, 2*G - F0 + Bt);

pos_tmp:=pos_tmp+2*bits;

end;

end;

{**********************}

{Copy}

for i:=0 to ((pos_tmp-1) div 8 + 1) do img_src^[i]:= tmp_img^[i];

x:=x shl 1;

end else begin

{**********************}

pos_src:=0;

pos_tmp:=0;

for i:=1 to y do begin

for j:=1 to x do begin

F0:= GetBitValue(img_cod, pos_cod, bits);

pos_cod:=pos_cod+bits;

Bt:= GetBitValue(img_cod, pos_cod, 1);

pos_cod:=pos_cod+1;

G:= GetBitValue(img_src, pos_src, bits);

pos_src:=pos_src+bits;

SetBitValue(tmp_img, pos_tmp, bits, F0);

SetBitValue(tmp_img, pos_tmp+bits*x, bits, 2*G - F0 + Bt);

pos_tmp:=pos_tmp+bits;

end;

pos_tmp:= pos_tmp+bits*x;

end;

{**********************}

{Copy}

for i:=0 to ((pos_tmp) div 8 + 1) do img_src^[i]:= tmp_img^[i];

y:=y shl 1;

end;

until ((x = resx) and (y = resy));{(pos_cod >= bitcount);{}

{Print}

OutImage(tmp_img,280,1);

{end print}

FreeMem(tmp_img, bs);

end;

procedure TScreenEngine.DrawSourceImage(x,y: word);

var

i: byte;

begin

SetRGBPalette(1,10,10,10);

SetRGBPalette(2,20,20,20);

SetRGBPalette(3,40,40,40);

SetRGBPalette(4,60,60,60);

SetRGBPalette(5,80,80,80);

SetRGBPalette(6,40,40,40);

SetRGBPalette(7,50,50,50);

SetRGBPalette(8,63,63,63);

SetRGBPalette(9,70,70,70);

SetRGBPalette(10,60,60,60);

SetRGBPalette(11,70,70,70);

SetRGBPalette(12,80,80,80);

SetRGBPalette(13,80,80,80);

SetRGBPalette(14,80,80,80);

SetRGBPalette(15,80,80,80);

setcolor(2);

Line(1,1,x,1);

Line(x,1,x,y);

Line(x,y,1,y);

Line(1,y,1,1);

for i:=0 to 19 do Line(12 + Round((x-20)/20*i),12,12+Round((x-20)/20*i) , 12+Round((y-20)/20*i));

SetLineStyle(SolidLn, 0, 3);

SetColor(3);

Line(0+10,0+10,x-10,y-10);

SetColor(1);

Line(0+10,10,x-10,10);

SetColor(4);

Line(x-10,10,x-10,y-10);

SetColor(5);

Circle(x div 2, y div 2, round(x / 6)-1);

Circle(x div 2, y div 2, round(x / 6)+1);

SetColor(4);

Circle(x div 2, y div 2, round(x / 6));

SetColor(5);

Circle(x div 2, y div 2, round(x / 5));

SetColor(2);

Circle(x div 2, y div 2, round(x / 4));

SetColor(4);

Circle(x div 2, y div 2, round(x / 3));

SetColor(0);

SetFillStyle(0, 0);

Bar(0,Y+2,GetMAxX,GetMaxY);{}

Bar(X+2,0,GetMAxX,GetMaxY);{}

SetLineStyle(SolidLn, 0, 1);

setcolor(15);

Line(0+279,0,x+1+279,0);

Line(x+1+279,0,x+1+279,y+1);

Line(x+1+279,y+1,0+279,y+1);

Line(0+279,y+1,0+279,0);

SetLineStyle(SolidLn, 0, 1);

setcolor(15);

Line(0,0,x+1,0);

Line(x+1,0,x+1,y+1);

Line(x+1,y+1,0,y+1);

Line(0,y+1,0,0);

end;

var

i,j,a,b: word;

IMG: TBinaryIMG;

resX,resY: word;

bits: byte;

pos: longint;

avail: longint;

grDriver: integer;

grMode: integer;

ErrCode: integer;

begin

write('ResX[32..128] = ');

readln(ResX);

write('ResY[32..128] = ');

readln(ResY);

if (ResX < 129) and (ResY < 129) and (ResX > 31) and (ResY > 31) then

begin

bits:= 4;

grDriver := VGA;

grMode := VGAHi;

InitGraph(grDriver, grMode,'');

ErrCode := GraphResult;

if ErrCode = grOk then

begin { Do graphics }

avail:= MemAvail;

IMG.bits := bits;

IMG.resX := resX;

IMG.resY := resY;

IMG.MemAllocIMG;

IMG.DrawSourceImage(ResX,ResY);

pos:=0;

for i:= 0 to (ResY-1) do begin

for j:= 0 to (ResX-1) do begin

A := getPixel(j+1, i+1);

SetBitValue(IMG.img_src, pos, bits, A);

pos:=pos+bits;

end;

end;

outTextXY(10,resY+10,'Source image');

outTextXY(10+280,resY+10,'Code image');

outTextXY(10+280,resY+30,'To begin press any key...');

repeat

until KeyPressed;

IMG.BuildMipMapIMG;

IMG.DecodeMipMapIMG;{}

readln;

IMG.MemFreeIMG;

if (avail <> MemAvail) then begin

writeln('Error in memory allocation...');

readln;

end;

outTextXY(10,GetMaxY-10,'Demonstration finish...');

repeat

until KeyPressed;

end

else Writeln('Graphics error:', GraphErrorMsg(ErrCode));

CloseGraph;

end else writeln('Enter correct value :)');

end.

Выводы

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

Литература

1. Гафаров Р.М. Методические указания для выполнения курсовых и лабораторных работ. Ижевск, 2002.

2. Чэн Ш.-К. Принципы проектирования систем визуальной информации. М., Мир, 1994.

3. Павлидис Т. Алгоритмы машинной графики и обработки изображений. Радио и связь, М., 1986.

Размещено на Allbest.ru

...