Структура модуля имеет вид:

Unit Name_M; { Name_M - имя модуля }

{-----------------------------------------------------------------}

Interface { Интерфейсная часть модуля}

{------------------------------------ раздел описания глобальных имен}

Type MM= array[1..10, 1..10] of real; { описание типа}

Var Max_F, Min_F: real; {описание глобальных переменных}

{-----------------------------------------------------------------}

Procedure Name_P(p1: real; p2: MM); { описание заголовков процедуры}

Function Name_f(p3, p4: real): real; { и функции}

{-----------------------------------------------------------------}

Implementation {Исполняемая часть модуля}

{-------------------------------------- раздел описания локальных имен}

Const C = 'Подключен модуль Name_M'; { задание локальной константы}

Procedure Name_P; {Полное описание процедуры}

{ Раздел описания процедуры}

Begin { Раздел выполнения процедуры} End;

Function Name_f: real; {Полное описание функции}

{ Раздел описания функции}

Begin { Раздел выполнения функции} End;

{---------------------------------------------------------------- }

BEGIN { Инициирующая часть модуля}

Writeln(C); {операторы модуля}

END.

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

Модуль записывается в файл с именем модуля, например, Name_M. pas. Затем файл компилируется, при этом получается файл с расширением ". tpu", например, Name_M. tpu, который автоматически записывается в каталог, указанный в опции Options, Directories, EXE & TPU, иначе - в текущий каталог. При запуске программы, использующей модуль, файл с расширением ". tpu" ищется в каталоге, указанном в опции Options, Directories, EXE & TPU или Unit Directories, либо в текущем каталоге.

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

Program Pr_1;

Uses Name_M1, Name_M2;

Если в основной программе имя идентификатора совпадает с именем, объявленным в интерфейсной части подключенного модуля, то используются значения, присвоенные идентификатору в программе. Если одинаковые имена встречаются в интерфейсной части подключенных модулей (например в Name_M1 и Name_M2), то используются значения, присвоенные идентификатору в последнем описанном модуле, т. е. в Name_M2.

Приведем пример разработки и подключения модуля. В модуле опишем процедуры работы с матрицами.

Unit MATR_1;

{-----------------------------------------------------------------}

Interface

{-----------------------------------------------------------------}

Type M = array[1..10, 1..10] of real;

M1 = array[1..10] of real;

Procedure MAT_1(a:M; var b:M; n: word);

Procedure MAT_2(a:M; var b:M1; n: word);

{-----------------------------------------------------------------}

Implementation

{-----------------------------------------------------------------}

Procedure MAT_1; {создание матрицы "B", транспонированной к "A"}

var i, j: word;

begin for i:=1 to N do for j:=1 to N do b[i,j]:=a[j,i]

end;

{-----------------------------------------------------------------}

Procedure MAT_2; {расчет квадратов диагональных элементов}

var i, j: word;

begin for i:=1 to N do b[i]:=a[i,i]*a[i,i]

end;

{-----------------------------------------------------------------}

END.

В основной программе PR_1 подключается модуль MATR_1 и используются процедуры MAT_1 и MAT_2.

Program PR_1;

Uses MATR_1;

Type MM = M; MM1 = M1;

Var a1,a2,a3: MM; b1,b2: MM1; i,j,n: word;

Begin Writeln('введите размерность матрицы N='); Readln(n);

Randomize;

for i:=1 to n do for j:=1 to n do a1[i,j]:=random(20)+1;

MAT_1(a1, a2, n); MAT_1(a2, a3, n);

MAT_2(a1, b1, n); MAT_2(a2, b2, n) end.

В результате двойного транспонирования исходной матрицы "a1" (из "a1" в "a2", из "a2" в "a3") получается матрица "a3" тождественная "a1" .

Матрицы "b1" и "b2" содержат квадраты диагональных элементов матриц "a1" и "a2". Типы массивов фактических параметров должны соответствовать типам массивов формальных параметров, описанных в модуле MATR_1. Можно использовать имена типов, заданные в интерфейсной части модуля или задавать новые имена типов.

1.14 Модуль СRT

1.14.1 Управление экраном в текстовом режиме

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

При превышении допустимых пределов параметра N происходит преобразование N, при этом символы выводятся с мерцанием. Мерцание символов можно получить, также задавая: N:= N + 128;

В процедурах TextBackGround(N); и TextColor(N); можно применять параметр N, либо наименование цвета, например:

N:=1; TextColor(N); { либо } TextColor(Blue);

1.14.2 Управление клавиатурой

KeyPressed; - возвращает значение True (тип Boolean) - если была нажата любая клавиша (кроме Ctrl, Alt, NumLock и т. п. ), иначе - False.

ReadKey; - возвращает символ нажатой клавиши (тип Char).

Следующие операторы выводят на экран указанную надпись до нажатия клавиши:

Repeat Writeln('Нажмите скорее любую клавишу') until KeyPressed;

Следующие операторы ожидают нажатия клавиши с символом "А":

Repeat Writeln('Нажмите клавишу "А"'); c:=ReadKey until c='А';

В отличие от оператора Read оператор ReadKey не показывает на экране символ нажатой клавиши.

