|
Значение
|
Тип данных
изображения
|
Цветовая
таблица
|
Кодирование
|
|
0
|
В файле нет
данных изображения
|
Нет
|
Нет
|
|
1
|
Изображение с
цветовой таблицей
|
Есть
|
Нет
|
|
2
|
Truecolor-изображение
|
Нет
|
Нет
|
|
3
|
Монохромное
изображение
|
Нет
|
Нет
|
|
9
|
Изображение с цветовой
таблицей
|
Есть
|
Есть
|
|
10
|
Truecolor-изображение
|
Нет
|
Есть
|
|
11
|
Монохромное
изображение
|
Нет
|
Есть
|
Поле CMapLength хранит сведения о количестве элементов в
цветовой таблице. Если изображение содержит только 57 цветов, то, используя это
поле, можно построить 57-элементную таблицу.
Поле CMapDepth определяет количество битов в каждом элементе
таблицы. Обычно оно имеет значения 15, 16, 24 или 32.
ImageDesc - Описание изображения. Несет в себе следующую
информацию:
-6 биты - резерв, всегда 0;
-5 биты - определяют позицию начала изображения. Если оба
бита равны 0, то изображение начинается в левом нижнем углу;
-3 биты - количество битов атрибутов в пикселе (альфа-канал,
оверлейные биты и биты прерывания) [1].
1.1.3
Цветовая таблица
Формат TGA определяет три метода хранения данных изображения:
pseudo-color (псевдоцвет), direct-color и true-color.
Каждый пиксель псевдоцветного изображения хранит значение,
соответствующее индексу цветовой таблицы. В этой таблице записаны фактические
цветовые величины, которые и отображаются на экране дисплея. Цветовые таблицы
псевдоцветных изображений содержат все цветовые величины, определяющие каждый
цвет в виде отдельного элемента, причем значения отдельного цветового канала
индивидуально недоступны.
Изображения direct-color подобны псевдоцветным изображениям, однако в них
каждый цветовой канал (красный, зеленый и синий) записан как отдельный элемент
и может быть модифицирован индивидуально. Значение каждого пикселя данных
изображения direct-color содержит три индекса - по одному на каждый канал цветовой
таблицы.
Изображения true-color хранят цветовую информацию пикселя
непосредственно в данных изображения, и для их отображения цветовая таблица не
применяется [2].
Цветовая таблица присутствует в файле формата TGA только
тогда, когда поле ColorMapType заголовка данного файла установлено в 1. Значение 0 этого
поля указывает на то, что цветовая таблица в этом файле отсутствует.
Цветовая таблица может присутствовать в TGA-файле даже в том
случае, если она не используется.
Формат TGA поддерживает цветовые таблицы переменной длины.
Большинство других форматов требуют, чтобы цветовая таблица имела фиксированное
количество элементов, основанное на пиксельной глубине данных изображения.
Таким образом, 8-битовое изображение содержит 256-элементную цветовую таблицу,
даже если для его репродуцирования требуется всего 4 цвета. А вот формат TGA не
определяет количество элементов цветовой таблицы на основании пиксельной
глубины, поэтому изображение, содержащее 57 цветов, может включать цветовую таблицу,
состоящую только из 57 элементов. Данные о количестве элементов в цветовой
таблице содержатся в поле СМарLength заголовка файла TGA.
Выраженный в битах размер каждого элемента цветовой таблицы
записывается в поле CMapDepth заголовка файла. Пиксельная глубина данных изображения не
всегда соответствует глубине элемента цветовой таблицы. Для 24-битового
изображения может использоваться цветовая таблица из 256 элементов, в которой
каждый элемент имеет глубину 24 бита, и в то же время такое изображение может
содержать пиксели глубиной всего в 8 битов. Этой глубины вполне достаточно,
поскольку нужно проиндексировать только 256 элементов. Вполне возможно, что
TGA-изображение может иметь цветовую таблицу из 4096 элементов с глубиной
каждого элемента 8 битов. В таком случае минимальная пиксельная глубина,
необходимая для индексации элементов цветовой таблицы указанного размера,
должна быть равной 12 битам, хотя 16-битовые пиксельные значения гораздо проще
и читать, и записывать. Понятие глубины элемента цветовой таблицы всегда
включает альфа-канал, оверлейные биты или биты прерывания, если они есть [2].
1.1.4 Данные
изображения
Данные изображения обычно следуют за заголовком, но если в
файле имеется цветовая таблица и/или поле идентификации изображения, то данные
записываются после них.
Размер TGA-изображения ограничен 65535 пикселями по высоте и
таким же количеством пикселей по ширине.
Данные изображения содержат (Width x Height) пикселей. Каждый
пиксель определяет данные изображения в одном из следующих форматов:
значение индекса цветовой таблицы (8-битовый пиксель);
красный, зеленый, синий (16-битовый пиксель с оверлейным
битом (15-й бит));
красный, зеленый, синий (24-битовый пиксель);
альфа-канал, красный, зеленый, синий (32-битовый пиксель).
Читать или записывать пиксельные данные в 8-, 16-, 24 - или
32-битовом формате так же просто, как читать и записывать байты данных.
Однако 16-битовые пиксельные данные формата TGA несколько сложнее.
Значение поля PixelDepth = 16 означает, что в данных каждого пикселя выделено по 5 битов
для представления каждой из цветовых величин (красной, зеленой и синей), а один
бит содержит оверлейные данные (см. ниже). Поскольку эти 16 битов записываются
в 2 байтах, то для чтения и записи отдельных элементов таких пиксельных данных
необходимо произвести некоторый сдвиг и маскирование [2].
Количество битов атрибутов в пикселе определяется значениями
битов 0-3 поля ImageDescriptor заголовка и соответствует количеству битов в
пикселе, которые не связаны непосредственно с его цветовыми величинами.
В формате TGA 16 только 15 из 16 битов пикселя используются для
воспроизведения цветовой информации. Каждый 16-й бит, называемый оверлейным,
применяется для задания прозрачности (пиксель не виден) или непрозрачности
(пиксель виден) пикселя при отображении на видеомониторе.
В формате TGA 32 пиксель представлен 32 битами, причем цветовая
информация хранится в 24 битах, а дополнительные 8 битов атрибутов в каждом
пикселе применяются в качестве значений альфа-канала.
Альфа-канал - это условное название, которое определяет
значение, задающее степень прозрачности отображаемого пикселя. Значения
альфа-канала и оверлейных битов применяются при наложении одного изображения на
другое или на "живую видеокартинку". Один оверлейный бит (как в
формате TGA 16) может только указывать на то, видим пиксель или нет; восемь битов
точности могут управлять видимостью пикселя в диапазоне от полной прозрачности
(0) до полной непрозрачности (255).
Данные изображения, записанные в файле TGA, обычно не
обрабатываются (не кодируются). По этой причине файлы TGA, как правило, весьма
громоздки, особенно если растровые данные имеют глубину 24 или 32 бита. На этот
случай спецификацией TGA предусмотрена простая, но эффективная схема сжатия RLE [2]. Изображение любого
типа может быть сжато при помощи алгоритма RLE. В сжатом изображении в
общем случае сжатие может переходить от одной строки к другой. Зажатые данные
представляют собой серию групп, каждая из которых состоит из управляющего байта
и одного или более пикселей. Старший бит управляющего байта сообщает тип группы
- литеральная или повторяемая, а младшие 7 бит содержат длину группы. Длина
группы на 1 больше, чем значение в управляющем байте, так что величины
управляющего байта от 0h до 7Fh соответствуют длинам от 1 до 128 пикселей. Если
старший бит - 1, то группа является повторяющейся, т.е. имеется 1 пиксель,
который повторяется несколько раз. Если старший бит - 0, группа - литеральная и
в ней столько пикселей, сколько указано в длине. Например, управляющий байт 0Fh - литеральная группа, и
за этим байтом следует 16 пикселей. Управляющий байт 88h - повторяющаяся группа,
и за этим байтом следует 1 пиксель, который повторяется в изображении 9 раз
[4].
графический изображение формат файл
1.2 Формат
BMP
Формат файла BMP (сокращенно от BitMaP) - это
"родной" формат растровой графики для Windows, поскольку он наиболее
близко соответствует внутреннему формату Windows, в котором эта система хранит
свои растровые массивы. Для имени файла, представленного в BMP-формате, чаще
всего используется расширение BMP, хотя некоторые файлы имеют расширение RLE,
означающее run length encoding (кодирование длины серий). Расширение RLE имени
файла обычно указывает на то, что произведено сжатие растровой информации файла
одним из двух способов сжатия RLE, которые допустимы для файлов BMP-формата.
В файлах BMP информация о цвете каждого пиксела кодируется 1,
4, 8, 16 или 24 бит (бит/пиксел). Числом бит/пиксел, называемым также глубиной
представления цвета, определяется максимальное число цветов в изображении.
Изображение при глубине 1 бит/пиксел может иметь всего два цвета, а при глубине
24 бит/пиксел - более 16 млн. различных цветов.
Формат собственно данных растрового массива в файле BMP зависит от числа бит,
используемых для кодирования данных о цвете каждого пиксела. При 256-цветном
изображении каждый пиксел в той части файла, где содержатся собственно данные
растрового массива, описывается одним байтом (8 бит). Это описание пиксела не
представляет значений цветов RGB, а служит указателем для входа в таблицу цветов
файла. Таким образом, если в качестве первого значения цвета RGB в таблице цветов файла BMP хранится R/G/B=255/0/0, то значению
пиксела 0 в растровом массиве будет поставлен в соответствие ярко-красный цвет.
Значения пикселов хранятся в порядке их расположения слева направо, начиная
(как правило) с нижней строки изображения. Таким образом, в 256-цветном BMP-файле первый байт данных
растрового массива представляет собой индекс для цвета пиксела, находящегося в
нижнем левом углу изображения; второй байт представляет индекс для цвета
соседнего справа пиксела и т.д. Если число байт в каждой строке нечетно, то к
каждой строке добавляется дополнительный байт, чтобы выровнять данные
растрового массива по 16-бит границам.
Не все файлы BMP имеют структуру одинаковую структуру. Например,
файлы BMP с глубиной 16 и 24 бит/пиксел не имеют таблиц цветов; в этих
файлах значения пикселов растрового массива непосредственно характеризуют
значения цветов RGB. Также могут различаться внутренние форматы хранения отдельных
разделов файла. Например, информация растрового массива в некоторых 16 и
256-цветных BMP-файлах может сжиматься посредством алгоритма RLE, который заменяет
последовательности идентичных пикселов изображения на лексемы, определяющие
число пикселов в последовательности и их цвет. В Windows допускается работа с BMP-файлами стиля OS/2, в которых
используются различные форматы информационного заголовка растрового массива и
таблицы цветов.
Основными элементами файла являются:
- заголовок;
- палитра (если нужна);
- изображение.
1.2.1
Заголовок BMP
Структура BITMAPFILEHEADER, используемая для объявления заголовка
растрового файла bmfHeader, имеет следующее определение:
Рисунок 1.1 - Структура BITMAPFILEHEADER
Поле bfType должно содержать ASCII-символы В и М, которые,
разумеется, означают bitmap. Соответствующие шестнадцатеричные значения
равны 0x42
и 0x4D. При любых других
значениях этого поля файл не будет опознаваться Windows как растровое
изображение. Cлово
типа WORD размещается в памяти, начиная с младшего байта, поэтому, формируя
заголовок, используется инструкция вида bfType = 0x4d42.
Поле bfSize содержит размер всего файла в байтах.
Поле bfOffbits задает байтовое смещение до начала растрового
изображения. Если BMP-файл прочитан в память, то поле bfOffbits позволяет вычислить
адрес начала массива aBitmapBits.
1.2.2
Заголовок информационного блока
После заголовка растрового файла следует заголовок
информационного блока bmi Header,
в котором содержится информация о размерах и цветовом формате
растра.
Соответствующая структура BITMAPINFOHEADER определена в файле wingdi. h:
Рисунок 1.2 - Структура заголовка
Поля
biWidth и biHeight определяют ширину и высоту битового изображения.
Высота
biHeight обычно является положительной величиной, но она может быть и
отрицательной. Знак этого поля определяет порядок следования строк развертки в
массиве пикселов. Положительное значение соответствует обратному порядку строк
(снизу вверх), при котором первый пиксел массива является первым пикселом
последней строки развертки изображения. Такие DIB-растры называют перевернутыми
(bottom-up). Отрицательное значение соответствует прямому порядку строк (сверху
вниз), и такие DIB-растры называют неперевернутыми (top-down). В большинстве
BMP-файлов используется обратный порядок следования строк развертки. Поле bi
Planes задает количество цветовых плоскостей для целевого графического
устройства. В разных устройствах может использоваться различная структура строк
развертки (с одной или несколькими цветовыми плоскостями).
Формат
DIB поддерживает изображения только с одной плоскостью, поэтому поле biPlanes
должно иметь единичное значение.
Поле
biBitCount содержит количество битов, используемых для кодирования цвета одного
пиксела. Иногда эту характеристику называют цветовой глубиной.
1.2.3 Палитра
BMP
Цветовая таблица является массивом структур типа RGBQUAD. Этот тип определен
следующим образом:
Рисунок 1.3 - Структура RGBQUAD
Поля структуры задают относительную интенсивность для синей,
зеленой и красной составляющих цвета пиксела. Последнее поле в структуре
является резервным. Обычно цветовая таблица используется в DIB-растрах,
содержащих не более 256 цветов. В этом случае каждый пиксел массива aBitmapBits
содержит индекс в цветовой таблице. Иногда цветовую таблицу включают и в
DIB-растры формата True Color (Hi Color), что, на первый взгляд, кажется
избыточным. Но это позволяет отображать указанные растры с требуемым качеством
передачи цветов на устройствах, не поддерживающих формат True Color, а работающих
с цветовой палитрой.
Количество элементов в цветовой таблице задается в поле
biCLrUsed заголовка информационного блока. Если это поле имеет нулевое
значение, то используется максимальное количество элементов для заданной
цветовой глубины.
1.2.4 Данные
изображения BMP
Пикселы изображения хранятся в массиве пикселов aBitmapBits.
Если поле biHeight заголовка информационного блока содержит положительное
значение, то строки развертки хранятся в обратном порядке, если же значение
отрицательное - то в прямом порядке.
Пикселы упаковываются внутри строки развертки для экономии
места.
Строки дополняются битами до границы двойного слова.
Количество байтов на строку вычисляется по следующей формуле:
= ( (width * MtCount + 31) / 32) * 4:
где width - ширина изображения в пикселах, a bitCount -
количество бит на пиксел.
Для несжатых растров DIB, у которых поле biCompression имеет
значение BI_RGB, обращение к отдельным пикселам массива является простой
операцией, которая реализуется достаточно эффективно. Массив пикселов
aBitmapBits можно объявить как двумерный, что отражало бы семантику хранения в
нем строк развертки изображения. Однако основные функции отображения DIB в
контексте устройства получают в качестве аргумента адрес одномерного массива.
Поэтому удобней объявлять aBitmapBits как одномерный массив, а прямой доступ к
пикселам осуществлять посредством преобразования пары индексов
"логического" двумерного массива в эквивалентный индекс
"физического" одномерного массива.
2 Описание
алгоритма отображения файла
2.1 Открытие
файла TGAСхематично открытие файла формата TGA представлено на рис.2.1
Рисунок 2.1 - Схема открытия файла.
На рисунке 2.2 приведен алгоритм открытия файла формата TGA. Рассмотрим его
подробнее.
Сначала происходит открытие файла с именем ИмяФайла. tga. В случае возникновения
ошибок при открытии файла пользователю выдается соответствующее сообщение и
далее идет выход из алгоритма.
Далее считывается Заголовок (см. 1.1.2) из файла. Проверяются
полученные данные.
Рисунок 2.2 - Алгоритм открытия файла формата TGA.
После этого определяется тип изображения, содержащегося в
файле. Если это изображение типа, не поддерживаемого системой, то после вывода
соответствующего сообщения алгоритм завершает свою работу.
При наличии в изображении палитры (см.1.1.3) значения ее
цветов читаются из файла и далее читаются данные изображения (см.1.1.4),
которые представляют собой 8-ми битные индексы цветов в палитре.
Если в файле отсутствует палитра, то происходит чтение данных
изображения, содержащих в себе цвет каждого пикселя.
После получения всех необходимых данных для отображения
изображения файл закрывается.
2.2 Открытие
файла BMP
Открытие BMP файла осуществляется методом LoadFromFile, который загружает BMP-файл с заданным именем,
считывая его с диска в оперативную память. В процессе загрузки сначала читается
заголовок растрового файла, затем вычисляются размер заголовка информационного
блока в совокупности с цветовой таблицей, который указывается в поле infoHeadSize.
Помимо этого в поле imageSize указывается вычисленный размер
изображения в байтах. Полученные величины используются для указания размеров
динамически выделяемой памяти под заголовок информационного блока plnfoHead и под массив пикселов aBitmapBits. После выделения
указанной памяти соответсвующие компоненты растра читаются из файла.
На рисунке 2.3 показан алгоритм реализации чтения BMP файла.
2.3
Отображение изображения
Алгоритм отображения изображения представлен на рисунке
Рисунок 2.3 - Алгоритм чтения BMP файла
Рисунок 2.4 - Алгоритм отображение файла
3. Описание
алгоритмов реализации эффектов
В данной работе приведена реализация простейших спецэффектов
зашумления одной из составляющих и фильтрации изображения, алгоритмы которых
представлены ниже.
.1 Зашумление
составляющей B
Алгоритм зашумления изображения по составляющей B представлен на рисунке
3.1.
Рисунок 3.1 - Алгоритм зашумления изображения по B
Для того чтобы зашумить составляющую B в изображении необходимо
если в файле есть палитра, то к каждому цвету палитры параметра B прибавить заданный шум.
Если в файле нет палитры, то каждый пиксель нужно разложить
на RGB, прибавить к B заданный шум, вернуть
пиксель в предыдущий формат и сохранить полученное значение.
В случае если полученное значение составляющей B выходит за границы допустимого
его корректируют в зависимости от максимально и минимально возможного для
значения пикселя данного размера.
3.2
Зашумление составляющей S
Алгоритм зашумления изображения составляющей S представлен на рисунке
3.2.
Рисунок 3.2 - Алгоритм зашумления составляющей S.
Данные в программе хранятся в базисе RGB и для зашумления
составляющей S
базиса HLS необходимо выполнить преобразование цвета каждого пикселя из
базиса RGB в базис HLS, которое выполняет процедура RGB_to_HLS. Далее требуется
выполнить зашумление составляющей S, прибавлением к ней шума, заданного
пользователем, и обратное преобразование из одного базиса в другой, выполняемое
функцией HLS_to_RGB.(Hue, Lightness, Saturation - цветовой тон, светлота,
насыщенность) - модель ориентированная на человека и обеспечивающая возможность
явного задания требуемого оттенка цвета (рис.3.3). Эта модель образует
подпространство, представляющее собой двойной конус, в котором черный цвет
задается вершиной нижнего конуса и соответствует значению L = 0, белый цвет
максимальной интенсивности задается вершиной верхнего конуса и соответствует
значению L = 1. Максимально интенсивные цветовые тона соответствуют основанию
конусов с L = 0.5, что не совсем удобно.
Рисунок 3.3 - Представление HLS
Цветовой тон H, аналогично системе HSV, задается углом поворота.
Насыщенность S меняется в пределах от 0 до 1 и задается
расстоянием от вертикальной оси L до боковой поверхности конуса. Т.е.
максимально насыщенные цветовые цвета располагаются при L=0.5, S=1.
В общем, систему HLS можно представить как полученную из HSV
"вытягиванием" точки V=1, S=0, задающей белый цвет, вверх для
образования верхнего конуса.
Формулы перевода из RGB в HLS:
Формулы перевода из HLS в RGB:
3.3
Фильтрация изображения
Для реализации фильтрации изображения использовался фильтр,
который задается матрицей 3x3. Матрица изображена на рис.3.4
Рисунок 3.4 - Матрица фильтра 4
Рисунок 3.5 - Алгоритм фильтрации изображения.
Изображение покрывается этой матрицей, в цикле попиксельно.
При этом каждый элемент матрицы складывается с каждой составляющей
соответствующего пикселя. При чем, если составляющая выходит за рамки 0.255, то
она приравнивается к ближайшей границе этого интервала.
Алгоритм фильтра представлен на рис.3.5
4. Описание
программы для работы с графическими форматами
4.1 Выбор
средств для описания программы
Данный программный продукт реализован на объектно-ориентированном
языке С++, в оболочке программирования Microsoft Visual C++ 2005.
Эта оболочка выбрана потому, что она являются наиболее
простым, и в то же время мощным, инструментальным средством для создания
32-разрядных приложений Windows. Эти приложения намного превосходят как по
объёму, так и по сложности своих предшественников для 16-разрядной Windows и ещё более древние
программы, которые вообще обходились без графического интерфейса. Но, несмотря
на то что, объём и сложность программ увеличиваются, для их создания от
программиста требуется не больше, а меньше усилий, по крайней мере для тех, кто
правильно выбирает инструментальные средства.
Именно таким инструментом является Microsoft Visual C++ 2005. Оснащённый
набором разнообразных мастеров (Wizard), формирующих программный код, этот продукт
позволяет с считанные секунды создать работоспособное приложение Windows. Включённая в состав Microsoft Visual C++ 2005 библиотека
классов Microsoft Foundation Classes (MFC) уже стала фактически
стандартом для разработчиков компиляторов C++. Визуальные средства
разработки интерфейса пользователя превращают процесс компоновки разнообразных
меню и диалоговых окон в увлекательную игру. Программные продукты созданные в Microsoft Visual C++ 2005 просты в
использовании и не требуют глубоких знаний от пользователей работающих с ними.
В настоящее время для Microsoft Visual C++ 2005 существует
большое количество библиотек классов, различных программных функций, открытых
программных кодов.
Язык С++ был выбран потому, что он наиболее эффективен, при
решении задач системного программирования и при написании прикладных программ.
Среди преимуществ языка можно отметить переносимость программ на компьютеры
различной архитектуры и из одной операционной системы в другую, лаконичность записи
алгоритмов, логическую стройность, возможность получить эффективный код
программ, сравнимых по скорости с программами написанными на ассемблере. Язык
С++ очень удобен, т.к. имеет полный набор конструкций структурного
программирования, поддерживающим модуальность, блочную структуру программ,
возможность раздельной компиляции модулей. В то же самое время он имеет набор
низкоуровневых средств, позволяющих иметь удобный доступ к аппаратным средствам
компьютера, в частности позволяющих добраться до каждого бита памяти.
4.2 Структуры
данных
В данной курсовой работе реализованы 3 класса: KWnd, KDib, Tga. Класс KWnd, в котором
инкапсулируется код, отвечает за регистрацию оконного класса, создание окна и
показ его на экране. Заголовок конструктора класса KWnd содержит 12 параметров.
Первые четыре параметра являются обязательными, а остальные имеют значения по
умолчанию.
Четвертый параметр является указателем на функцию,
принимающую четыре аргумента и возвращающую значение типа LRESULT. Здесь
обязателен спецификатор WINAPI или эквивалентный ему спецификатор stdcall. Класс KDib предназначен для работы
с файлом BMP. Реализация класса показана на рисунке 4.1.
Рисунок 4.1 - Интерфейс класса KDib
Кроме традиционных для класса методов, таких как конструктор
и деструктор, класс KDib содержит методы, перечисленные ниже:
) Метод CreateDib24 создает в памяти 24-разрядный растр с
заданными шириной и высотой. В процессе создания осуществляется инициализация
полей заголовка растрового файла и заголовка информационного блока. После этого
выделяется память для хранения массива пикселов. В завершение открывается
дисковый файл с заданным именем, предназначенный для сохранения в нем
создаваемого растра.
) Метод SetPixel осуществляет прямой доступ к пикселам в
24-разрядном растре. Цветовая информация для синей, зеленой и красной
составляющих цвета пиксела записывается в соответствующие элементы массива aBitmapBits. Адреса элементов
вычисляются через номер строки развертки у и номер пиксела в строке х.
) Метод StoreDib24 сохраняет созданный растр, записывая его на
диск в формате BMP.
) Метод LoadFromFile загружает BMP-файл с заданным именем,
считывая его с диска в оперативную память. В процессе загрузки сначала читается
заголовок растрового файла, затем вычисляются размер заголовка информационного
блока в совокупности с цветовой таблицей, который указывается в поле infoHeadSize. Помимо этого в поле imageSize указывается вычисленный
размер изображения в байтах. Полученные величины используются для указания
размеров динамически выделяемой памяти под заголовок информационного блока plnfoHead и под массив пикселов aBitmapBits. После выделения
указанной памяти соответствующие компоненты растра читаются из файла.
) Метод Draw выводит растр на поверхность графического
устройства, используя функцию StretchDIBits.
Класс Tga предназначен для работы с файлами Tga. Кроме традиционных для
класса методов, таких как конструктор и деструктор, класс Tga содержит методы,
перечисленные ниже:
) Метод LoadFromFile загружает Tga-файл с заданным именем,
считывая его с диска в оперативную память. В процессе загрузки сначала читается
заголовок файла. Помимо этого в поле imageSize указывается вычисленный размер
изображения в байтах. Полученные величины используются для указания размеров
динамически выделяемой памяти под массив пикселов aBitmapBits. После выделения
указанной памяти соответствующие компоненты читаются из файла.
) Метод Draw выводит содержимое Tga-файла на поверхность
графического устройства, используя функцию SetPixel.
) Метод RgbToHls переводит даныые изображения из RGB в HLS.
) Метод HlsToRgb переводит данные изображения из HLS в RGB.
) Метод NoiseB зашумляет составляющую B
) Метод NoiseS переводит данные изображения из RGB в HLS, зашумляет составляющую S и обратно переводит из HLS в RGB.
) Метод Filter применяет фильтр "размытие" к
изображению.
4.3 Основные
модули, их назначение и взаимодействие
Основные модули программы и их назначение:
KWnd. cpp - содержит основные функции и глобальные
переменные создания, регистрации и показа главного окна приложения;
KDib. cpp - модуль, содержащий функции для открытия
файлов, сохранения, показа на экран формата TGA и BMP. В этом файле описаны
реализации классов KDib и Tga для работы с соответсвующими файлами;
TgaToBmp. cpp - содержит основные функции и глобальные
переменные для работы приложения и главного окна. В нем вызываются все методы
классов KDib и Tga;
Resource. h - файл ресурса, в котором прописано меню и элементы
управления.
Структура модулей программы представлена на рисунке 4.2.
Рисунок 4.2 - Структура модулей программы.
4.4 Перечень
процедур и функций в модулях
В таблице 4.1 представлены поля класса KDib и их назначение.
Таблица 4.1 Поля класса KDib.
|
Поле
|
Тип
|
Назначение
|
|
aBitmapBits
|
BYTE*
|
Массив пикселов
|
|
Width
|
INT
|
Ширина
изображения
|
|
Height
|
INT
|
Высота
изображения
|
|
bytesPerLine
|
INT
|
Кол - во байт в
строке изображения
|
|
fileHead
|
BITMAPFILEHEADER
|
Заголовок
растрового файла
|
|
infoHead
|
BITMAPFILEHEADER
|
Заголовок
информационного блока
|
|
pInfoHead
|
BITMAPFILEHEADER*
|
Указатель на
инфоблок
|
|
fileHeadSize
|
INT
|
Размер
заголовка
|
|
infoHeadSize
|
INT
|
Размер
информационного блока
|
|
imageSize
|
INT
|
Размер
изображения
|
|
Error
|
STRING
|
Сообщение об
ошибке
|
|
outFile
|
Ofstream
|
Имя выходного
файла
|
В таблице 4.2 представлены поля класса Tga и их назначение.
Таблица 4.2 Поля класса TGA.
|
Поле
|
Тип
|
Назначение
|
|
aBitmapBits
|
BYTE*
|
Массив пикселов в RGB
|
|
aBitmapHLS
|
BYTE*
|
Массив пикселов
в HLS
|
|
idlength
|
CHAR
|
Длина текстовой
информации после первого 18-ти байтового блока. Может быть использована для
описания файла
|
|
colourmaptype
|
CHAR
|
Идентификатор
наличия цветовой карты
|
|
Datatypecode
|
CHAR
|
Тип данных -
запакованный или нет
|
|
Colourmaporigin
|
INT
|
Информация о
цветовой карте
|
|
Colourmaplength
|
INT
|
Информация о
цветовой карте
|
|
Colourmapdepth
|
CHAR
|
Информация о цветовой
карте
|
|
X_origin
|
INT
|
Начало
изображения по оси X
|
|
Y_origin
|
INT
|
Начало
изображения по оси Y
|
|
Width
|
INT
|
Ширина
изображения
|
|
Height
|
INT
|
Высота
изображения
|
|
Bitsperpixel
|
CHAR
|
Кол-во бит на
пиксель - здесь только 24 или 32
|
|
Imagedescriptor
|
CHAR
|
Описание
|
|
imageSize
|
INT
|
Размер
изображения
|
|
Error
|
STRING
|
Сообщение об
ошибке
|
|
outFile
|
Выходной файл
|
Описание методов класса KDib приведено в таблице 4.3.
Таблица 4.3 Методы класса KDib.
|
Метод
|
Тип
|
Назначение
|
|
CreateDib24
|
BOOL
|
Создает BMP - файл
|
|
StoreDib24
|
VOID
|
Пересылка
данных изображения
|
|
LoadFromFile
|
BOOL
|
Загружает BMP - файл
|
|
SetPixel
|
VOID
|
Устанавливает
пиксель в контексте
|
|
Draw
|
INT
|
Вывод на экран
изображения
|
|
GetWidth
|
INT
|
Возвращает
ширину
|
|
GetHeight
|
INT
|
Возвращает
высоту
|
|
GetError
|
CHAR*
|
Возвращает
ошибку
|
Описание методов класса Tga приведено в таблице 4.4.
Таблица 4.4 Методы класса Tga.
|
Метод
|
Тип
|
Назначение
|
|
RgbToHls
|
VOID
|
Переводит из RGB в HLS
|
|
HlsToRgb
|
VOID
|
Переводит из HLS в RGB
|
|
LoadFromFile
|
BOOL
|
Загружает BMP - файл
|
|
GetA
|
BYTE*
|
Возвращает
массив пикселов
|
|
Draw
|
INT
|
Вывод на экран
изображения
|
|
GetWidth
|
INT
|
Возвращает
ширину
|
|
GetHeight
|
INT
|
Возвращает
высоту
|
|
NoiseB
|
VOID
|
Зашумляет B
|
|
NoiseS
|
VOID
|
Защумляет S
|
|
Filter
|
VOID
|
Фильтрует
|
5.
Тестирование, результаты работы программы
Программа написана под операционную систему от Windows XP до Windows VISTA. Для установки системы
нет необходимости в особых настройках.
Требования к аппаратной платформе - процессор должен быть
типа Pentium или Celeron с тактовой частотой не ниже 166 МГц (рекомендуется
Pentium III
800 МГц), оперативной памяти - 512 Мбайт (рекомендуется 1024 Мбайт),
достаточное количество свободного дискового пространства всего 50 Mб.
Тестирование функции NoiseS методом граничных
значений, представлено в таблице 5.1
Таблица 5.1 - Тестирование функции NoiseS.
|
Входные данные
|
Результат
|
Сообщения
|
|
S
|
Pixel
|
R
|
G
|
B
|
|
|
0
|
0
|
Pal
[Pixel]
|
Pal
[Pixel]
|
Pal
[Pixel]
|
-
|
|
1
|
-1
|
0
|
0
|
0
|
Ошибка.
|
|
1
|
256
|
0
|
0
|
0
|
Ошибка
|
|
256
|
111
|
Pal
[Pixel]
|
Pal
[Pixel]
|
Pal
[Pixel]
|
Ошибка
|
|
1
|
0
|
0
|
0
|
0
|
|
|
1
|
-1
|
255
|
255
|
255
|
|
В результате была разработана программа, имеющая интерфейс,
удобный и простой для пользователя, выполняющая открытие, сохранение файлов
графических форматов TGA и BMP, и реализующая спецэффекты.
Выводы
В результате работы было создано приложение, которое
позволяет осуществлять загрузку графического формата TGA. Также осуществляет
сохранение изображений в формате BMP. К открытому изображению можно применить
специальные эффекты, такие как зашумление цветовых составляющих (B,S), применение фильтра
задающегося матрицей 3х3.
Самым простым в реализации оказался формат BMP, единственным
неудобством этого формата является сохранение строк развертки в обратном
порядке.
Формат TGA, как и BMP отличается несложной структурой организации
данных. Из множества видов кодирования - алгоритм RLE ввиду своей простоты,
обеспечивает не всегда эффективное сжатие изображения.
В результате выполнения работы были изучены различные виды
хранения графической информации, алгоритмы ее сжатия и отображения.
Приложение Б Руководство пользователя
После загрузки приложения необходимо выбрать файл для
просмотра. В окне навигации осуществляется перемещение по каталогам и выбор
файлов. После выбора файла происходит его автоматическое распознавание и
загрузка файла. После этого становятся доступными соответствующие функции
программы. Пример меню можно посмотреть на рис. Б.1
При работе с файлами изображений доступны функции:
открытие файла в формате TGA (Файл - > Открыть TGA);
открытие файла в формате BMP (Файл - > Открыть BMP);
сохранение файла в формат BMP (Файл - > Сохранить
как BMP);
применение фильтра (Эффекты - > Отфильтровать фильтром);
зашумить составляющую B (Эффекты - >Зашумить
составляющую B);
зашумить составляющую S (Эффекты - > Зашумить
составляющую S);
выход из программы (Файл - > Выход);
просмотр открытого изображения TGA файла (Просмотр->TGA файл);
просмотр открытого изображения BMP файла (Просмотр->BMP файл);
просмотреть информацию о программе (Справка - > О
программе)
Рисунок Б.1 - Главное меню программы
Вывод изображения осуществляется в главное окно программы.
Приложение
Листинг программы
#include <windows. h>
#include <fstream>
#include <string>namespace std;KDib {:* aBitmapBits; //
массив пикселов();
~KDib ();CreateDib24 (int w, int h, const char*
fileName);StoreDib24 ();LoadFromFile (const char* fileName);SetPixel (int x,
int y, COLORREF color);Draw (HDC hdc, int xDst, int yDst, int wDst, int
hDst,xSrc, int ySrc, int wSrc, int hSrc, DWORD rop);GetWidth () { return width;
}GetHeight () { return height; }char* GetError () { return error. c_str ();
}:width;height;bytesPerLine;fileHead; // заголовок растрового файлаinfoHead; //
заголовок информационного блока*
pInfoHead;fileHeadSize;infoHeadSize;imageSize;error;outFile;
};Tga {:idlength;colourmaptype;datatypecode;int
colourmaporigin;int colourmaplength;colourmapdepth;int x_origin;int
y_origin;width;height;bitsperpixel;imagedescriptor;imageSize;error;outFile;:*
aBitmapBits; // массив пикселов* aBitmapHLS; // массив пикселов();
~Tga ();GetWidth () { return width; }GetHeight () { return
height; }LoadFromFile (char* fileName);Draw (HDC hdc,BYTE*
aBitmapBits);RgbToHls ();HlsToRgb ();NoiseB ();NoiseS ();Filter ();TransformPix
(int x, int y);* GetA ();
};
// // // // // // // // // // // // // // // // // // // //
// // // // // // // // // //
// KWnd. h
#include <windows. h>KWnd {:(LPCTSTR windowName,
HINSTANCE hInst, int cmdShow,(WINAPI *pWndProc)
(HWND,UINT,WPARAM,LPARAM),menuName = NULL,x = CW_USEDEFAULT, int y = 0,int width
= CW_USEDEFAULT, int height = 0,UINT classStyle = CS_HREDRAW |
CS_VREDRAW,windowStyle = WS_OVERLAPPEDWINDOW,hParent = NULL);GetHWnd () {
return hWnd; }:hWnd;wc;
};
// {{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by TgaToBmp1. rc
//
#define IDR_MENU1 101
#define ID_40001 40001
#define ID_40002 40002
#define ID_40003 40003
#define ID_40004 40004
#define ID_40005 40005
#define ID_40006 40006
#define ID_40007 40007
#define ID_40008 40008
#define ID_40009 40009
#define ID_40010 40010
#define ID_40011 40011
#define ID_40012 40012
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 102
#define _APS_NEXT_COMMAND_VALUE 40013
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
// // // // // // // // // // // // // // // // // // // //
// // // // // // // // // //
// KWnd. cpp
#include "KWnd. h"
#include "resource1. h":: KWnd (LPCTSTR windowName,
HINSTANCE hInst, int cmdShow,(WINAPI *pWndProc)
(HWND,UINT,WPARAM,LPARAM),menuName, int x, int y, int width, int
height,classStyle, DWORD windowStyle, HWND hParent)
{szClassName [] = "KWndClass";. cbSize = sizeof
(wc);. style = classStyle;. lpfnWndProc = pWndProc;. cbClsExtra = 0;.
cbWndExtra = 0;. hInstance = hInst;. hIcon = LoadIcon (NULL, IDI_APPLICATION);.
hCursor = LoadCursor (NULL, IDC_ARROW);. hbrBackground = (HBRUSH)
GetStockObject (WHITE_BRUSH);. lpszMenuName = MAKEINTRESOURCE (IDR_MENU1); // menuName;.
lpszClassName = szClassName;. hIconSm = LoadIcon (NULL, IDI_APPLICATION);
// Регистрируем класс окна(! RegisterClassEx (&wc)) {msg
[100] = "Cannot register class: ";(msg, szClassName);(NULL, msg,
"Error", MB_OK);;
}=640; height=480;
// Создаем окно= CreateWindow (szClassName, windowName,
windowStyle,, y, width, height, hParent, (HMENU) NULL, hInst, NULL);(! hWnd)
{text [100] = "Cannot create window: ";(text, windowName);(NULL,
text, "Error", MB_OK);;
}
// Показываем окно(hWnd, cmdShow);
}
// KDib. cpp
#include "KDib. h"
#include <math. h>:: KDib () {= sizeof
(BITMAPFILEHEADER);. bfType = 0x4d42;= NULL;
}:: ~KDib () {(pInfoHead) delete [] pInfoHead;(aBitmapBits)
delete [] aBitmapBits;(outFile) outFile. close ();
}KDib:: CreateDib24 (int w, int h, const char* fileName) {=
w;= h;= ( (width * 24 + 31) / 32) * 4;= bytesPerLine * height;= sizeof
(BITMAPINFOHEADER);. bfSize = fileHeadSize + infoHeadSize + bytesPerLine *
height;. bfOffBits = fileHeadSize + infoHeadSize;. biSize = infoHeadSize;.
biWidth = width;. biHeight = - height;. biPlanes = 1;. biBitCount = 24;.
biCompression = BI_RGB;. biSizeImage = imageSize;= new BYTE
[imageSize];(aBitmapBits, 0, imageSize);. open (fileName, ios:: out | ios::
binary | ios:: trunc);(! outFile) return FALSE;return TRUE;
}KDib:: LoadFromFile (const char* fileName) {inpFile;. open
(fileName, ios:: in | ios:: binary);(! inpFile) {= "Неверное имя файла или
каталога. ";FALSE;
}. read ( (char*) &fileHead, fileHeadSize);(fileHead.
bfType! = 0x4d42) {= "Это не BMP-файл";FALSE;
}= fileHead. bfOffBits - fileHeadSize;fileSize = fileHead.
bfSize;= fileSize - (fileHeadSize + infoHeadSize);= (BITMAPINFOHEADER*) (new
BYTE [infoHeadSize]);. read ( (char*) pInfoHead,
infoHeadSize);=pInfoHead->biWidth;= pInfoHead->biHeight;= new BYTE [imageSize];.
read ( (char*) aBitmapBits, imageSize);true;
}KDib:: Draw (HDC hdc, int xDst, int yDst, int wDst, int
hDst,xSrc, int ySrc, int wSrc, int hSrc, DWORD rop) {StretchDIBits (hdc, xDst,
yDst, wDst, hDst, xSrc, ySrc, wSrc, hSrc,, (CONST BITMAPINFO*) pInfoHead,
DIB_RGB_COLORS, rop);
}KDib:: SetPixel (int x, int y, COLORREF color) {row = y;col
= 3 * x;[row*bytesPerLine + col] = GetBValue (color);[row*bytesPerLine + col+1]
= GetGValue (color);[row*bytesPerLine + col+2] = GetRValue (color);
}KDib:: StoreDib24 () {
// Запись заголовка BMP-файла. write ( (char*) &fileHead,
fileHeadSize);. write ( (char*) &infoHead, infoHeadSize);
// Запись массива пикселей. write ( (char*) aBitmapBits,
imageSize);
}:: Tga () {=
NULL;='0';='0';='0';=0;=0;='0';_origin=0;_origin=0;=0;=0;='0';='0';=0;
}:: ~Tga () {}Tga:: LoadFromFile (char* fileName) {inpFile;.
open (fileName, ios:: in | ios:: binary);(! inpFile) {= "Неверное имя
файла или каталога. ";FALSE;
}. read ( (char*) &idlength,1);. read ( (char*)
&colourmaptype,1);. read ( (char*) &datatypecode,1);. read ( (char*)
&colourmaporigin,2);. read ( (char*) &colourmaplength,2);. read (
(char*) &colourmapdepth,1);. read ( (char*) &x_origin,2);. read (
(char*) &y_origin,2);. read ( (char*) &width,2);. read ( (char*)
&height,2);. read ( (char*) &bitsperpixel,1);. read ( (char*)
&imagedescriptor,1);= width * height*3;= new BYTE [imageSize];. read (
(char*) aBitmapBits, imageSize);. close ();true;
}Tga:: Draw (HDC hdc,BYTE* aBitmapBits) {x = GetWidth ();y =
GetHeight ();bytesPerLine = ( (x * 24 + 31) / 32) * 4;(int row = 0; row < y;
row++)(int col = 0; col < x; col++) {(hdc,col,row,RGB (aBitmapBits
[row*bytesPerLine + col*3+2],[row*bytesPerLine + (col*3) +1],[row*bytesPerLine
+ (col*3)]));
}
}* Tga:: GetA () {aBitmapBits;
}Tga:: RgbToHls () {R,G,B,H,L,S;x = GetWidth ();y = GetHeight
();bytesPerLine = ( (x * 24 + 31) / 32) * 4;= x * y * 3;= new BYTE
[imageSize];(int row = 0; row < y; row++)(int col = 0; col < x; col++) {=
aBitmapBits [row*bytesPerLine + col*3 + 2];= aBitmapBits [row*bytesPerLine +
(col*3) + 1];= aBitmapBits [row*bytesPerLine + (col*3)];= (BYTE) sqrt (
(double) (R*R + G*G + B*B - R*G - B*G - R*B));= (R + G + B) /3;= (BYTE) asin
(sqrt (3.0/2.0) * (G - R) / S);[row*bytesPerLine + (col*3)] =
S;[row*bytesPerLine + (col*3) + 1] = L;[row*bytesPerLine + col*3 + 2] = H;
}
}Tga:: HlsToRgb () {R,G,B,H,L,S;x = GetWidth ();y = GetHeight
();bytesPerLine = ( (x * 24 + 31) / 32) * 4;(int row = 0; row < y;
row++)(int col = 0; col < x; col++) {= aBitmapHLS [row*bytesPerLine + col*3
+ 2];= aBitmapHLS [row*bytesPerLine + (col*3) + 1];= aBitmapHLS
[row*bytesPerLine + (col*3)];= L - (1/3) *S*cos ( (double) H) - (1/sqrt (3.0))
*S*sin ( (double) H);= L + (2/3) *S*cos ( (double) H);= L - (1/3) *S*cos (
(double) H) + (1/sqrt (3.0)) *S*sin ( (double) H);[row*bytesPerLine + (col*3)]
= B;[row*bytesPerLine + (col*3) + 1] = G;[row*bytesPerLine + col*3 + 2] = R;
}
}Tga:: NoiseB () {B;x = GetWidth ();y = GetHeight
();bytesPerLine = ( (x * 24 + 31) / 32) * 4;(int row = 0; row < y;
row++)(int col = 0; col < x; col++) {= aBitmapBits [row*bytesPerLine +
(col*3)];+=rand ();(B < 0) B = 0;(B > 255) B = 255;[row*bytesPerLine +
(col*3)] = B;
}
}Tga:: NoiseS () {S;x = GetWidth ();y = GetHeight
();bytesPerLine = ( (x * 24 + 31) / 32) * 4;(int row = 0; row < y;
row++)(int col = 0; col < x; col++) {= aBitmapHLS [row*bytesPerLine +
(col*3)];+=rand ();(S < 0) S = 0;(S > 255) S = 255;[row*bytesPerLine +
(col*3)] = S;
}
}Tga:: TransformPix (int x, int y) {NewBGR [3];Pixel [3];Pix
[3];w = GetWidth ();h = GetHeight ();count = 9;Matrix [9]
={1,1,1,1,1,1,1,1,1};bytesPerLine = ( (w * 24 + 31) / 32) * 4;
// x y(int c = 0; c < 3; c++) {[c] = aBitmapBits
[y*bytesPerLine + x*3 + c];[c] = NewBGR [c] * Matrix [4];
}
// x-1 y-1(int c = 0; c < 3; c++) {[c] = aBitmapBits [
(y-1) *bytesPerLine + (x-1) *3 + c];[c] += NewBGR [c] * Matrix [0];
}
// x y-1(int c = 0; c < 3; c++) {[c] = aBitmapBits
[y*bytesPerLine + (x-1) *3 + c];[c] += NewBGR [c] * Matrix [1];
}
// x+1 y-1(int c = 0; c < 3; c++) {[c] = aBitmapBits [
(y+1) *bytesPerLine + (x-1) *3 + c];[c] += NewBGR [c] * Matrix [2];
}
// x+1 y(int c = 0; c < 3; c++) {[c] = aBitmapBits [ (y+1)
*bytesPerLine + x*3 + c];[c] += NewBGR [c] * Matrix [5];
}
// x+1 y+1(int c = 0; c < 3; c++) {[c] = aBitmapBits [
(y+1) *bytesPerLine + (x+1) *3 + c];[c] += NewBGR [c] * Matrix [8];
}
// x y+1(int c = 0; c < 3; c++) {[c] = aBitmapBits
[y*bytesPerLine + (x+1) *3 + c];[c] += NewBGR [c] * Matrix [7];
}
// x-1 y+1(int c = 0; c < 3; c++) {[c] = aBitmapBits [
(y-1) *bytesPerLine + (x+1) *3 + c];[c] += NewBGR [c] * Matrix [6];
}
// x-1 y(int c = 0; c < 3; c++) {[c] = aBitmapBits [ (y-1)
*bytesPerLine + x*3 + c];[c] += NewBGR [c] * Matrix [3];
}(int c = 0; c < 3; c++) {(count! =0)[c] = Pixel [c]
/count;[c] = BYTE (Pixel [c]);(Pix [c] < 0)[c] = 0;if (Pix [c] > 255)[c]
=255;[y*bytesPerLine + x*3 + c] = Pix [c];
}
}Tga:: Filter () {w = GetWidth ();h = GetHeight ();= w * h *
4;= new BYTE [imageSize];(int y = 1; y < h-1; y++)(int x = 1; x < w-1;
x++) {(x,y);
}= aBitmapHLS;
}
// // // // // // // // // // // // // // // // // // // //
// // // // // // // // // // // // // // //
// TgaToBmp. cpp
#include <windows. h>
#include <stdio. h>
#include "KWnd. h"
#include "KDib. h"
#include "resource1. h"bmp;tga;CALLBACK WndProc
(HWND, UINT, WPARAM, LPARAM);
// ====================================================WINAPI
WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int
nCmdShow)
{msg;mainWnd ("TgaToBmp", hInstance, nCmdShow,
WndProc);(GetMessage (&msg, NULL, 0, 0)) {(&msg);(&msg);
}msg. wParam;
}
//
====================================================CALLBACK WndProc (static
HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{hDC;ps;rect;dX, dY;tm;ws, hs, wd, hd;sz;int width,
height;color;x, y;isFileCreated;BOOL isFileLoadedT=false;BOOL
isFileLoaded=false;success;BOOL view=false;
// Переменные для стандартных диалогов "Open",
"Save as"OPENFILENAME ofn;char szFile [MAX_PATH];char szFileTitle
[256];char szFilter [256] ="Файлы TGA\0*. tga\0Файлы BMP\0*. bmp\0";(uMsg)
{WM_CREATE:= GetDC (hWnd);
// Инициализация структуры ofn. lStructSize = sizeof
(OPENFILENAME);. hwndOwner = hWnd;. nFilterIndex = 1;. lpstrFile = szFile;.
nMaxFile = sizeof (szFile);. lpstrInitialDir =". \TgaToBmp";
// Подогнать размеры окна программы под размер растра
bmp(hWnd, &rect);= 640 - rect. right;= 480 - rect. bottom;(hWnd,
&rect);(&rect, dX/2, dY/2);(hWnd, rect. left, rect. top,. right-rect.
left, rect. bottom-rect. top, TRUE);(hWnd, hDC);;WM_COMMAND:(LOWORD (wParam))
{ID_40001: // Открыть TGA(szFile, "");.
lpstrFilter=szFilter;= GetOpenFileName (&ofn);(success) {
// MessageBox (hWnd, ofn. lpstrFile, "Открывается
файл:", MB_OK);= tga. LoadFromFile (ofn. lpstrFile);(! isFileLoadedT)
{(hWnd, "Файл TGA не загружен.", "Error", MB_OK);;
}
}