курсовые,контрольные,дипломы,рефераты
Модуль Graph
Модуль Graph представляет собой библиотеку подпрограмм, обеспечивающую полное управление графическими режимами различных адаптеров дисплеев: CGA, EGA, VGA и т.д. Библиотека содержит более пятидесяти графических процедур и функций, как базовых (рисование точек, линий, окружностей и т.п.), так и расширяющих возможности базовых (многоугольники, заполнение фигур, вывод текста и др.).
Чтобы запустить программу, использующую процедуры модуля Graph , необходимо, чтобы в рабочем каталоге находились соответстственно графические драйверы (файлы с расширением .BGI), а если программа использует еще и штриховые шрифты, то необходимо, чтобы там же находились файлы шрифтов (с расширением .CHR).
Кроме того, системе программирования (компилятору) должен быть доступен модуль GRAPH.TPU (он не входит в состав файла TURBO.TPL, а изначально находится в архиве BGI.ARC).
Файлы BGI и содержимое модуля Graph
Файл BGI - это графический интерфейс (Borland Graphic Interface) фирмы Borland. Он обеспечивает взаимодействие программ с графическими устройствами. Перед работой программы в графических режимах дисплея процедура InitGraph определяет тип адаптера, представленного в ПК, и загружает в память соответствующий BGI-драйвер, в котором определены возможные режимы работы.
Процедура CloseGraph выгружает графический драйвер из памяти и восстанавливает текстовый режим работы видеоадаптера. В описываемом модуле присутствуют также процедуры, позволяющие выходить из графического режима без выгрузки драйвера (RestoreCRTMode) и возвращаться обратно (SetGraphMode).
Итак, в рабочем каталоге могут находиться следующие файлы:
| CGA.BGI | - драйвер для IBM CGA, MCGA; |
| EGAVGA.BGI | - драйвер для IBM EGA, VGA; |
| HERC.BGI | - драйвер для Hercules; |
| ATT.BGI | - драйвер для АТ&Т6300 (400 строк); |
| PC3270.BGI | - драйвер для IBM 3270PC; |
| IBM8514.BGI | - драйвер для IBM 8514. |
Такой набор файлов необходим при составлении программ, которые будут работать практически на всех ПК, совместимых с ПК фирмы IBM. Если же такая задача не стоит, то достаточно иметь один файл, соответствующий представленному в используемом ПК графическому адаптеру.
Все процедуры и функции модуля Graph можно разбить на функциональные группы:
1) Управление графическими режимами и их анализ (DetectGraph, InitGraph, CloseGraph, GraphDefaults, ClearDevice, InstallUserDriver, RegisterBGIDriver, RestoreCRTMode, SetGraphMode, SetWrifeMode, GetGraphMode, GetModeRange, GetMaxMode, GetModeName, GetDriverName, GraphResuIt,, GraphErrorMsg).
2) Рисование графических примитивов и фигур:
a) управление «текущим указателем» (MoveTo, MoveRel, GetMaxX, GetMaxY, GetX, GetY);
b) собственно рисование (Line, LineTo, LineRel, Arc, GetArcCoords, Circle, Sector, Ellipse, Rectangle, DrawPoly);
c) стиль линий и коэффициент сжатия изображения (SetLineStyle, GetLineSettings, SetAspeclRatio, GetAspectRatio).
3) Управление цветами и шаблонами заполнения (SetColor, GetColor, SetBkColor, GetBkColor, GetMaxColor, GetPalette, GetPaletteSize, GetDefaultPalette, SetPalette, SetAllPalette, SetRGBPalette, SetFillStyle, SetFillPattern, GetFillPattern, GetFillSettings, SetGraphBufSize, FillPoly, FillEIIipse, FloodFill, PicSlice, Bar, Bar3D).
4) Битовые операции (PutPixel, GetPixel, ImageSize, Getlmage, Putlmage).
5) Управление страницами (SetActivePage, SetVisualPage).
6) Графические окна (вьюпорты) (SetViewPort, GetViewSettings, ClearViewPort).
7) Управление выводом текста (RegisterBGIFont, lnstallUserFont, OutText, OutTextXY, SetTextStyle, SetTextJustify, SetUserCharSize, GetTextSettings, GetTextHeight, TextWidth).
Управление графическими режимами. Инициализация и закрытие графического режима
Процедура инициализации InitGraph. Простейшая программа, использующая графику, обязательно должна содержать блок вызова процедур инициализации графического режима и обращение к процедуре его закрытия. Такой блок инициализирует режим, проверяет правильность переключения и, если все операции прошли успешно, допускает дальнейшую работу программы. Процедура инициализации объявлена следующим образом:
InitGraph (VAR GraphDriver; {тип адаптера}
VAR GraphMode Integer; {режим графики}
DriverPath: String); {путь к драйверу}
В модуле Graph определены константы для задания вида адаптера параметром GraphDriver перед вызовом InitGraph(последняя константа введена для вызова процедуры GetModeRange уже после инициализации).
| Detect | = 0; | { автоопределение} |
| CGA | = 1; | {адаптер CGA} |
| HCGA | = 2; | {адаптер MCGA} |
| EGA | = 3; | { адаптер EGA 256K} |
| EGA64 | = 4; | { адаптер EGA 64K} |
| EGAMono | = 5; | { EGA с моно - дисплеем} |
| IBM8514 | = 6; | { адаптер 8514} |
| НегсМопо | = 7; | { адаптер Hercules} |
| АTT400 | = 8; | { для ПЭВМ AT&T} |
| VGA | = 9; | { адаптер VGA} |
| РС3270 | = 10; | { адаптер 3270} |
| CurrentDriver | =-128; | { для GetModeRange} |
Если параметру GraphDriver присвоить значение константы Detect система включится в режим автоопределсиия. Если возможно переключение системы в графический режим, то инициализируется соответствующий BGI-драйвер и включается режим с максимальным разрешением. В параметрах GraphDriver и GraphMode при этом будут возвращены автоматически выбранные значения или код ошибки.
Такая установка параметров процедуры рекомендуется в тех случаях, когда программа должна работать на разных ПК с различными видеоадаптерами. Однако этот метод предполагает наличие в памяти ПК или на диске одновременно всех драйверов. Если программа большая, то наличие всех драйверов в памяти может вызвать затруднения.
Если же параметр GraphDriver содержит номер конкретного адаптера, то и второй параметр, GraphMode, должен иметь значение (номер) режима, допустимого при этом адаптере.
Все остальные графические установки (положение текущего указателя, палитра, цвет, параметры графического окна и т.д.) при инициализации принимаются по умолчанию.
Параметр DriverPath указывает путь в каталог, содержащий файлы с необходимыми драйверами. Если в него передается значение " (пустая строка), то драйверы должны находиться в текущем каталоге. Это же значение должно передаваться DriverPath, если необходимые BGI-файлы преобразованы при помощи утилиты BINOBJ в файлы типа .OBJ, а затем скомпонованы с программой в ЕХЕ-файл.
Процедура CloseGraph. Для окончательного завершения работы в графическом режиме необходимо всегда производить вызов процедуры CloseGraph. Эта процедура не имеет параметров. Она очищает экран, переводит адаптер в текстовый режим и, если возможно, выгружает из памяти все BGI-драйверы и штриховые шрифты. Последующий возврат в графические режимы возможен только через повторную инициализацию.
Обработка ошибок инициализации
Процедура InitGraph возвращает также и результат своей работы в параметре GraphDriver. В случае ошибки он может принимать значения, приведенные в таблице.
| Значение | Объяснение |
| -2 | Нет графического адаптера |
| -3 | Не найден файл драйвера |
| -4 | Ошибка в драйвере (в его коде) |
| -5 | Не хватает памяти для загрузки драйвера |
| -10 | Невозможный режим для выбранного драйвера |
| -15 | Нет такого драйвера |
Если же ошибок при инициализации не обнаружено, то в параметре GraphDriver возвращается номер адаптера из приведенного выше списка констант.
В модуле Graph реализован еще один способ проверки результата проведения графической операции. Он осуществляется с помощью функции
GraphResult: Integer
Эта функция возвращает код результата последнего вызова одной из процедур или функций, указанных в таблице.
Bar Bar3D ClearViewPort CloseGraph DetectGraph DrawPoly FillPoly FloodFill GetGraphMode |
ImageSize InitGraph InstallUserDriver InstallUserFont PieStice RegisterBGIdriver RegisterBGIfont SetAllPalette |
SetFillPattern SetFillStyle SetGraphBufSize SetGraphMode SetLineStyle SetPalette SetText Justify SetTextStyle |
Таблица кодов, возвращаемых GraphResult, и расшифровка их содержания приведена при описании функции GraphErrorMsg, т.к. обычно эти функции используются совместно. После одного вызова GraphResult следующий ее вызов даст нулевое значение, поэтому для дальнейшего использования результатов тестирования рекомендуется сохранять значение этой функции в какой- либо переменной.
Для быстрой выдачи простого сообщения о типе ошибки графической системы используется функция, преобразующая результат вызова функции GraphResult в сообщение, которое можно вывести процедурой Write. Эта функция объявлена как:
GraphErrorMsg (ErrorCode: Integer): String;
Константы кодов ошибок, определенные в модуле Graph,и соответствующие им сообщения приведены в следующей таблице.
| Константа | Код | Сообщение об ошибке | Перевод и пояснение |
| grOk | 0 | No error | Ошибки нет |
| grNoInitGraph | -1 | (BGI) Graphics not installed (use InitGraph) | Графика не инициализирована |
| grNotDetected | -2 | Graphics hardware not detcted | Графический адаптер не найден |
| grFileNotFound | -3 | Device driver file not detected | BGI -файла нет в указанном каталоге |
| grlnvalidDriver | -4 | Invali device driver file | BGI-файл содержит ошибочный код |
| grNoLoadMem | -5 | Not enough memory to load driver | Нет места в ОЗУ для загрузки драйвера |
| grNoScanMem | -6 | Out of memory in scan fill | При работе процедуры FillPoly не хватает рабочей памяти |
| grNoFloodMem | -7 | Out of memory in flood fill | При работе процедуры FloodFill не хватает рабочей памяти |
| grFontNotFound | -8 | Font file not found | CHR -файла нет в указанном каталоге |
| grNoFontMem | -9 | Not enough memory to load font | Нет места в ОЗУ для загрузки шрифта |
| grlnvalidMode | -10 | Invalid Graphics mode for selected driver | Невозможный режим для выбранного драйвера |
| grError | -11 | Graphics error | Ошибка графики |
| grIOError | -12 | Graphics I/O error | Ошибка ввода-вывода графики |
| grInvalidFont | -13 | Invalid font fite | В файле шрифта неправильный код |
| grInvalidFontNum | -14 | Invalid font number | Несуществующий номер шрифта |
| grInvalidDeviceNum | -15 | Invalid device number | Несуществующий номер адаптера |
Простейший блок инициализации графического режима в программе может выглядеть, как показано в следующем примере.
Uses Graph;
Procedure GrInit;
Var
GraphDriver: Integer;
GraphMode: Integer;
ErrorCode: Integer;
Begin
GraphDriver: =Detect;
InitGraph (GraphDriver, GraphMode, '');
ErrorCode: =GraphResult;
if ErrorCode <> grOK then
begin
Writeln (‘Ошибка графики: ‘, GraphErrorMsg (ErrorCode));
Writeln(‘Программа остановлена...');
Halt(1);
end;
Begin {Пример инициализации}
GrInit;
Line (0, 0, GetMaxX, GetMaxY);
Readln;
CloseGraph;
End.
В дальнейшем процедуру Grlnit лучше записать в отдельный файл (например, INITGRAF.PAS) и использовать директиву включения этого файла при компиляции. Такой блок всегда включает стандартный графический режим максимального разрешения.
Возможные графические режимы для различных адаптеров приведены в таблице. Во втором столбце приведены имена предопределенных констант, которые можно передавать в процедуры, управляющие графическими режимами. Последний столбец показывает количество полноэкранных изображений, которые могут храниться в памяти видеоадаптера одновременно.
| Драйвер | Имя константы режима и ее значение | Разрешение экрана (в точках) | Палитра | Число видеостраниц |
| CGA | CGAC0 = 0 | 320x200 | 4 цвета | 1 |
| CGAC1 = 1 | 320x200 | 4 цвета | 1 | |
| CGAC2 = 2 | 320x200 | 4 цвета | 1 | |
| CGAC3 = 3 | 320x200 | 4 цвета | 1 | |
| CGAHi = 4 | 640x200 | 2 цвета | 1 | |
| MCGA | MCGAC0 = 0 | 320x200 | 4 цвета | 1 |
| MCGAC1 = 1 | 320x200 | 4 цвета | 1 | |
| MCGAC2 = 2 | 320x200 | 4 цвета | 1 | |
| MCGAC3 = 3 | 320x200 | 4 цвета | 1 | |
| MCGAMed= 4 | 640x200 | 2 цвета | 1 | |
| MCGAHi = 5 | 640x480 | 2 цвета | 1 | |
| EGA | EGALo = 0 | 640x200 | 16 цветов | 4 |
| EGAHi = 1 | 640x350 | 16 цветов | 2 | |
| EGA64 | EGA64Lo = 0 | 640x200 | 16 цветов | 1 |
| EGA64Hi = 1 | 640x350 | 4 цвета | 1 | |
| EGAMono | EGAMonoHi = 3 | 640x350 | 2 цвета | 1(2) |
| Herc | HercMonoHi = 0 | 720x348 | 2 цвета | 2 |
| АТТ | АТТ400С0 = 0 | 320x200 | 4 цвета | 1 |
| АТТ400С1 = 1 | 320x200 | 4 цвета | 1 | |
| АТТ400С2 = 2 | 320x200 | 4 цвета | 1 | |
| АТТ400СЗ = 3 | 320x200 | 4 цвета | 1 | |
| ATT400Med = 4 | 640x200 | 2 цвета | 1 | |
| АТТ400Нi= 5 | 640x400 | 2 цвета | 1 | |
| VGA | VGALo = 0 | 640x200 | 16 цветов | 4 |
| VGAMed = 1 | 640x350 | 16 цветов | 2 | |
| VGAHi = 2 | 640x480 | 16 цветов | 1 | |
| PC3270 | PC3270Hi = 0 | 720x350 | 2 цвета | 1 |
| IBM8514 | IBM8514Lo = 0 | 640x480 | 256 цветов | 1 |
| IBM8514= 1 | 1024x768 | 256 цветов | 1 |
Для того чтобы полностью использовать возможности установленного в ПК адаптера, необходимо воспользоваться инструкцией по работе с ним.
Процедура DetectGraph. Для тестирования графического адаптера в модуле Graph объявлена процедура:
DetectGraph (VAR GraphDriver, GraphMode: Integer)
Эта процедура может быть вызвана до инициализации графики. Через формальный параметр GraphDriver возвращается значение из первого столбца таблицы указанной выше таблицы, а через параметр GraphMode - обычно последнее значение из соответствующего раздела второго столбца. Эти значения и рекомендуется подставлять в качестве фактических параметров в процедуру InitGraph. После определения GraphDriver автоматически становится доступным диапазон графических режимов, реализуемых адаптером
Существует возможность манипуляции режимами работы графического адаптера - при помощи группы процедур и функций, но уже после инициализации графики. Но часто бывает важным сначала определить разрешенные значения режимов.
Диапазоны графических режимов. Номер текущего графического режима для установленного драйвера определяется функцией
GetGraphMode: Integer,
Функция
GetMaxMode: Word
возвращает номер максимального режима для графического адаптера; таким образом, каждый драйвер поддерживает диапазон режимов 0...GetMaxMode. Обычно этот же результат можно получить из процедуры
GetModeRange (GraphDriver: Integer; VAR LoMode, HiMode: Integer),
через параметры LoMode и HiMode, возвращающей соответственно нижнюю и верхнюю границу режимов для драйвера GraphDriver. Но по ряду технических соображений предпочтительнее пользоваться функцией GetMaxMode, полагая минимальный номер режима равным нулю.
Функции GetModeName и GetDriverName.
GetModeName (GraphMode: Word): String. Функция возвращает строку, в которой содержится последовательно через пробелы разрешение, имя константы и иногда название палитры, например, '640x200 CGA'. Представленный пример поможет определить, в каких графических режимах может работать используемая ПЭВМ.
| USES Graph; | {подключен модуль Graph} |
| {$I initgraf.pas} | { процедура инициализации} |
| VAR | |
| mode: Integer; | |
| BEGIN | |
| Grlnit; | { инициализация} |
| for mode := 0 to GetMaxMode do | { показ всех режимов } |
| OutTextXY(10, 10+mode*10, GetModeName( mode ) ); | |
| ReadLn; | { пауза до нажатия...} |
| CloseGraph | { закрытие графики} |
| END. | |
Функция GetDriverName: String позволяет получить имя используемого драйвера. Ее применение обосновано только в том случае, если в процедуре InitGraph переменная GraphDriver определена, как Detect.
Очистка графического экрана. Две следующие процедуры выполняют почти одинаковые действия, только первая из них является как бы подмножеством второй:
Эта процедура очищает графический экран и устанавливает указатель позиции в (0, 0), а процедура
GraphDefaults кроме очистки экрана устанавливает ряд параметров графической системы:
o графическое окно становится равным размеру экрана;
o восстанавливается системная цветовая палитра;
o переназначаются цвета основных линий и фона экрана;
o толщина и стиль линий принимаются как по умолчанию;
o цвет и шаблон заливки геометрических фигур и замкнутых ломаных принимается как по умолчанию;
o переустанавливается активный шрифт и его стиль.
Процедура GraphDefaults неявно вызывается при инициализации графики и выполняет, no-сути, все стартовые установки графических параметров.
Переключение режимов. Оно осуществляется процедурой SetGraphMode ( GraphMode: Integer)
Процедура переключает систему в указанный параметром GraphMode режим и очищает экран монитора. При этом все характеристики устанавливаются по умолчанию. Такие переключения возможны только в рамках текущего драйвера.
Процедура RestoreCRTMode. При написании некоторых пакетов, использующих и графические, и текстовые режимы работы, может использоваться процедура RestoreCRTMode, которая возвращает систему в текстовый режим, работавший до инициализации графики. Казалось бы, уже есть процедура с подобным действием — CloseGraph. Однако после нее возврат в графический режим должен проводиться через процедуру InitGraph, что довольно сложно. Если же воспользоваться процедурой RestoreCRTMode, то возвращение в графику будет достаточно простым
| USES Graph; | {подключен модуль Graph} | |
| {$I Initgraf.pas} | {процедура инициализации} | |
| CONST | {константы - сообщения} | |
| graph_str = ‘Это графический режим'; | ||
| text_str = 'А это текстовый режим'; | ||
| graph_ back = 'А это снова графический режим'; | ||
| BEGIN | ||
| Grlnit; | {инициализация графики} | |
| Line(0,0,GetMaxX,GetMaxY }; | { диагональ экрана} | |
| OutTextXY(0,100,graph_str); | { вывод первого сообщения} | |
| ReadLn; | {пауза до нажатия ввода} | |
| RestoreCRTMode; | {восстановление текстового режима} | |
| Write{ text_str ); | { вывод второго сообщения} | |
| ReadLn; | {пауза до нажатия ввода} | |
| SetGraphMode(GetGraphMode); | {восстановление графического режима} | |
| Une(0,0,GetMaxX,GetMaxY); | { диагональ экрана } | |
| OutTextXY(0,100,graph_back); | {вывод третьего сообщения} | |
| ReadLn; | { пауза до нажатия ввода} | |
| CloseGraph | { закрытие графики} | |
| End. | ||
Обратное переключение осуществляется при помощи функции GetGraphMode, которая возвращает номер текущего графического режима. При работе RestoreCRTMode выгрузки графического драйвера не происходит, т.е. он остается в памяти активным.
В растровой компьютерной графике экран представляет собой прямоугольный массив адресуемых точек и любое изображение на нем образуется как композиция светящихся или погашенных пикселов. Эти точки адресуются двумя целыми - горизонтальным номером точки nx и вертикальным номером ny:
0 <= nх <= nx_max,
0 <= nу <= ny_max,
где nx_max и ny_max - количество адресуемых точек по горизонтали и по вертикали минус единица
В модуле Graph предусмотрена возможность программного опроса максимальных адресуемых координат экрана. Она реализована парой функций
GetMaxX: Integer;
GetMaxY: Integer.
Возвращаемые ими значения соответствуют параметрам nx_max и ny_max, будут различаться для различных режимов и адаптеров. При адресации точек координатами, большими, чем эти значения, операция игнорируется.
Точка с адресом (0,0) обычно расположена в левом верхнем углу экрана дисплея. Координаты (nx, ny) называют также координатами устройства. Они могут принимать только целые значения.
«Текущий указатель» или, как его еще называют, графический курсор выполняет те же функции, что и курсор в текстовом режиме, однако является при этом невидимым. Положение графического курсора указывает на начальные координаты изображения графического примитива, выводимого «от текущей позиции».
Графические координаты задают положение точки на экране дисплея. Поскольку минимальным элементом, к которому имеет доступ программист, является пиксель, естественно в качестве графических координат использовать порядковые номера пикселей. Допустимый диапазон изменения графических координат составляет [0, rx- 1] для X и [0, ry - 1] для Y –координаты. Точкой отсчета является верхний левый угол экрана. Значения X- координаты отсчитываются слева направо, а Y-координаты - сверху вниз. Это отличает графические координаты от обычных декартовых координат, принятых в математике, и служит источником ошибок для начинающего программиста.
Для правильного отображения графика в декартовой системе координат на экране необходимо учесть следующее:
1. Графические координаты принимают только целочисленные значения.
2. Графические координаты принимают, ограниченные как снизу (нулевым значением), так и сверху (значением разрешения).
3. Графическая координата Y отсчитывается сверху вниз.
Таким образом, геометрические декартовы координаты точки (X, Y) для отображения на экране следует пересчитать в графические (Xg, Yg) по формулам:
Xg= ëSx*Xû + dx,
Yg= ry-ëSy*Yû – dy,
Где ëXû - целая часть X, Sx, Sy- масштабные множители, выбираемые из условия
rx=ëSx*Xmaxû+1
ry=ëSx*Ymaxû+1
Xmax, Ymax- максимальные значения геометрических координат.
Слагаемые dx, dy обеспечивают смещение относительно левого верхнего угла экрана.
Изображение будет смещено в центр экрана при dx=ërx/2û, dy=ëry/2û.
В графическом режиме текущий указатель перемещается специальными процедурами.
Процедура MoveTo (х, у: Integer) перемещает его в точку экрана с координатами (х, у).
Процедура MoveRel( dx, dy : Integer ) перемещает текущий указатель на dx пикселов по горизонтали и соответственно на dy по вертикали относительно последнего положения текущего указателя. Положительные значения dx и dy увеличивают его координаты, а отрицательные — уменьшают.
В системе координат дисплея ось Y направлена вниз, поэтому, если указатель надо перенести вверх, то приращение dy должно быть отрицательным.
Для определения текущего положения графического курсора используются функции
GetX: Integer;
GetY: Integer,
возвращающие положение указателя соответственно по оси X и по оси Y. Позиционирование текущего указателя и опрос его местонахождения работают корректно, даже если работа происходит за пределами координат устройства.
Изменяют положение текущего указателя также процедуры LineTo, LineRel, OutText.
Все процедуры инициализации и очистки экрана (InitGraph, GraphDefaults, ClearDevice, SetGraphMode, SetViewPort и ClearViewPort) устанавливают текущий указатель в положение (0,0).
Рисование графических примитивов и фигур. Линии и их стили
Процедура вывода линии (отрезка) на экран (в текущем цвете и стиле) определена в следующем виде:
Line (Х1, Y1, Х2, Y2: Integer)
Здесь задаются координаты начала (X1,Y1) и конца (X2,Y2) отрезка. Возможны еще два метода рисования отрезков:
1. Из текущей точки в точку с заданными координатами (X,Y). Выполняется процедурой
2. LineTo ( х, у: Integer)
3. Относительно текущей позиции. Положение текущего указателя принимается за начало «временных» координат (0,0) и указывается местоположение конца отрезка в них. Такое построение делает процедура
4. LineRel( dx, dy : Integer )
Координаты концов могут превышать границы графического окна. При этом часть отрезка может быть обрезана (но текущий указатель переместится в координаты конца отрезка).
В Турбо Паскале можно управлять стилем линий: задавать толщину, тип (сплошные линии, пунктирные и т.п.). Для этого определены следующие типы и константы стилей изображаемых линий:
TYPE
LineSettingsType=RECORD
| LineStyle | : Word; | { стиль (тип) } |
| Pattern | : Word; | { шаблон типа } |
| Thickness | : Word; | { толщина } |
END;
CONST
{ Для значений поля LineStyle :}
| SolidLn | = 0 | { сплошная линия } |
| DottedLn | = 1 | { точечная линия} |
| CenterLn | = 2 | { штрихпунктирная линия} |
| DashedLn | = 3 | { пунктирная линия } |
| UserBitLn | = 4 | { тип линии задан явно шаблоном} |
{ Для значений поля Thickness: }
| NormWidth = 1 | { толщина линии в один пиксел} |
| ThickWidth = 3 | { толщина линии в три пиксела} |
Чтобы получить информацию о текущем стиле линяй, можно воспользоваться процедурой
GetLineSettings( VAR LineType : LineSettingsType)
А чтобы установить новый стиль линий, необходимо использовать процедуру SetLineStyle( LineStyle, Pattern, Thickness : Word ), подставив в нее соответствующие значения. Если параметр LineStyle не равен UserBitLn, то значение параметра Pattern не играет роли и обычно задается нулем.
Рассмотрим подробно вариант, когда LineStyle равно UserBitLn. В этом случае при определении типа линии руководствуются следующими соображениями:
1. Линия представляет собой совокупность отрезков, каждый из которых имеет длину 16 пикселов. Если длина линии не делится на 16 нацело, то последний отрезок обрезается.
2. Можно задать шаблон-комбинацию шестнадцати светящихся или погашенных пикселов. Его представляют как множество единиц и нулей: 1 - светится, 0 - нет. Например, мелкий равномерный пунктир задается как 1100110011001100 - всего 16 разрядов.
Поскольку Турбо Паскаль не позволяет работать с числами, представленными в двоичной системе счисления, необходимо перевести полученное число в десятичную (52428) или в шестнадцатиричную ($СССС) систему счисления и подставить его фактическим параметром на место Pattern при вызове SetLineStyle.
| Uses Graph; | {подключен модуль Graph} |
| {$I Initgraf.pas} | {процедура инициализации} |
| Var | |
| x : Integer; | |
| BEGIN | |
| Grlrtit; | {инициализация графики} |
| X: = GetMaxX; | {разрешение экрана по X} |
| SetLineStyle (DottedLn, 0, NormWidth); | |
| Line (0, 10, x, 10); | {тонкая сплошная линия} |
| SetLineStyle (CenterLn, 0, NormWidth); | |
| Line (0, 20, x, 20); | {штрихпунктирная линия} |
| SetLineStyle( UserBitLn, $CCCC, NonriWidth ); | |
| Line{ 0, 30, x, 30 ); | { линия 1100110011001100 } |
| SetLineStyle( UserBitLn, $B38F, NormWidth ); | |
| Line( 0, 40, x, 40 ); | { линия 1011001110001111 } |
| SetLineStyle( UserBitLn, $4C70, NormWidth ); | |
| Line( 0, 50, x, 50 ); | { линия 0100110001110000 } |
| ReadLn; | { пауза до нажатия ввода } |
| SetLineStyle( DottedLn, 0, ThickWidth ); | |
| Line( 0. 10, x, 10 ); | { толстая сплошная линия } |
| SetLineStyle( CenterLn, 0, ThickWidth ); | |
| Line( 0, 20, x, 20 ); | { штрих-пунктирная линия} |
| SetLineStyle( UserBitLn, $СССС, ThickWidth ); | |
| Line( 0, 30, x, 30 ); | { линия 1100110011001100 } |
| SetLineStyle( UserBitLn, $B38F, ThickWidth ); | |
| Line( 0, 40, x, 40 ); | { линия 1011001110001111 } |
| SetLineStylef UserBitLn, $4С70, ThickWidth ); | |
| Line( 0, 50, x, 50 ); | { линия 0100110001110000} |
| ReadLn; | { пауза до нажатия ввода} |
| CloseGraph | { закрытие графики} |
| END. | |
В этом примере на экране монитора рисуется пять горизонтальных линий разной толщины: две нарисованы по системному шаблону, а три - по шаблону, заданному нами.
Назначение стиля линий влияет на действие всех процедур, выводящих на экран отрезки или фигуры, из них состоящие. Процедуры, выводящие на экран дуги, учитывают только толщину, заданную в стиле.
Если нарисовать квадрат отрезками, например
MoveTo (100, 100);
LineRel (20, 0); LineRel (0, 20);
LineRel (-20, 0); LineRel (0, -20);
то на экране, скорее всего, возникнет сжатый прямоугольник. Похожая картина будет наблюдаться, если «вручную» нарисовать окружность с помощью отрезков прямых или точек: получится эллипс. Это связано с тем, что отношение высоты экрана к ширине не равно отношению его разрешающей способности по вертикали к разрешающей способности по горизонтали. Для учета этого неравенства в графическом стандарте BGI вводится специальный показатель, называемый коэффициентом сжатия изображения (aspect ratio). Его значения могут иметь широкий диапазон. Например, для ПК IBM PC/XT/AT стандартные мониторы имеют отношение высоты экрана к его ширине, равное 0,75. При этом разрешающая способность адаптеров колеблется от 640x200 для CGA до 1024x768 IBM8514, и отношение GetMaxY к GetMaxX может меняться от 0,3125 (640x200) до 0,75 (640x480, 1024x768). Таким образом, на единицу длины оси экрана приходится разное количество пикселов по горизонтали и вертикали, а поскольку все операции производятся с пикселами, то в результате вместо окружности может получиться эллипс, горизонтальная полуось которого равна радиусу, а вертикальная - радиусу, деленному на коэффициент сжатия изображения.
В модуле Graph есть две процедуры, помогающие устранить неудобство. Первая из них
GetAspectRatio (VAR А, В: Word)
возвращает в переменных A и B значения, отношение которых (А/В) соответсвует коэффициенту сжатия изображения. В модуле Graph нет ни одного вещественного параметра (что повышает быстродействие), поэтому все нецелые значения представляются как отношение двух целых.
Другая процедура,
SetAspectRatio (А, В: Word)
Позволяет изменять текущий коэффициент сжатия на коэффициент, равный (А/В). Переназначение коэффициента сжатия влияет на работу всех процедур, выводящих окружности, эллипсы, дуги и на значение параметров, возвращаемых при вызове процедуры GetAspectRatio. Построить же правильный квадрат можно, домножая его вертикальный размер на исходный (системный) коэффициент сжатия.
{ Построение квадрата }
Program QuadroDem;
Uses Graph;
const l=100;
Var
d,r,e:integer;
a,b :word;
Begin
d:=Detect;
InitGraph(d,r,'');
e:=GraphResult;
if e<>grOk then
writeln(GraphErrorMsg(e))
else
begin
GetAspectRatio(a,b);
Rectangle(20,20,round(l*(b/a)),l);
readln;
CloseGraph;
end
End.
Окружности, эллипсы и дуги
Для изображения окружностей используется процедура
Circle(x, у: Integer; Radius: Word)
Здесь (X,Y) - координаты центра окружности, Radius - ее радиус. Результатом ее работы будет окружность, если коэффициент изображения соответствует принятому BGI-драйвером для текущего графического режима. В противном случае на экране появится эллипс, вытянутый по вертикали (коэффициент сжатия больше принятого по умолчанию) или по горизонтали (коэффициент меньше принятого).
В модуле Graph представлены процедуры рисования эллипсов, дуг, секторов и процедура, позволяющая рисовать сектор, залитый по заданному шаблону. Все они запрашивают параметры StartAngle и EndAngle, которые обозначают начальный и конечный угол дуги. На рисунке изображена система графических координат, в которой мы работаем.
Положительное направление оси X (слева направо) принято за 0°, отрицательное направление оси Y - за 90°, т.е. углы отмеряются от положительного направления оси X против часовой стрелки. Все значения этих параметров даются в градусах.
Ниже перечислены процедуры рассматриваемого класса:
Рисование дуги радиуса Radius из центра с координатами (X,Y) от угла StartAngle до EndAngle:
Arc(X, Y: Integer; StartAngle, EndAngle, Radius: Word)
При изменении коэффициента сжатия изображения вид выводимых дуг будет отличаться от правильных окружностей.
Рисование эллиптической дуги с аналогичными параметрами:
Ellipse (X, Y: Integer; StartAngle, EndAngle, XRadius, YRadius: Word)
где XRadius и YRadius - размеры горизонтальной и вертикальной полуосей соответственно. Оси эллипса могут быть только параллельны осям X и Y. Для изображения полного эллипса надо задавать углы 0° и 360°. Значение коэффициента сжатия изображение не влияет на его вид.
Угловые параметры очень неудобны для нашей системы координат - мы можем определить координаты начала и конца дуг окружности или эллипса не иначе, как только используя известные тригонометрические выражения. Но в подобных вычислениях нет необходимости, поскольку эти координаты все равно известны внутри процедур Arc, Ellips, Sector и PieSlice.
Извлечь концевые координаты дуг позволяет процедура
GetArcCoords (VAR ArcCoords: ArcCoordsType)
Тип ArcCoordsType объявлен в модуле Graph следующим образом:
TYPE
ArcCoordsType = RECORD
| X, Y | :Integer; | {центр} |
| XStart, YStart | :Integer; | {начало} |
| XEnd, YEnd | :Integer; | {конец} |
END;
Рассматриваемая процедура возвращает результаты последнего вызова процедуры рисования дуги или сектора.
Для построения прямоугольника достаточно вызвать процедуру Rectangle (Х1, Y1, Х2, Y2: Integer), которая изобразит на экране прямоугольник с диагональю (X1, Y1) - (X2, Y2). Для рисования квадрата надо выбрать высоту прямоугольника так, чтобы она равнялась произведению ширины на коэффициент сжатия изображения.
Чтобы построить фигуры с большим количеством вершин (в том числе и незамкнутые), можно воспользоваться процедурой
DrawPoly (NumPoints: Word; VAR PolyPoints)
Она позволяет рисовать на экране дисплея любую ломаную, заданную набором координат некоторого множества точек. Это может быть как сложная геометрическая фигура, так и табличная математическая функция. Параметр NumPoints - это количество точек ломаной (заметим, что если необходимо нарисовать замкнутый многоугольник с N вершинами, то значение NumPoints должно быть на единицу больше числа N, а координата (N+1) –й точки должна быть такой же, как координата первой). Под бестиповым параметром PolyPoints понимается какая-либо переменная, состоящая из наборов двухкомпонентных записей. Поля каждой записи должны содержать координаты X-и Y очередной точки. В модуле Graph введен такой тип:
TYPE
PointType=RECORD
X, Y: Integer; {координаты точки}
END;
Обычно набор точек организуется как массив из записей типа PointType (и именно к такой структуре приводится значений параметра PolyPoint при работе процедуры DrawPoly). Пример построения графика функции с помощью процедуры DrawPoly приведен далее.
| USES Graph; | {подключен модуль Graph } |
| {$I initgraf.pas} | {процедура инициализации} |
| CONST | |
| Pi * 3.14151828; | {константа Pi (замещает функцию)} |
| Pi2 = 2 * Pi; | {различные производные от Pi...} |
| Pi001 = 0.01* Pi; | |
| VAR | |
| angle: Real; | |
| sine_func: Array [1.201] of PointType ; | { массив точек} |
| maxy, i: Integer; | |
| BEGIN | |
| Grlnit; | {инициализация графики} |
| maxy := GetMaxY div 2; | {середина экрана по оси Y} |
| angle := 0.0; | {задание стартовых значений} |
| i := 0; | { счетчик точек в sine_func} |
| repeat | { цикл заполнения sine_func } |
| Inc ( i ); | |
| sine_func[i].x:= Round (100 * angle) + 10; | |
| sine_func[i].y:= Round (100 * Sin (angle)) + maxy; | |
| angle := angle + Pi001; | |
| until angle > Pi2; | |
| DrawPoly (i, sine_func) ; | { рисование графика синуса} |
| ReadLn; | {пауза до нажатия ввода} |
| CloseGraph | {закрытие графики} |
| END. | |
С помощью DrawPoly можно вывести график части функции. Для этого достаточно указать при передаваемом массиве номер n первого рассматриваемого элемента (т.е. точки), а в первом параметре — количество рассматриваемых точек, начиная с n-й, например
DrawPoly (20, sine_func [100]);
Такой вызов выведет ломаную линию по точкам с номерами 100, 101,..., 119.
При выводе количества точек, соизмеримого со значением GetMaxX, и при несплошном стиле линии может оказаться, что шаг между соседними точками соответствует ширине пробела между пунктиром. В итоге линия может вообще не проявиться на экране. Надо либо уменьшить число точек, либо избрать сплошной тип линии.
Управление цветами и шаблонами заливки (заполнения)
Рассмотрим процедуры, управляющие цветовой гаммой изображения на дисплее, что не только определяет степень разборчивости и привлекательности изображения, но и в конечном итоге может влиять на физиологическое состояние пользователя.
В модуле Graph предусмотрены процедуры, с помощью которых можно заполнить (залить) определенным «узором» любую замкнутую область изображения. Вид «узора» задается так называемым шаблоном заливки. В Турбо Паскале предопределен ряд стандартных шаблонов, но кроме того, имеется возможность конструировать собственные.
Назначение шаблона заполнения (заливки) производится процедурой
SetFillStyle (Pattern: Word; Color: Word)
где параметр Pattern определяет вид шаблона заливки, a Color — его цвет. Все разрешенные значения параметра Pattern предопределены в модуле Graph в виде констант:
CONST
| EmptyFill | =0 | { сплошная заливка цветом фона} |
| SolidFill | =1 | { сплошная заливка текущим цветом} |
| LineFill | =2 | { заливка типа ===} |
| LtSlashFill | =3 | { заливка типа ///} |
| SlashFill | =4 | { заливка жирными линиями типа ///} |
| BkSlashFill | =5 | { заливка жирными линиями типа \\\} |
| LtBkSlashFill | =6 | { заливка типа \\\} |
| HatchFill | =7 | { заливка редкой штриховкой} |
| XHatchFill | =8 | { заливка частой штриховкой} |
| InterleaveFill | =9 | { заливка прерывистой линией} |
| WideDotFill | =10 | { заливка редкими точками} |
| CloseDotFill | =11 | { заливка частыми точками} |
| UserFill | =12 | { заливка, определенная программистом} |
Константа UserFill используется для определения типа заливки, который предварительно был задан в программе. Для задания своего нового шаблона необходимо воспользоваться процедурой
SetFillPattern (PattMatrix: FillPatternType; Color: Word)
передав ей в параметре PattMatrix матрицу шаблона заливки и указав цвет параметром Color. Эта процедура по действию аналогична SetFillStyle, но устанавливает только «самодельные» шаблоны. Процедура SetFillStyle удобнее, особенно в приложениях деловой графики (гистограммы, круговые диаграммы и т.п.). Задавая хотя бы раз новый шаблон, мы автоматически связываем его со значением UserFill и далее можем манипулировать всеми тринадцатью шаблонами. Если же задать UserFill, не определив перед этим новый шаблон, то функция GraphResult возвратит значение -11 (grError) и все установки вида шаблона и цвета останутся прежними. По умолчанию устанавливается шаблон SolidFill и цвет с. номером, максимальным для текущего графического режима.
В обеих процедурах назначения шаблона переменная Color определяет цвет, которым исполняется шаблон. Цвет фона при этом остается неизменным.
{ Демонстрация стандартных типов штриховки }
Program FillStDem;
Uses CRT,Graph;
Var
d,r,e,i,j,x,y : integer;
Begin
d:=Detect;
InitGraph(d,r,'');
e:=GraphResult;
if e<>grOk then
writeln(GraphErrorMsg(e))
else
begin
SetGraphMode(0);
x:=GetMaxX div 9;
y:=GetMaxY div 7;
for j:=0 to 2 do
for i:=0 to 3 do
begin
Rectangle((2*i)*x,(2*j+1)*y,
(2*i+1)*x,(2*j+2)*y);
SetFillStyle(i+j*4,j+1);
Bar((2*i)*x+1,(2*j+1)*y+1,
(2*i+1)*x-1,(2*j+2)*y-1);
end;
readln;
CloseGraph;
end
End.
Рассмотрим процедуры, непосредственно реализующие заливку. Имеется целый ряд процедур, рисующих графические фигуры и сразу же заполняющих их по заданному шаблону. Первая них — процедура
Bar (X1, Y1, X2, Y2: Integer)
рисует прямоугольник, внутренняя область которого залита по текущему шаблону. Она обычно используется в деловой графике для строения столбчатых диаграмм. Параметры (X1,Y1) и (X2, Y2) - координаты верхнего левого и правого нижнего углов прямоугольника. Еще более наглядное представление информации при рисовании диаграмм позволяет получить процедура
Bar3D (X1, Y1, X2, Y2: Integer; D3: Word; Top: Boolean)
Она рисует параллелепипед, лицевая сторона которого заливается по текущему шаблону, а глубина задается в пикселах параметром D3. Параметр Тор задает режим отображения верхней плоскости: True - отображать, False - не отображать. Этот параметр необходим для того, чтобы можно было рисовать столбцы, стоящие друг на друге. В модуле Graph определены две константы для нее:
CONST
| TopOn = True; | {верхняя плоскость нужна} |
| TopOff = False; | {верхняя плоскость не нужна} |
{ Построение параллелепипеда }
Program Bar3Dem;
Uses CRT,Graph;
Var
d,r,e : integer;
Begin
d:=Detect;
InitGraph(d,r,'');
e:=GraphResult;
if e<>grOk then
writeln(GraphErrorMsg(e))
else
begin
Bar3d( 80,100,120,180,15,TopOn);
Bar3d(150,150,190,180,15,TopOff);
Bar3d(230, 50,250,150,15,TopOn);
Bar3d(220,150,260,180,15,TopOn);
Bar3d(300,150,340,180,15,TopOff);
Bar3d(300, 50,340,150,15,TopOn);
readln;
CloseGraph;
end
End.
Следующие «заполняющие» процедуры работают с секторами окружностей и эллипсов. Рисование сектора эллипса, который будет залит цветом по текущему шаблону, осуществляется процедурой
Sector (X, Y: Integer; StartAngle, EndAngle, XRadius, YRadius: Word)
Параметры процедуры имеют тот же смысл, что и в процедурах Arc, Ellipse. для задания кругового сектора надо задавать YRadius с учетом коэффициента сжатия:
VAR
R, А, В: Word; {R - радиус кругового сектора}
BEGIN
GetAspectRatio (А, В);
Sector (100, 100, 0, 90, R, R * Longlnt (A) div В);
END.
Этого же эффекта можно достичь, используя процедуру
PieSlice(X, Y: Integer; StartAngle, EndAngle, Radius: Word)
которая рисует сектор окружности, площадь которого заливается по текущему шаблону заполнения.
процедура
FillEllipse(X, Y: Integer; XRadius, YRadius: Word)
рисует эллипс текущим цветом и заполняет его по установленному шаблону. Параметры этой процедуры имеют такой же смысл, как и параметры процедуры Ellipse.
Заполнение более сложных геометрических фигур, в том числе и неправильной формы, производится процедурой
FillPoly (NumPoints: Word; VAR PolyPoints)
Ее параметры имеют такое же назначение, как и в процедуре DrawPoly. Единственное отличие в том, что координаты первой и последней вершины многоугольника могут не совпадать. Однако все равно они будут соединены линией, и внутренность фигуры будет залита.
| USES Graph; | {подключен модуль Graph} |
| {$I initgraf.pas} | {процедура инициализации} |
| CONST | |
| our_ figure : Array [1..4] of PointType = | |
| ( x: 319; y: 40), | {Задание координат концов } |
| ( x: 398; y: 146), | {отрезков, являющихся сторонами} |
| ( x: 240; у: 146), | {геометрической} |
| ( x:400; у: 40)); | {фигуры} |
| BEGIN | |
| Grlnit; | { инициализация графики} |
| SetFiUStyle(InterleaveFill, Red); | { задание шаблона } |
| { рисование заданной фигуры} | |
| FillPoly( SizeOf(our.figure) div SizeOf( PointType ), our_figure ); | |
| ReadLn; | |
| CloseGraph | |
| END. | |
Функция SizeOf (our_figure) возвращает размер константы our_figure в байтах, a SizeOf (PointType) — размер памяти, занимаемый одним элементом типа PointType. И, наконец, универсальная процедура
FloodFilt(X, Y: Integer; Border: Word)
Она заливает всю область вокруг точки (X,Y), ограниченную линиями цвета Border. Например, если точка (X,Y) находится внутри области, ограниченной окружностью, то вся область будет залита по шаблону и цветом, установленными процедурами SetFillPattern или SetFillStyle. Если же точка будет находиться вне этой области, то залитым будет весь экран за исключением этой области. Если область не замкнута сплошной линией или границами экрана, то по шаблону заполнится весь экран.
Различные адаптеры поддерживают разное количество цветов, выводимых одновременно на экран в графическом режиме. Но для всех BGI-драйверов оно ограничено диапазоном 0..15. Нумерация и названия цветов совпадают с теми, которые были приведены для текстовых цветов, а имена констант, обозначающих цвета (за исключением Blink), продублированы в модуле Graph.
Максимальный номер цвета, воспринимаемый данным адаптером в текущем графическом режиме, может быть получен при помощи функции
GetMaxColor: Word
На экране всегда различаются цвет фона и цвет пера. Все процедуры изображения фигур, если не содержат в себе явной установки цвета, рисуют эти фигуры цветом пера (как символы в текстовом режиме). Этот цвет устанавливается процедурой
SetColor (Color: Word)
Цвет фона — всегда един в поле экрана. Он может быть изменен процедурой
SetBkColor (Color: Word)
После использования этой процедуры цвет экрана сразу же меняется на заданный. Параметр Color не должен превышать текущее значение GetMaxColor. Цветом фона может быть любой из разрешенных цветов, в том числе и яркий. По умолчанию и при реинициализации графики цвет фона равен 0 (Black), а цвет пера равен значению функции GetMaxColor.
Всегда можно опросить текущие установки цвета.
Функция GetColor : Word возвращает значение текущего цвета пера, а функция GetBkColor: Word возвращает текущий цвет фона.
Палитра и ее анализ. Максимальный набор цветов, поддерживаемых одновременно BGI-драйвером, называется палитрой и может состоять из 16 цветов, пронумерованных от 0 до 15 (так будет, например, для графических адаптеров EGA, VGA).
Эти шестнадцать цветов используются по умолчанию в режимах 640x480 для VGA, 640x350, 640x200 и 320x200 для EGA как в текстовом, так и в графическом режимах.
Числа от 0 до 15, которые используются для обозначения цветов, определяют цветовые атрибуты или, как их еще называют, «программные» цвета. Каждому программному цвету присваивается «аппаратный» цвет из так называемой полной палитры. Например, для адаптера EGA, выводящего одновременно до 16 цветов, программные цвета выбираются из полной палитры в 64 цвета, имеющейся в этом адаптере. А в адаптере VGA аппаратная палитра содержит 256 цветов. Для управления соответствием между программными и аппаратными цветами в модуле Graph предусмотрен ряд процедур, охватывающих практически все возможные операции с палитрой.
Рассмотрим процедуры, с помощью которых можно получить системную информацию о ней. В модуле Graph определен тип для описания палитры:
CONST
MaxColors = 15; {максимальный программный номер цвета}
TYPE PaletteType=RECORD
| Size | : Byte; | {размер программной палитры} |
| Colors: Array [0..MaxColors] of Shortlnt; | ||
END;
Поле Size содержит количество цветов в палитре, а поле Colors содержит действующие цвета в первых Size элементах массива. Процедуры GetPalette и GetDefaultPalette возвращают в фактических параметрах значение типа PaletteType:
GetDefaultPalette (VAR Palette: PaletteType);
GetPalette (VAR Palette: PaletteType);
Они отличаются друг от друга тем, что первая процедура возвращает набор цветов, который устанавливается при инициализации графического режима, т.е. по умолчанию, а вторая процедура возвращает текущий набор цветов.
Функция GetPaletteSize: Word
возвращает результат типа Word, который показывает, какое количество цветов входит в текущую программную палитру. В принципе, эта функция возвращает значение, равное GetMaxColor+1.
Установка палитры. Для установки палитры в модуле Graph представлены три процедуры разной сложности. Процедура
SetPalette (ColorNum: Word; Color: Shortlnt)
управляет только одним цветом в палитре. ColorNum - это номер программного цвета, Color - номер аппаратного цвета, который будет под ним пониматься.
Например, вызов SetPalette(0, Red) делает красный цвет первым цветом палитры. Параметр Color может превышать максимальный программный номер цвета, но только на адаптерах EGA (0..63) и VGA. При некорректном вызове процедуры функция GraphResult вернет значение grError.
Битовые графические операции
Опрос пикселов. Турбо Паскаль позволяет организовать прямой доступ к каждому пикселу экрана с помощью функции
GetPixel(X,Y: Integer).
Эта функция возвращает значение типа Word- номер цвета пиксела с координатами (X, Y). Поскольку обычно номер цвета лежит в диапазоне 0..15, значащим является только младший байт.
Управление пикселами заключается в возможности назначить цвет любому пикселу экрана. Процедура
PutPixel ( X, Y: integer; Color: Word ); зажигает на экране в точке с координатами X, Y пиксел цвета Color.
Память видеоадаптеров разделена на так называемые страницы, или видеостраницы. По умолчанию в графическом режиме действия производятся с нулевой страницей, поэтому практически во всех предыдущих примерах было видно, как рисуются на экране фигуры. Однако если направить вывод изображений на ненулевую страницу (при условии, что такая доступна в текущем режиме видеоадаптера, то на экране ничего не отобразится, поскольку по умолчанию видимой является нулевая страница. Если же после этого дать команду считать видимой «скрытую» страницу, то она появится на экране буквально мгновенно (конкретно: за один прямой проход луча в кинескопе). Проделать все это позволяют две процедуры:
SetVisualPage (Page: Word)
которая устанавливает «видимой» на экране видеостраницу номер Page, и процедура
SetActivePage (Page: Word)
устанавливающая перенаправление всех графических операций на страницу номер Page (т.е. делающая активной). Активность не тождественна видимости страницы на экране.
Рассмотрим пример использования этих процедур.
(* Пример только для адаптеров EGA и VGA!!! *)
| USES Graph, CRT; | {используется Graph и CRT} |
| {$I initgraf.pas} | {процедура инициализации} |
| PROCEDURE Forms (kadr: Byte); | {рисование кадров 0..3} |
| CONST | |
| Radius: Array [0..3] of Integer = (20, 40, 60, 60); | |
| VAR | |
| r, rr : Integer; | { радиусы эллипсов в кадрах } |
| BEGIN | |
| r:= Radius[kadr]; | {максимальный радиус} |
| rr := 0; | { радиус вложенного эллипса } |
| repeat | |
| Ellipse(GetMaxX div 2,GetMaxY div 2,0,360,r,rr); | |
| Inc( rr, 5 ) ; | |
| until rr>=r; | |
| END; | |
| PROCEDURE AnimEGAVGA; | {процедура смены кадров} |
| CONST ms = 60; | {задержка между кадрами, мс} |
| VAR i: Byte; | {параметр циклов смены} |
| BEGIN | |
| repeat | { цикл до нажатия клавиши...} |
| for i:=0 to 3 do begin | { Смена видеостраниц: прямо } |
| SetVisualPage (i); | |
| Delay( ms ); | |
| end; | |
| for i:=3 downto 0 do begin | { ... и обратно } |
| SetVisualPage( i ); | |
| Delay( ms ); | |
| end; | |
| until KeyPressed; | { условие окончания показа } |
| END; | |
| VAR | (* ОСНОВНАЯ ЧАСТЬ ПРИМЕРА *) |
| i: Byte; | { параметр (номер кадра)} |
| BEGIN | |
| Grlnit; | {инициализация графики } |
| SetGraphMode (EGALo); | {режим EGA, 640x200, 4 стр.} |
| for i:=3 downto 0 do begin | { Цикл заполнения страниц} |
| SetVisualPage (Succ (i) mod 4); | {Видим "пустоту “} |
| SetActivePage(i); | {и готовим кадр} |
| Forms( i ) | {рисунок кадра} |
| end; {for} | |
| AnimEGAVGA; | {начало оживления кадров} |
| CloseGraph | |
| END. | |
Здесь показано использование процедур SetActivePage и SetVisualPage для алгоритма «кадровой» мультипликации. Особенность ее заключается в том, что все кадры (здесь их четыре) сначала записываются на соответствующие страницы, а затем производится последовательное переключение отображения страниц на дисплей процедурой SetVisualPage.
В системе BGI-графики вводится термин «viewport». Специальный словарь дает следующее разъяснение: «вьюпорт - это область просмотра, окно экрана, в компьютерной графике - часть пространства отображения, в которой изображается и просматривается часть моделируемого объекта». Мы будем использовать термин «графическое окно». При образовании графического окна получается как бы «экран в экране» заданного размера. В модуле Graph для описания графического окна объявлен следующий тип и две константы:
TYPE ViewPortType = RECORD
| X1, Y1, X2, Y2: Integer ; | { границы окна} |
| Clip: Boolean; | {режим отсечения) |
END;
CONST
| ClipOn = True; | { отсечение по границе окна включено} |
| ClipOff = False; | { отсечение по границе окна выключено} |
Здесь первые элементы записи — это координаты прямоугольной области (графического окна), как их принято задавать, a Clip — это параметр, указывающий графической системе, что делать с изображением, попавшим за пределы этой области. Clip может принимать два значения. Значение ClipOn указывает на то, что все элементы изображения обрезаются по границам графического окна, a ClipOff указывает на то, что все рисуется без изменений.
Объявление графического окна производится процедурой
SetViewPort (Х1, Y1, Х2, Y2: Integer; ClipMode: Boolean)
входные параметры соответствуют полям записи типа ViewPortType. После выполнения этой процедуры все текущие установки станут относиться к окну. Текущий указатель (графический курсор) установится в его левый верхний угол, и туда же переносится начало системы координат дисплея. Другими словами, мы получим локальну систему координат устройства. Если параметры процедудуры заданы неправильно, то функция GraphResult возвратит ошибку grError (-11).
Назначение графического окна можно использовать для перемещения начала системы координат. Так, если задать окно вызовом
SetViewPort (GetMaxX div 2, GetMaxY div 2, GetMaxX, GetMaxY, ClipOff);
то получим систему координат с началом в центре экрана. При этом станет «видимой» адресация отрицательных координат. Графическое окно не меняет масштаба системы координат, а лишь выбирает систему отсчета адресуемых пикселов. Для опроса текущих параметров графического окна служит процедура
GetViewSettings {VAR ViewSettings: ViewPortType)
Если воспользоваться ею сразу же после инициализации графического режима, то обнаружится, что графическим окном является весь экран. Это говорит о том, что для системы безразлично, какое графическое устройство отображает результат, поскольку графическое окно представляет собой некоторый универсальный интерфейс между графической программной системой и графическим устройством вывода.
Для очистки рабочего пространства графического окна в модуле Graph существует специальная процедура
ClearViewPort
Она работает следующим образом:
1. устанавливает цвет заполнения равный текущему цвету фона;
2. вызывает процедуру Ваг с теми же значениями координат; что и у процедуры SetViewPort, вызванной перед этим;
3. перемещает текущий указатель в точку (0,0) .
{ Иллюстрация дейсвия режима "отсечка" }
Program ClipOn_Off;
Uses Graph;
Var d,e,r:integer;
Const
x11=0; y11=40; x12=120; y12=85;
x21=200; y21=y11; x22=320; y22=y12;
Begin
d:=Detect; InitGraph(d,r,'');
e:=GraphResult;
if e<>grOk then
writeln(GraphErrorMsg(e))
else
begin
writeln(' ClipOn: ClipOff');
Rectangle(x11,y11,x12,y12);
Rectangle(x21,y21,x22,y22);
SetViewPort(x11,y11,x12,y12,ClipOn);
Circle(20,20,60);
SetViewPort(x21,y21,x22,y22,ClipOff);
Circle(20,20,60);
readln;
CloseGraph;
end
End.
Вывод текста в графическом режиме имеет ряд отличий от подобных действий в текстовом режиме. Основное отличие состоит в том, что все действия производятся только со строковыми константами и переменными. Вся числовая информация должна предварительно преобразовываться в строковую процедурой Str . Другое отличие - в том, что можно использовать различные шрифты.
В комплектах поставки пакета Турбо Паскаль есть файлы с расширением .CHR. Это набор штриховых шрифтов, которые могут быть использованы для вывода информации. Поскольку они построены не матричным способом (как сделаны стандартные шрифты для текстового режима), а векторным, становятся возможными манипуляции размерами шрифтов без потери качества их изображения.
Всего с пакетом Турбо Паскаль поставляется четыре шрифта (хотя можно, используя отдельный специальный пакет, самостоятельно расширить их набор). Кроме того, доступен системный матричный шрифт 8x8 для графических режимов (всегда доступны символы с ASCII-кодами от 0 до 127 и символы с кодами от 128 до 255 при условии, что их матрицы загружены в память ПЭВМ). Для обозначения этих пяти шрифтов введены константы:
CONST
| DefaultFont | = 0; | { матричный шрифт 8x8 (по умолчанию)} |
| TriplexFont | = 1; | { полужирный шрифт} |
| SmallFont | = 2; | { светлый шрифт (тонкое начертание)} |
| SansSerifFont | = 3; | { книжная гарнитура (рубленый шрифт)} |
| GothicFont | = 4; | { готический шрифт} |
DefaultFont - это матричный шрифт 8x8. Если не принимать никаких действий по смене шрифта, то будет принят именно он.
Активизация любого из названных шрифтов осуществляется процедурой
SetTextStyle (Font, Direction: Word; CharSize: Word)
Здесь параметр Font - номер шрифта (например, одна из описанных выше констант), Direction - расположение текста (по умолчанию принимается горизонтальное). Возможны лишь две ориентации текста, обозначенные константами:
CONST
| HorizDir | = 0; | { горизонтальная, слева направо} |
| VertDir | =1; | { вертикальная, снизу вверх} |
При значении Direction, равном VertDir, все символы будут повернуты против часовой стрелки на 90° и выводятся снизу вверх. Если задать Direction=2, то буквы будут повернуты так же, как и при Direction=VertDir, но вывод строки будет производиться горизонтально, слева направо.
Размер каждого символа устанавливается параметром CharSize, диапазон изменения которого составляет от 1 до 10. Стандартное значение CharSize для матричного шрифта 8x8 равно единице, а для штриховых шрифтов - четырем.
При каждом вызове процедурой SetTextStyle какого-либо шрифта он читается с диска и загружается в память.
Чтобы определить результат чтения файла шрифта с диска и загрузки его в память, можно проверить значение функции CraphResult. Перечень значений, возвращаемых ею в этом случае, приведен в таблице.
| GraphResult | Смысл значения |
| 0 | Успешное выполнение операции |
| -8 | Файл CHR не найден |
| -9 | Не хватает памяти для загрузки выбранногошрифта |
| -11 | Ошибка графики |
| -12 | Ошибка ввода-вывода графики |
| -13 | Неправильное содержимое файла шрифта |
| -14 | Неправильный номер шрифта |
{Демонстрация шрифтов}
Program SetStDem;
Uses Graph;
const
text : array[1..4] of string[14]=
('TripLexFont','SmallFont','SansSerifFont','GothicFont');
s4=', size 4';
s5=' and 5';
Var
d,r,e,i:integer;
Begin
d:=Detect;
InitGraph(d,r,'');
e:=GraphResult;
if e<>grOk then
writeln(GraphErrorMsg(e))
else
begin
SetTextStyle(DefaultFont,HorizDir,1);
OutText('DefaultFont, size 1');
SetTextStyle(0,0,2);
OutText(' and 2');
for i:=1 to 4 do begin
SetTextStyle(i,0,4);
Moveto(10,i*40);
OutText(text[i]+s4);
SetTextStyle(i,0,5);
Outtext(s5);
end;
for i:=1 to 4 do begin
SetTextStyle(i,1,4);
Moveto(GetMaxX div 2+i*40-20,0);
OutText(text[i]);
end;
readln;
CloseGraph;
end
End.
Для вывода текста есть две процедуры. Первая —OutText (TextString: String) выводит на графический экран строку TextString, ориентированную относительно позиции текущего указателя, а вторая OutTextXY (X, Y: Integer; TextString: String} выводит строку, ориентированную относительно координат (X,Y). Шрифт предварительно может быть установлен вызовом SetTextStyle (по умолчанию принимается DefaultFont). Рассмотрим ориентировку строки относительно стартовой точки. Существует несколько вариантов ориентировки. Они задаются процедурой SetTextJustify (Horizontal, Vertical: Word), параметры которой могут принимать одно из трех объявленных в модуле Graph значений:
CONST
| { — Для горизонтального ориентирования (Horizontal) —} | ||
| LeftText | =0; | {координата X задает левый край строки} |
| Center-Text | = 1; | {координата X задает середину строки} |
| RightText | = 2; | {координата X задает правый край строки} |
| { — Для вертикального ориентирования (Vertical): —} | ||
| BottomText | = 0; | {координата Y задает нижний край строки} |
| CenterText | = 1; | {координата Y задает середину строки} |
| TopText | = 2; | {координата Y задает верхний край} |
Эта процедура позволяет ориентировать выводимую строку относительно стартовой координаты по установленной схеме. По умолчанию параметры ориентировки соответствуют LeftText, TopText.
Модуль Graph Модуль Graph представляет собой библиотеку подпрограмм, обеспечивающую полное управление графическими режимами различных адаптеров дисплеев: CGA, EGA, VGA и т.д. Библиотека содержит более пятидесяти графических процедур и функци
Модуляция и демодуляция
Мониторы
Мониторы: назначение, классификация
Мультимедиа и ее составляющие
Мультимедиа технологии
Назначение компьютерных сетей
Накопичувачі інформації
Нанотехнологии и нанороботы
Направления компьютерной лингвистики
Направления обеспечения защиты информации на предприятии
Copyright (c) 2024 Stud-Baza.ru Рефераты, контрольные, курсовые, дипломные работы.