При нажатии на клавишу в буфер клавиатуры записывается соответствующий код, который считывается операторами Read/Readln либо функцией Readkey. При этом буфер клавиатуры очищается. При многократном нажатии на клавиши (без считывания программой символов) буфер клавиатуры переполняется и компьютер начинает "пищать". Для очистки буфера клавиатуры применяются операторы:

While KeyPressed Do c:=ReadKey;

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

PROGRAM FAM;

Uses CRT;

var N : word; f, dx, x, y, i, j, xm, ym : byte;

BEGIN

for i:=0 to 9 do begin { режимы работы монитора }

if i<4 then N:=i else N:=256+i-4; if i=9 then N:=7;

textMode(N);

xm:=lo(WindMax)+1; ym:=hi(WindMax)+1;

write('xm=',xm, '_ym=',ym, '_N=',N, '_Нажмите Enter'); readln;

TextBackGround(1); clrscr; TextColor(14); x:=1;

f:=8; dx:=3; { f - длина фамилии + курсор, dx - приращение отступа}

for j:=1 to ym-1 do begin y:=j;

if (xm-x-f)<0 then x:=1; { контроль выхода надписи за экран }

gotoXY(x, y); write('ФАМИЛИЯ'); x:= x + dx; end;

Writeln; write('Нажмите Enter'); readln end;

TextMode(3)

END.

1.14.3 Работа с символьными переменными

Следующие операторы позволяют выводить на экран символы, набираемые на клавиатуре, до нажатия клавиши Enter (код #13):

Repeat c:= readKey; Write(c) until c=#13;

здесь "с" - переменная типа Char, #13 - код клавиши Enter.

Часто используются клавиши с кодами: #32 - SpaceBar, #27 - Esc.

Для запоминания вводимых символов можно использовать операторы:

i:=0; repeat i:=i+1; ch[i]:=readKey; write(ch[i]) until ch[i]=#13;

Здесь ch[i] - элемент массива ch типа Char.

1.14.4 Работа со строковыми переменными

В программе "Бегущая строка" можно использовать переменные типа String. Для этого достаточно описать переменную "cha" типом String.

Для строковых переменных допускаются операции сложения, например, если s1:='Hello!', s2:='Привет!', то переменной s3:=s1+'_'+s2; присвоится значение: "Hello! Привет!" .

Сравнение строковых переменных происходит по символам, начиная с первого. Для приведенного выше примера выражение ( s1<>s2 ) верно.

Если код первого символа в первой строке больше, чем во второй, то первая строковая переменная считается больше второй. В данном примере выражение s1<s2 верно, т. к. значение кода "Н" меньше, чем "П".

Строковую переменную можно рассматривать как массив символов, например: s1[1]:='H' , s1[2]:='e'; и т. д.

Длина строковой переменной "L" содержится в элементе с нулевым индексом и может находиться оператором L:= Ord(s1[0]); или оператором L:= Length(s1);

Функция Copy(S,L1,L2); позволяет скопировать строковую переменную "S" в другую строковую переменную.

Где L1 - номер индекса первого копируемого символа,

L2 - число копируемых символов.

Например, для заданного ранее значения s1 переменная Sc:=Copy(s1,1,5); примет значение "Hello".

Процедура Delete(S,L1,L2); позволяет удалить из строки "S" часть символов.

Где L1 -номер индекса первого удаляемого символа,

L2 - число удаляемых символов.

Например, после действия оператора Delete(s1,6,1); переменная "s1" примет значение "Hello".

Процедура Insert(Si, S, L1); позволяет вставить в строку "S" строку "Si"

начиная с номера "L1" строки "S".

Здесь переменные L1, L2 - типа Integer.

1.14.5 Управление звуковыми сигналами

Sound(N); - включение звука с частотой тона N (измеряется в герцах).

Delay(M); - задержка выполнения программы на M миллисекунд.

NoSound; - выключение звука. Здесь N и M - типа Word.

Управление звуковым устройством компьютера осуществляется последовательностью операторов:

Sound(F); Delay(N); NoSound;

где F - частота звука в Гц.

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

F=Round(440*Exp(Ln(2)*(No-(10-Nn)/12)));

где No - номер октавы -3<= No <=4; Для основной октавы No=0.

Nn - номер ноты 1 - До, 2 - До#, 3 - Ре, и т. д. 12 - Cи.

При сквозной нумерации нот принять для No<0 - Nn<1, для No>0 - Nn>12.

1.15 Модуль Graph

1.15.1 Инициализация графического режима

Графический режим ПК существенно отличается от текстового как по принципам функционирования, так и по возможностям. Графика применяется практически во всех серьезных программных разработках, так как позволяет увидеть результаты расчетов в виде чертежей, графиков, иллюстраций в движении. Фирмой Borland разработана библиотека графических функций (Модуль Graph. tpu) как приложение к Turbo-пакетам фирмы Borland и графические драйверы - файлы *. bgi (Borland Graphics Interface ), обеспечивающие взаимодействие программ с графическими устройствами.

Подключение графической библиотеки при программировании в среде Turbo-Pascal производится оператором: Uses Graph;

Переход из текстового режима к графическому (инициализация графики) осуществляется оператором:

InitGraph(Gd, Gm, 'way');

где Gd - имя графического драйвера (параметр-переменная),

Gm - номер графического режима монитора (параметр-переменная),

'way' - дорожка DOS к файлам с графическими драйверами (*. bgi), например, C:\TP7\BGI .

Файлы графических драйверов принято хранить в поддиректории BGI. Если эти файлы располагаются в текущей директории, то дорожку DOS можно не указывать.

В графическом режиме изображение формируется из точек (пикселов) разных цветов. Количество точек на экране и число допустимых цветов можно задавать выбором подключаемого драйвера и номером графического режима. Вариации графических режимов весьма разнообразны, особенно для качественных мониторов. Например, адаптер IBM 8514 / A может обеспечить разрешение 1024 х768 точек и 256 цветов. Однако не все программные продукты рассчитаны на такие режимы.

Обычно драйверы подключаются в режиме автоопределения используемого монитора ПК. Для этого перед инициализацией графики задается Gd:= Detect; или Gd:= 0;. В этом случае по умолчанию устанавливается режим с наибольшим числом точек на экране, а значение параметра "Gm" игнорируется. Номер наибольшего режима для текущего драйвера возвращает функция GetMaxMode;.

Изменить режим можно процедурой SetGraphMode(Gm); где 0 =<Gm<= GetMaxMode. Экран при этом очищается.

1.15.2 Простейшие графические процедуры и функции

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

SetBkColor(N); - установить цвет "N" для пикселов фона.

По умолчанию установлен черный цвет фона.

SetColor(N); - установить цвет "N" для выводимых линий.

По умолчанию установлен белый цвет линий.

PutPixel(X, Y, N); - высветить цветом "N" пиксел с координатами X, Y.

Наибольшее значение параметра "N" возвращает функция GetMaxColor;. Цвет задается аналогично цветам текста в модуле Crt - можно использовать целое число или соответствующую константу, например, при N<16:

0 - Black, 1 - Blue, 15 - White. Режим мерцания в графике не предусмотрен.

Circle(X, Y, R); - построить окружность с центром X, Y и радиусом R.

Line(x1, y1, x2, y2); - построить отрезок прямой линии от точки с координатами x1, y1 к точке с координатами x2, y2.

Rectangle(x1, y1, x2, y2); - построить прямоугольник с левым верхним углом в точке с координатами x1, y1 и правым нижним углом в точке с координатами x2, y2 ( стороны параллельны краям экрана ).

GetPixel(X, Y); - функция возвращает цвет пиксела с координатами X, Y.

Координаты точек имеют тип Integer, остальные параметры - тип Word.

Значения координат задаются в пределах 0 X GetmaxX; 0 Y GetmaxY;

Перемещение курсора за пределы экрана игнорируется.

Очистить графический экран можно процедурами: ClearDevice; (без изменения установленных параметров), либо GraphDefaults; (устанавливаются параметры, принятые по умолчанию).

Рассмотрим пример фрагмента программы:

Uses Crt, Graph; { раздел описаний для фрагментов программ N1- N8 }

const N= 500;

var X, Y, Vx, Vy, P: array[1..N] of integer; ch: char;

Gd, Gm, Gx, Gy, x1, y1, x2, y2, xc, yc, dx, dy, r: integer;

i1, i2, zx, zy, ax, ay, i, k: integer;

begin { инициализация графики для фрагментов программ N1- N8 }

Gd:=Detect;

InitGraph(Gd,Gm,'C:\tp7\bgi');Randomize; Gx:=GetMaxX; Gy:=GetMaxY;

{-----------------------------------------------------------------

Фрагмент N 1 программы "небо в алмазах" ( рисование пикселов ).

----------------------------------------------------------------- }

SetColor(0); Repeat i:= 9 + random(7); xc:= random(Gx);

yc:= random(Gy);

PutPixel(xc, yc, i); Circle(xc, yc, 3) Until KeyPressed;

{---------------------------------------------------------------- }

While KeyPressed do ch:= ReadKey; { очистка буфера клавиатуры }

CloseGraph; end. { закончить работу в графическом режиме }

После инициализации графики определяются переменные Gx, Gy - максимальные значения координат по осям X, Y. Назначается черный цвет для линий, которые будут выводиться. Затем в цикле повторяется до нажатия любой клавиши высвечивание точек (пикселов) с номерами цвета "i" от 9 до 15 и координатами xc, yc. Значения координат точек и номеров цвета определяются из заданного диапазона функцией Random. Чтобы точки не "забивали" экран, некоторые из них "гасятся" окружностью радиусом 3 пиксела с центром в появившейся точке.

1.15.3 Рисование геометрических фигур

1.15.3.1 Построение заполненных фигур

Ряд графических процедур выполняет построение заполненных фигур - фигур с замкнутым контуром, автоматически заполняемых сразу после построения. По умолчанию заполнение производится сплошным белым цветом. Цвет и стиль (орнамент) заполнения можно устанавливать из стандартного набора BGI или определять самим.

SetFillStyle(P, N); - процедура установки орнамента P=0, 1, 12 и цвета с номером "N" для заполняемых фигур.

P = 0 - сплошное заполнение цветом фона, при этом значение "N" игнорируется,

P = 1 - сплошное заполнение цветом с номером "N",

P = 2. . . 11 - стандартный набор орнаментов BGI,

P = 12 - орнамент и цвет определяет пользователь.

SetFillPattern(PP, N); - процедура установки орнамента пользователя PP и цвета с номером "N" для заполняемых фигур.

Параметр PP имеет тип FillPatternType или array [1. . 8] of byte. Байт состоит из восьми битов и соответствует ряду из 8 пикселов, т. е. параметр РР определяет элемент орнамента размером 8*8 пикселов (восемь рядов по восемь пикселов). Если бит равен 1, то пиксел высвечивается заданным цветом, если бит равен 0 - текущим цветом фона.

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

Орнамент удобно задавать, используя переменные с начальным значением (типизированные константы), например:

{оператор описания:}

Const Bukva_Y: FillPatternType=($81,$C3,$66,$3C,$18,$18,$18,$18 );

{оператор выполнения:} SetFillPattern(Bukva_Y, 4);

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

Z:= A and B; - орнамент из совпадающих единичных частей исходных орнаментов,

Z:= A or B; - орнамент с добавлением единичных частей исходных орнаментов,

Z:= A xor B; - орнамент из несовпадающих единичных частей исходных орнаментов,

Z:= not A; - орнамент инверсный (обратный) к исходному орнаменту.

Z:= A xor A; - обнуление, Z:= A xor (not A); - сплошное заполнение орнамента.

Приведем процедуры построения заполненных установленным орнаментом фигур. Граница заполняемых фигур рисуется текущим цветом для линий.

Bar(X1, Y1, X2, Y2); - построить заполненный прямоугольник с заданными координатами левого верхнего (X1, Y1) и правого нижнего (X2, Y2) углов. Аналог процедуры: Rectangle(X1, Y1, X2, Y2);.

Bar3d(X1, Y1, X2, Y2, d, t); -построить параллелепипед с заполненной

передней гранью. Координаты углов: (X1, Y1), (X2, Y2), глубина "d". Переменная "t" типа boolean задает вывод верхней грани. При t=TopOn (true) верхняя грань показывается, при t=TopOff (false) - нет.

FillEllipse(X, Y, RX, RY); - построить заполненный эллипс с центром в точке (X, Y) и радиусами (полуосями): RX - по горизонтали, RY - по вертикали.

Sector(X, Y, A1, A2, RX, RY); - построить заполненный сектор эллипса.

A1 и A2 - начальный и конечный углы (в градусах), отсчитываемые против часовой стрелки относительно направления оси Х. Аналог процедуры: Ellipse(X, Y, A1, A2, RX, RY); строит сектор эллипса без автоматического заполнения.

PieSlice(X, Y, A1, A2, R); - построить заполненный сектор круга с центром в точке (X, Y) и радиусом R. Аналог процедуры: Arc(X, Y, A1, A2, R); строит дугу окружности.

FillPoly(N, M); - заполнить произвольную плоскую фигуру с границей, описанной массивом точек. N - число точек границы, М - параметр - переменная типа PointType, определяемая в модуле Graph в виде: TYPE PointType = Record x, y: Integer End; В программе массив можно описать операторами: Const N=100; Var M: array[1..N] of PointType;

Присвоение значений можно провести в цикле:

For i:=1 to 3 do begin M[i].x:=random(95); M[i].y:=random(95) end;

Приведем пример программы, выводящей два прямоугольника с орнаментами пользователя (bukva_Y и Red_50), а затем демонстрирующей набор стандартных орнаментов на передней грани параллелепипедов:

uses Graph; Сonst

bukva_Y: FillPatternType=($81, $C3, $66, $3C, $18, $18, $18, $18);

Red_50: FillPatternType=($AA, $55, $AA, $55, $AA, $55, $AA, $55);

var i, x1, y1, x2, y2, Gd, Gm : integer;

Begin Gd:= Detect; InitGraph(Gd, Gm, '_');

SetFillPattern(Red_50, Red); { орнамент - 50% красных пикселов }

Bar(250, 10, 350, 110);

SetFillPattern(bukva_Y, Blue); { орнамент - синяя буква "Y" }

Bar(340, 30, 440, 130);

{ стандартный набор из 12 орнаментов BGI выводим цветом с номером "11" }

for i:=0 to 11 do begin SetFillStyle(i, 11);

if i<6 then begin x1:=90*i; y1:=150 end

else begin x1:=90*(i-6); y1:=270 end;

x2:=x1+70; y2:=y1+80;

Bar3d(x1, y1, x2, y2, 10, TopOn) end;

ReadLn; CloseGraph

End.

Заполняя не черный экран орнаментом Red_50, можно получить новые цвета фона.

Выбранным из стандартных или определенным орнаментом можно заполнить любую замкнутую область с границей цвета "N" оператором FloodFill(X, Y, N);

Заполнение начинает производится из точки X, Y и ограничивается при достижении границы цвета с номером "N". Например: Rectangle(x1, y1, x2, y2); FloodFill((x1+x2) div 2, (y1+y2) div 2, Red); Если область не замкнута или цвет границы не равен "N", то заполнение "разольется" по экрану.

1.15.3.2 Работа с линиями

В графическом режиме курсор невидим, его положение можно определить функциями, возвращающими значения координат: GetX; - по оси "Х", GetY; - по оси "Y".

Следующие процедуры перемещают курсор без рисования:

MoveTo(x, y); - переместить курсор в точку с координатами (x, y),

MoveRel(dx,dy); - сместить курсор на расстояние dx, dy от текущего положения.

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

LineTo(x, y); - провести отрезок прямой линии от текущего положения курсора до точки с координатами X, Y.

LineRel(dX, dY); - провести отрезок прямой линии от текущего положения курсора до точки, смещенной на расстояние dX, dY по соответствующим осям.

В отличие от процедуры Line(x1, y1, x2, y2); процедуры LineTo(x, y); и LineRel(dX, dY); при своем исполнении перемещают текущий указатель.

Пример операторов для построения восьмиугольника:

R:=100; { расстояние от вершин до центра xc, yc }

xc:= GetMaxX div 2; yc:= GetMaxY div 2;

for i:= 1 to 8 do begin alfa:= i * pi/4; { значение угла в рад. }

x[i]:= xc + round(R * cos(alfa)); { координаты вершин }

y[i]:= yc + round(R * sin(alfa))

end;

MoveTo(x[8], y[8]); { исходная позиция для рисования }

for i:= 1 to 8 do LineTo(x[i], y[i]); { рисование линий }

Для отрезков прямых линий и процедур с их использованием можно задать режимы построения прямых линий оператором: SetWriteMode(N);

N=0 - замещение линией изображения на экране ( режим CopyPut ) используется по умолчанию,

N=1 - изображение комбинируется ( режим XorPut ). Работа функции состоит в изменении согласно логической операции "исключающее ИЛИ" исходного значения цвета пиксела (числа "1" или "0"). Логическая функция Xor, примененная к одной переменной дважды, восстанавливает ее исходное значение: ( J xor I ) xor I = J . Следовательно при повторном проведении линии в режиме XorPut изображение этой линии уничтожается, а цвет пикселов экрана становится исходным. На этом правиле основаны некоторые программы построения движущихся изображений.

Пример операторов для рисования движущегося прямоугольника:

SetWriteMode(1);

a:= 100; b:= 50; { стороны прямоугольника }

x1:= 0; y1:= GetMaxY div 2;

N:= GetMaxX - x1 - a; { N - число перемещений }

for i:= 0 to N do begin

Rectangle(x1+i, y1, x1+a+i, y1+b); { рисование прямоугольника }

delay(10); Rectangle(x1+i,y1,x1+a+i,y1+b);{стирание прямоугольника}

end;

1.15.3.3 Создание графических узоров

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

Рассмотрим некоторые из принципов составления узоров на плоскости:

1. Перемещение фигуры.

Если фигуру перемещать не вращая относительно своего "центра", то получим плоскопараллельное движение тела (любой отрезок прямой на фигуре остается параллельным самому себе). За "центр" фигуры может быть принята любая точка жестко связанная с фигурой. Обычно "центр" фигуры (xf, yf) перемещают относительно центра узора (xc, yc) по определенному закону.

Приведем пример задания закона движения "центра" фигуры относительно центра узора:

for i:= 1 to Nc do begin

alfa:=2 * pi * i/Nc; { угол поворота "центра" фигуры }

Lx:= FLx(i); Ly:= FLy(i); { функции расстояний }

R:= FR(i); S:= FS(i); { функции радиуса и цвета окружности }

xf:= xc + round(Lx * cos(alfa)); { координаты "центра" фигуры }

yf:= yc + round(Ly * sin(alfa));

SetColor(S); Circle(xf, yf, R) end;

В этом фрагменте Nc - раз рисуется окружность с центром, поворачивающимся на угол alfa вокруг центра узора. Расстояние от центра i-й окружности до центра узора задается функциями Flx( i ), Fly( i ), радиус окружности - функцией FR( i ), цвет - функцией FS( i ). Подбором этих функций и числа окружностей Nc можно добиться разнообразных декоративных эффектов. Вместо окружностей можно строить любые фигуры, используя процедуры их рисования с заданием "центра" фигуры и других параметров в системе координат экрана.

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

xxi = xf + Kxi * ((xi-xf) * cos(A) - (yi-yf) * sin(A)),

yyi = yf + Kyi * ((yi-yf) * cos(A) + (xi-xf) * sin(A)),

где A - угол поворота фигуры относительно своего "центра", отсчитываемый в левой системе координат экрана по часовой стрелке относительно оси X,

xi, yi - исходные координаты i -ой точки фигуры,

xxi, yyi - новые координаты i -ой точки фигуры,

Kхi, Kyi - коэффициенты масштабирования координат i -ой точки по осям Х и Y.

Приведем пример задания закона движения линии относительно своего "центра":

for j:= 1 to Nf do begin

A:= 2 * pi * j/Nf; { угол поворота линии вокруг своего "центра" }

Kx1:= FKx1(j); Ky1:= FKy1(j); Kx2:= FKx2(j); Ky2:= FKy2(j);

{ координаты 1-ой точки фигуры }

xx1:= xf + round(Kx1 * ((x1-xf)*cos(A) - (y1-yf)*sin(A)));

yy1:= yf + round(Ky1 * ((y1-yf)*cos(A) + (x1-xf)*sin(A)));

{ координаты 2-ой точки фигуры }

xx2:= xf + round(Kx2* ((x2-xf)*cos(A) - (y2-yf)*sin(A)));

yy2:= yf + round(Ky2* ((y2-yf)*cos(A) + (x2-xf)*sin(A)));

SetColor(14); line(xx1, yy1, xx2, yy2); delay(100);

end;

x1, y1, x2, y2 - исходные координаты точек фигуры,

xx1, yy1, xx2, yy2 - координаты 1-ой и 2-ой точек фигуры на i-ом шаге рисования.

В этом фрагменте многократно (Nf - раз) рисуется линия, вращающаяся на угол "A” относительно своего центра xf, yf. Фигура может искажаться (деформироваться), если не соблюдаются равенства: Fkx1( j)= Fky1( j)= Fkx2( j)= Fky2( j)= K= 1.

Если центр узора перемещается, то изменение его координат необходимо задать во внешнем цикле.

1.15.3.4 Работа с текстом в графическом режиме

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

OutText(S); - вывод строки S (типа string) в текущей позиции курсора.

OutTextXY(x,y,S); - вывод строки S в позиции с координатами (x, y).

Строку S можно определять явно в виде символов, заключенных в апострофы, например, OutText('Sample 1');, или как переменную (константу) типа string. Если требуется вывести значение переменной числового типа, то необходимо приме-нить процедуру ее преобразования в строковый тип. Например: Str(x:10:5,S); - определяем переменную "S" (типа string), полученную преобразованием переменной "x" (вещественного типа) по указанному формату.

Перечислять несколько переменных через запятые (подобно параметрам функций write и writeln) в графических функциях вывода текста не допускается. При выводе нескольких строковых переменных они соединяются знаком "+" , например: OutText('x='+ S);

Для установки стиля вывода текста используется процедура

SetTextStyle(F, D, Z);

где F - номер шрифта, D - направление вывода надписи, Z - увеличение размера относительно базового варианта. Параметры F, D, Z - типа Word.

Шрифт в графическом режиме может создаваться двумя методами. В первом типе шрифта - матричном, берется стандартный шрифтовой набор BIOS ПК, где каждому символу соответствует матрица 8*8 пикселов. Матричный шрифт используется по умолчанию. Изменение размера матричного шрифта производится увеличением исходной матрицы в N-раз: 8N*8N пикселов. При увеличении размера явно проявляется "грубость" матричного шрифта.

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

В стандартном наборе BGI определено:

F = 0 (DefaultFont) - 8х8 пикселов - матричный шрифт, векторные шрифты:

F = 1 (TriplexFont) - триплекс (полужирный),

F = 2 (SmallFont) - уменьшенный,

F = 3 (SansSerifFont) - прямой (книжный),

F = 4 (GothicFont) - готический.

Направление шрифта: D= 0 - по горизонтали слева направо,

D= 1 - по вертикали снизу вверх, символы повернуты на 90⁰.

Увеличение размера Z варьируется от 1 до 31 для матричного шрифта и от 1 до 10 для векторных шрифтов. Причем базовый размер соответствует для матричного шрифта Z= 1, для векторного шрифта Z= 4. При Z= 0 базовый размер устанавливается по умолчанию.

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

SetUserCharSize(XN, X, YN, Y);

При этом (XN/X) - множитель для изменения ширины символов, (YN/Y) - множитель для изменения высоты символов. Параметры XN, X, YN, Y - типа Word.

Текст можно выравнивать относительно позиции его вывода с помощью процедуры

(0,2) (1,2) (2,2)

SetTextJustify(H, V); * * *

(0,1)*_ЦЕНТРИРУЕМЫЙ ТЕКСТ*(2,1)

* * *

Выравнивание по горизонтали: (0,0) (1,0) (2,0)

H = 0 - текст справа от позиции вывода, В скобках указаны значения H, V.

H = 1 - центрирование текста,

H = 2 - текст слева от позиции вывода.

Выравнивание по вертикали:

V = 0 - текст выше позиции вывода,

V = 1 - центрирование текста,

V = 2 - текст ниже позиции вывода.

По умолчанию установлено H= 0, V= 2.

Длину строки S (в пикселах) можно определить функцией TextWidth(S);

Высота строки S определяется функцией TextHeight(S);

Если строка не помещается в области экрана, то в случае матричного шрифта эта строка не выводится, а для векторных шрифтов часть строки отсекается.

Цвет текста в графике устанавливается процедурой SetColor(N); где N-номер цвета.

{ -------- Пример программы, демонстрирующей различные шрифты: --------- }

uses Graph;

var Gd, Gm, k, X, Y, Size: integer; S: string;

begin

Gd:= Detect; InitGraph(Gd, Gm, 'c:\tp7\bgi');

X:= 0; Y:= 0; { начальные координаты вывода текста }

for Size:= 1 to 10 do begin k:= 0; { перебор размеров шрифта }

SetTextStyle(k,0,Size); Str(Size,S);{ пишем матричным шрифтом }

OutTextXY(X, Y, 'Size=' + S);

Y:= Y + TextHeight('S') + 1 { смещение по "Y" на высоту буквы "S" }

end;

Readln; ClearDevice;

SetTextJustify(1,2); { выравнивание по центру }

for k:= 1 to 4 do begin { пишем векторными шрифтами }

Y:= 0; SetColor(k+8);

for Size:=1 to 10 do begin { перебор размеров шрифта }

SetTextStyle(k, 0, Size); Str(Size, S);

OutTextXY( GetmaxX div 2, Y, 'Size='+S);

Y:= Y + TextHeight('S') + 1;

end;

Readln; ClearDevice

end; CloseGraph

end.

1.15.5 Мультипликация

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

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

1.15.5.1 Мультипликация с запоминанием части экрана

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

Size: = ImageSize(X1, Y1, X2, Y2); {тип Word}

Параметры функции ImageSize определяют границу прямоугольной области графического экрана подобно процедуре Rectangle. Функция определяет число байт для хранения этой области. Этот размер можно также вычислить по формуле :

(X2-X1+1)*(Y2-Y1+1). Размер отводимой памяти должен быть меньше 64 Кбайт.

Далее определяем параметр P (типа pointer), который будет содержать начальный адрес области памяти ( буфера) размером "Size", отводимый для хранения двоичного образа прямоугольной области экрана процедурой: GetMem(P, Size);

Сохраняем двоичный образ прямоугольной области в ОЗУ (буфере) процедурой: GetImage(X1, Y1, X2, Y2, P^);

Сохраненный массив пикселов можно выводить на экран из буфера процедурой: PutImage(X, Y, P^, N);

Здесь X, Y - позиция вывода верхнего левого угла прямоугольной области,

P^ - обозначает содержимое буфера с начальным адресом "Р",

N - режим вывода:

N = 0 (CopyPut) - замена изображения на экране изображением из буфера.

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

N = 1 ( XorPut) - "исключающее ИЛИ" (результат равен 1, если значения битов различны),

N = 2 ( OrPut) - "ИЛИ" (результат равен 1, если один из битов равен 1),

N = 3 ( AndPut) - " И " (результат равен 1, если оба бита равны 1),

N = 4 ( NotPut) - " НЕ" (замена изображения на экране инверсным изображением из буфера).

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

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

Освобождение (очистка) участков памяти размером "Size", начиная с адреса, заданного параметром "Р", производится процедурой: FreeMem(P, Size);

Значения P и P^ после этого не определены.

Приведем пример программы - мультипликации с использованием процедур GetImage, PutImage, в режиме вывода XorPut:

uses Graph, Crt;

var Gd, Gm, i, j, k, Size, x, y, Xmax, Ymax: Integer;

P1, P2: Pointer; { тип указатель }

Begin

Gd := VGA; Gm:=2; InitGraph(Gd, Gm, 'c:\tp7\bgi');

Size := ImageSize(0, 0, 20, 100); { размер области }

SetLineStyle(0, 0, 3); { рисуем толстыми линиями }

PieSlice(10, 10, 0, 360, 10); { заполненный круг }

FillEllipse(10, 40, 10, 20); { заполненный эллипс }

Line(8, 60, 0, 100); Line(12, 60, 20, 100); { линии }

{ первый образ }

PieSlice(60, 10, 0, 360, 10);

FillEllipse(60, 40, 10, 20);

Line(60, 60, 60, 100);

{ второй образ }

GetMem(P1, Size); { P1 - указатель адреса для хранения первого образа}

GetImage(0, 0, 20, 100, P1^);{P1^ - содержимое (двоичный код) образа}

GetMem(P2, Size); { P2 - указатель адреса для хранения второго образа}

GetImage(50, 0, 70, 100, P2^);{P2^ - содержимое (двоичный код) образа }

x:=0; y:=200; { координаты начальной точки }

Readln; ClearDevice; Line( 0, 300, 600, 300); { "дорога" }

Repeat { имитация движения чередованием образов со смещением }

PutImage(x, y, P1^, 1); delay(50); PutImage(x, y, P1^, 1);

x:=x+10; { смещаем позицию на полшага }

PutImage(x, y, P2^, 1); delay(50); PutImage(x, y, P2^, 1);

x:=x+10

Until x > GetmaxX - 20; { достижение края }

FreeMem(P1, Size); FreeMem(P2, Size); CloseGraph

End.

В приведенной программе в память заносятся два образа человечка с разным положением ног. Экран очищается и в цикле происходит поочередное извлечение образов со смещением по оси "х". Каждое изображение хранится на экране 0, 05 с., затем исчезает, вследствие перерисовки в режиме XorPut.

1.15.5.2 Мультипликация с чередованием видеостраниц

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

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

Страницы переключаются для просмотра на экране процедурой: SetVisualPage(N); где N - номер страницы. По умолчанию видна и активна страница с N=0.

Страница активизируется для рисования процедурой: SetActivePage(N);

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

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

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

k:= 2; { количество кодовых страниц }

Repeat

for i:= 1 to 100 do

begin j:= i mod k; { j - номер кодовой страницы }

SetActivePage(j); { активизируем страницу без ее показа }

ClearDevice; { стираем старый рисунок }

SetfillStyle(1, i div 15 +1); { изменение цвета заполнения через 15 стр. }

Bar(1, 1, i+10, i+5); { строим новый рисунок }

SetVisualPage(j); delay(40) { показываем страницу }

end

Until KeyPressed;

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

1.15.5.3 Мультипликация с управлением движения образа

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

dx:= 1; dy:= 1; { пошаговые перемещения по осям X и Y }

x:= 100; y:= 100; { начальные координаты смещаемого образа }

Xmax:= GetMaxX; Ymax:= GetMaxY;

Repeat

PutImage(x, y, P1^, 1); { выводим образ (запомненный ранее в P1^) }

xold:= x; yold:= y; { запоминаем координаты }

c:= readkey; { считываем код клавиши в переменную типа char }

if c = #0 then c:= readkey;

case c of { анализируем код нажатой клавиши }

#72: if y > 1 then y:= y - dy; { смещение вверх }

#75: if x > 2 then x:= x - dx; { смещение влево }

#80: if y < Ymax-100 then y:= y + dy; { смещение вниз }

#77: if x < Xmax-20 then x:= x + dx end; { смещение вправо }

PutImage(xold, yold, P1^, 1) {стираем образ }

Until c = #27; { при нажатии клавиши Esc перемещение прекратится }

1.15.5.4 Модификация контурного изображения

В производстве мультфильмов широко используется следующий метод анимации (плавной модификации контурного изображения):

1. Задается массив координат узловых точек исходного (начального) контурного изображения (X1[1. . N], Y1[1. . N]). Соединяя определенным образом эти точки отрезками прямых, получаем изображение.

2. Задается массив координат узловых точек целевого (конечного) контурного изображения (X2[1. . N], Y2[1. . N]). Количество точек одинаково для обоих массивов.

3. Плавной модификацией исходного образа получаем целевое изображение. Для этого последовательно находятся наборы координат X[1. . N], Y[1. . N] промежуточных образов. Каждую i-точку промежуточного образа выбирают на отрезке прямой между соответствующими точками исходного и целевого контуров, т. е. между точкой (X1[i], Y1[i]) и точкой (X2[i], Y2[i]). Таким образом отрезок делится на "m" частей, где m - количество промежуточных образов, включая целевой. Промежуточные образы перерисовывают, постепенно удаляясь от исходного образа.

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

x[i]:= x1[i] + (x2[i] - x1[i])*k/m;

y[i]:= y1[i] + (y2[i] - y1[i])*k/m;

где k - номер промежуточного образа,

m - количество делений отрезка.

Перерисовку образов удобно делать двойным рисованием в режиме SetWriteMode(1), либо используя процедуры работы с видеопамятью в режиме XorPut. Задержка видимости образа (delay) определяет скорость преобразования. В приведенной ниже демонстрационной программе задается исходный контур из 12 точек X1[i], Y1[i] - координаты узлов на квадрате, а целевой контур из 12 точек X2[i], Y2[i] - координаты вершин звезды.

uses Graph, Crt;

var Gd, Gm, i, j, k, n, xc, yc, r, m: integer;

x, y, x1, y1, x2, y2: array[1..12] of integer; alfa: real;

begin

Gd:=Detect; InitGraph(Gd, Gm, ''); SetWriteMode(1);

{ координаты узлов на квадрате - исходной фигуры: }

for i:=7 to 10 do begin x1[i]:= 10; y1[i]:= 10+(i-7)*40 end;

for i:=1 to 4 do begin x1[i]:=130; y1[i]:=130-(i-1)*40 end;

x1[11]:= 50; x1[12]:= 90; y1[11]:=130; y1[12]:=130;

x1[ 6]:= 50; x1[ 5]:= 90; y1[ 5]:= 10; y1[ 6]:= 10;

{ координаты узлов на звезде - целевой фигуры: }

xc:= 500; yc:= 300; { центр звезды }

for i:= 1 to 12 do begin alfa:= (1-i)*(2*pi)/12;

if (i mod 2)=0 then r:=30 else r:=100;

x2[i]:= xc + round(r*cos(alfa));

y2[i]:= yc + round(r*sin(alfa))

end;

m:= 60; { координаты узлов на промежуточных образах: }

for k:= 0 to m do begin

for i:=1 to 12 do begin x[i]:=x1[i]+round((x2[i]-x1[i])*k/m);

y[i]:=y1[i]+round((y2[i]-y1[i])*k/m)

end;

for j:= 1 to 2 do begin { перерисовка промежуточных образов }

moveto(x[12], y[12]);

for i:= 1 to 12 do LineTo(x[i], y[i] );

if j = 1 then delay(40)

end

end;

readln; CloseGraph

end.

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

2. Программирование в среде Турбо - Паскаль

2.1 Геометрические построения на плоскости

2.1.1 Построение графиков функций

Проведение численных расчетов желательно сопровождать визуализацией промежуточных и окончательных результатов на экране монитора. Это позволяет избежать некоторых ошибок, а также контролировать результаты расчета и оптимизировать алгоритм. Графики функций строятся обычно в декартовой системе координат (XoY). Функция может быть задана в явном виде, например, y=F(x), в неявном: F(x, y)=0, или в параметрическом виде: x=Fx(t), y=Fy(t).

Здесь F(x), F(x, y), Fx(t), Fy(t) - функции, x, t - аргументы (параметры).

Значения "x", "y" , полученные в результате расчета, будем называть расчетными координатами точек. При построении графика на экране монитора расчетные значения "x", "y" необходимо пересчитать в графические (экранные) координаты xG, yG. Напомним, что графические координаты изменяются в пределах [0 . . GetMaxX] - по горизонтали, [0 . . GetMaxY] - по вертикали.

Для изменения графических координат экрана в Турбо-Паскале предусмотрено задание графического окна процедурой:

SetViewPort(xG1, yG1, xG2, yG2, Cl);

где (xG1, yG1), (xG2, yG2) - координаты левого верхнего и правого нижнего вершин прямоугольника, образующего графическое окно (тип Integer).

Cl - признак рисования за границами окна (тип Boolean) задается в модуле Graph константами: ClipOn = True - рисование только в пределах окна, ClipOff= False - рисование в пределах экрана.

...