Представление графических данных. 
Преобразование форматов. 
Использование специальных эффектов

• Введение
• 1 Описание графических форматов файла
• 1.1 Формат TGA
• 1.1.1 Структура
• 1.1.3 Цветовая таблица
• 1.1.4 Данные изображения
• 1.2 Формат BMP
• 1.2.1 Заголовок BMP
• 1.2.2 Заголовок информационного блока
• 1.2.3 Палитра BMP
• 1.2.4 Данные изображения BMP
• 2 Описание алгоритма отображения файла
• 2.1 Открытие файла TGAСхематично открытие файла формата TGA представлено на рис. 2.1.
• 2.2 Открытие файла BMP
• 2.3 Отображение изображения
• 3. Описание алгоритмов реализации эффектов
• 3.1 Зашумление составляющей B
• 3.2 Зашумление составляющей S
• 3.3 Фильтрация изображения
• 4. Описание программы для работы с графическими форматами
• 4.1 Выбор средств для описания программы
• 4.2 Структуры данных
• 4.3 Основные модули, их назначение и взаимодействие
• 4.4 Перечень процедур и функций в модулях
• 5. Тестирование, результаты работы программы
• Выводы
• Приложение

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

У каждого устройства вывода (монитор, принтер, офсетная печатная машина и т. д.) есть свои возможности по цветовому охвату (не любой цвет можно воспроизвести). Например, на бумаге соотношение по светлоте между белым и чёрным достигает 40, в то время как у слайда оно более 200. Основной задачей является передать замысел автора с наименьшими потерями. Выполняется цветоделение — определение количества каждой краски для передачи каждого цвета. Специалист, подготавливая фотографии к публикации в печати, на телевидении, в Интернете, действуя творчески, как художник или используя стандартные методы, приводит изображение к виду, соответствующему техническим возможностям репродуцирующего процесса.

Сегодня редактирование аналоговых и цифровых изображений проводится в основном на компьютере растровыми редакторами в цифровом виде. Программы для просмотра и простой обработки изображений часто поставляются вместе с цифровыми фотоаппаратами. Более сложные и мощные программы (Adobe Photoshop, Corel PHOTO-PAINT, Paint Shop Pro, Microsoft Picture It!, Visualizer Photo Studio, Pixel image editor, PixBuilder Photo Editor, Fo2Pix ArtMaster, GIMP и пр.) нужно приобретать отдельно. Современные редакторы не лишены недостатков, однако грамотное их использование позволяет решить большинство задач, возникающих при редактировании изображений. Они могут, в какой-то степени, исправлять технические дефекты, допущенные при проведении фотосъемки.

1. Описание графических форматов файла

В данной курсовой работе программно реализована работа с двумя графическими форматами — TGA и BMP. Рассмотрим подробнее каждый из них.

1.1 Формат TGA

1.1.1 Структура

Графические файлы формата TGA имеют следующую структуру:

заголовок;

необязательное поле идентификации изображения;

необязательная цветовая таблица;

растровые данные.

Рассмотрим каждую часть более подробно.

1.1.2 Заголовок

Заголовок файла формата TGA имеет структуру, представленную в таблице 1.1.

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

ColorMapType — определяет наличие цветовой таблицы. Если это поле равно 1 — таблица есть, 0 — нет, если лежит в пределах от 2 до 255 — таблица есть, но формат ее понятен только программе, создавшей файл.

Таблица 1.1 — Структура заголовка файла TGA

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

Следующие три поля (CMapStart, CMapLength и CMapDepth) составляют спецификацию цветовой таблицы. Содержащаяся в них информация используется для манипуляции цветовой таблицей изображения. Если значение поля ColorMapType равно 0, то и эти поля должны иметь нулевые значения.

Поле CMapStart определяет смещение первого элемента цветовой таблицы. Хотя все элементы таблицы записываются непрерывно, однако начинаться они могут в любом ее месте (например, 16-цветные величины могут быть записаны в 64-элементной цветовой таблице, начиная с элемента 31, а не с элемента 0).

Таблица 1.2 — Типы изображений

Поле CMapLength хранит сведения о количестве элементов в цветовой таблице. Если изображение содержит только 57 цветов, то, используя это поле, можно построить 57-элементную таблицу.

Поле CMapDepth определяет количество битов в каждом элементе таблицы. Обычно оно имеет значения 15, 16, 24 или 32.

ImageDesc — Описание изображения. Несет в себе следующую информацию:

7−6 биты — резерв, всегда 0;

4−5 биты — определяют позицию начала изображения. Если оба бита равны 0, то изображение начинается в левом нижнем углу;

0−3 биты — количество битов атрибутов в пикселе (альфа-канал, оверлейные биты и биты прерывания).

1.1.3 Цветовая таблица

Формат TGA определяет три метода хранения данных изображения: pseudo-color (псевдоцвет), direct-color и true-color.

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

Изображения direct-color подобны псевдоцветным изображениям, однако в них каждый цветовой канал (красный, зеленый и синий) записан как отдельный элемент и может быть модифицирован индивидуально. Значение каждого пикселя данных изображения direct-color содержит три индекса — по одному на каждый канал цветовой таблицы.

Изображения true-color хранят цветовую информацию пикселя непосредственно в данных изображения, и для их отображения цветовая таблица не применяется.

Цветовая таблица присутствует в файле формата 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-битовые пиксельные значения гораздо проще и читать, и записывать. Понятие глубины элемента цветовой таблицы всегда включает альфа-канал, оверлейные биты или биты прерывания, если они есть.

1.1.4 Данные изображения

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

Размер TGA-изображения ограничен 65 535 пикселями по высоте и таким же количеством пикселей по ширине.

Данные изображения содержат (Width x Height) пикселей. Каждый пиксель определяет данные изображения в одном из следующих форматов:

значение индекса цветовой таблицы (8-битовый пиксель);

красный, зеленый, синий (16-битовый пиксель с оверлейным битом (15-й бит));

красный, зеленый, синий (24-битовый пиксель);

альфа-канал, красный, зеленый, синий (32-битовый пиксель).

Читать или записывать пиксельные данные в 8-, 16-, 24 — или 32-битовом формате так же просто, как читать и записывать байты данных.

Однако 16-битовые пиксельные данные формата TGA несколько сложнее. Значение поля PixelDepth = 16 означает, что в данных каждого пикселя выделено по 5 битов для представления каждой из цветовых величин (красной, зеленой и синей), а один бит содержит оверлейные данные (см. ниже). Поскольку эти 16 битов записываются в 2 байтах, то для чтения и записи отдельных элементов таких пиксельных данных необходимо произвести некоторый сдвиг и маскирование.

Количество битов атрибутов в пикселе определяется значениями битов 0−3 поля ImageDescriptor заголовка и соответствует количеству битов в пикселе, которые не связаны непосредственно с его цветовыми величинами.

В формате TGA 16 только 15 из 16 битов пикселя используются для воспроизведения цветовой информации. Каждый 16-й бит, называемый оверлейным, применяется для задания прозрачности (пиксель не виден) или непрозрачности (пиксель виден) пикселя при отображении на видеомониторе.

В формате TGA 32 пиксель представлен 32 битами, причем цветовая информация хранится в 24 битах, а дополнительные 8 битов атрибутов в каждом пикселе применяются в качестве значений альфа-канала.

Альфа-канал — это условное название, которое определяет значение, задающее степень прозрачности отображаемого пикселя. Значения альфа-канала и оверлейных битов применяются при наложении одного изображения на другое или на «живую видеокартинку». Один оверлейный бит (как в формате TGA 16) может только указывать на то, видим пиксель или нет; восемь битов точности могут управлять видимостью пикселя в диапазоне от полной прозрачности (0) до полной непрозрачности (255).

Данные изображения, записанные в файле TGA, обычно не обрабатываются (не кодируются). По этой причине файлы TGA, как правило, весьма громоздки, особенно если растровые данные имеют глубину 24 или 32 бита. На этот случай спецификацией TGA предусмотрена простая, но эффективная схема сжатия RLE. Изображение любого типа может быть сжато при помощи алгоритма RLE. В сжатом изображении в общем случае сжатие может переходить от одной строки к другой. Зажатые данные представляют собой серию групп, каждая из которых состоит из управляющего байта и одного или более пикселей. Старший бит управляющего байта сообщает тип группы — литеральная или повторяемая, а младшие 7 бит содержат длину группы. Длина группы на 1 больше, чем значение в управляющем байте, так что величины управляющего байта от 0h до 7Fh соответствуют длинам от 1 до 128 пикселей. Если старший бит — 1, то группа является повторяющейся, т. е. имеется 1 пиксель, который повторяется несколько раз. Если старший бит — 0, группа — литеральная и в ней столько пикселей, сколько указано в длине. Например, управляющий байт 0Fh — литеральная группа, и за этим байтом следует 16 пикселей. Управляющий байт 88h — повторяющаяся группа, и за этим байтом следует 1 пиксель, который повторяется в изображении 9 раз.

графический изображение формат файл

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. Соответствующие шестнадцатеричные значения равны 0×42 и 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 заголовка информационного блока содержит положительное значение, то строки развертки хранятся в обратном порядке, если же значение отрицательное — то в прямом порядке.

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

Строки дополняются битами до границы двойного слова. Количество байтов на строку вычисляется по следующей формуле:

bytesPertine = ((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. Описание алгоритмов реализации эффектов

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

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.

HLS (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 Фильтрация изображения

Для реализации фильтрации изображения использовался фильтр, который задается матрицей 3×3. Матрица изображена на рис. 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 содержит методы, перечисленные ниже:

1) Метод CreateDib24 создает в памяти 24-разрядный растр с заданными шириной и высотой. В процессе создания осуществляется инициализация полей заголовка растрового файла и заголовка информационного блока. После этого выделяется память для хранения массива пикселов. В завершение открывается дисковый файл с заданным именем, предназначенный для сохранения в нем создаваемого растра.

2) Метод SetPixel осуществляет прямой доступ к пикселам в 24-разрядном растре. Цветовая информация для синей, зеленой и красной составляющих цвета пиксела записывается в соответствующие элементы массива aBitmapBits. Адреса элементов вычисляются через номер строки развертки у и номер пиксела в строке х.

3) Метод StoreDib24 сохраняет созданный растр, записывая его на диск в формате BMP.

4) Метод LoadFromFile загружает BMP-файл с заданным именем, считывая его с диска в оперативную память. В процессе загрузки сначала читается заголовок растрового файла, затем вычисляются размер заголовка информационного блока в совокупности с цветовой таблицей, который указывается в поле infoHeadSize. Помимо этого в поле imageSize указывается вычисленный размер изображения в байтах. Полученные величины используются для указания размеров динамически выделяемой памяти под заголовок информационного блока plnfoHead и под массив пикселов aBitmapBits. После выделения указанной памяти соответствующие компоненты растра читаются из файла.

5) Метод Draw выводит растр на поверхность графического устройства, используя функцию StretchDIBits.

Класс Tga предназначен для работы с файлами Tga. Кроме традиционных для класса методов, таких как конструктор и деструктор, класс Tga содержит методы, перечисленные ниже:

1) Метод LoadFromFile загружает Tga-файл с заданным именем, считывая его с диска в оперативную память. В процессе загрузки сначала читается заголовок файла. Помимо этого в поле imageSize указывается вычисленный размер изображения в байтах. Полученные величины используются для указания размеров динамически выделяемой памяти под массив пикселов aBitmapBits. После выделения указанной памяти соответствующие компоненты читаются из файла.

2) Метод Draw выводит содержимое Tga-файла на поверхность графического устройства, используя функцию SetPixel.

3) Метод RgbToHls переводит даныые изображения из RGB в HLS.

4) Метод HlsToRgb переводит данные изображения из HLS в RGB.

5) Метод NoiseB зашумляет составляющую B

6) Метод NoiseS переводит данные изображения из RGB в HLS, зашумляет составляющую S и обратно переводит из HLS в RGB.

7) Метод 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.

В таблице 4.2 представлены поля класса Tga и их назначение.

Таблица 4.2 Поля класса TGA.

Описание методов класса KDib приведено в таблице 4.3.

Таблица 4.3 Методы класса KDib.

Описание методов класса Tga приведено в таблице 4.4.

Таблица 4.4 Методы класса Tga.

5. Тестирование, результаты работы программы

Программа написана под операционную систему от Windows XP до Windows VISTA. Для установки системы нет необходимости в особых настройках.

Требования к аппаратной платформе — процессор должен быть типа Pentium или Celeron с тактовой частотой не ниже 166 МГц (рекомендуется Pentium III 800 МГц), оперативной памяти — 512 Мбайт (рекомендуется 1024 Мбайт), достаточное количество свободного дискового пространства всего 50 Mб.

Тестирование функции NoiseS методом граничных значений, представлено в таблице 5.1

Таблица 5.1 — Тестирование функции NoiseS.

В результате была разработана программа, имеющая интерфейс, удобный и простой для пользователя, выполняющая открытие, сохранение файлов графических форматов 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

#include

#include

using namespace std;

class KDib {

public:

BYTE* aBitmapBits; // массив пикселов

KDib ();

~KDib ();

BOOL CreateDib24 (int w, int h, const char* fileName);

void StoreDib24 ();

BOOL LoadFromFile (const char* fileName);

void SetPixel (int x, int y, COLORREF color);

int Draw (HDC hdc, int xDst, int yDst, int wDst, int hDst,

int xSrc, int ySrc, int wSrc, int hSrc, DWORD rop);

int GetWidth () { return width; }

int GetHeight () { return height; }

const char* GetError () { return error. c_str (); }

private:

int width;

int height;

int bytesPerLine;

BITMAPFILEHEADER fileHead; // заголовок растрового файла

BITMAPINFOHEADER infoHead; // заголовок информационного блока

BITMAPINFOHEADER* pInfoHead;

int fileHeadSize;

int infoHeadSize;

int imageSize;

string error;

ofstream outFile;

};

class Tga {

private:

char idlength;

char colourmaptype;

char datatypecode;

short int colourmaporigin;

short int colourmaplength;

char colourmapdepth;

short int x_origin;

short int y_origin;

short width;

short height;

char bitsperpixel;

char imagedescriptor;

int imageSize;

string error;

ofstream outFile;

public:

BYTE* aBitmapBits; // массив пикселов

BYTE* aBitmapHLS; // массив пикселов

Tga ();

~Tga ();

int GetWidth () { return width; }

int GetHeight () { return height; }

BOOL LoadFromFile (char* fileName);

void Draw (HDC hdc, BYTE* aBitmapBits);

void RgbToHls ();

void HlsToRgb ();

void NoiseB ();

void NoiseS ();

void Filter ();

void TransformPix (int x, int y);

BYTE* GetA ();

};

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

// KWnd. h

#include

class KWnd {

public:

KWnd (LPCTSTR windowName, HINSTANCE hInst, int cmdShow,

LRESULT (WINAPI *pWndProc) (HWND, UINT, WPARAM, LPARAM),

LPCTSTR menuName = NULL,

int x = CW_USEDEFAULT, int y = 0, int width = CW_USEDEFAULT, int height = 0, UINT classStyle = CS_HREDRAW | CS_VREDRAW,

DWORD windowStyle = WS_OVERLAPPEDWINDOW,

HWND hParent = NULL);

HWND GetHWnd () { return hWnd; }

protected:

HWND hWnd;

WNDCLASSEX wc;

};

// {{NO_DEPENDENCIES}}

// Microsoft Visual C++ generated include file.

// Used by TgaToBmp1. rc

#define IDR_MENU1 101

#define ID_40 001 40 001

#define ID_40 002 40 002

#define ID_40 003 40 003

#define ID_40 004 40 004

#define ID_40 005 40 005

#define ID_40 006 40 006

#define ID_40 007 40 007

#define ID_40 008 40 008

#define ID_40 009 40 009

#define ID_40 010 40 010

#define ID_40 011 40 011

#define ID_40 012 40 012

// Next default values for new objects

#ifdef APSTUDIO_INVOKED

#ifndef APSTUDIO_READONLY_SYMBOLS

#define _APS_NEXT_RESOURCE_VALUE 102

#define _APS_NEXT_COMMAND_VALUE 40 013

#define _APS_NEXT_CONTROL_VALUE 1001

#define _APS_NEXT_SYMED_VALUE 101

#endif

#endif

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

// KWnd. cpp

#include «KWnd. h»

#include «resource1. h»

KWnd: KWnd (LPCTSTR windowName, HINSTANCE hInst, int cmdShow,

LRESULT (WINAPI *pWndProc) (HWND, UINT, WPARAM, LPARAM),

LPCTSTR menuName, int x, int y, int width, int height,

UINT classStyle, DWORD windowStyle, HWND hParent)

{

char szClassName [] = «KWndClass» ;

wc. cbSize = sizeof (wc);

wc. style = classStyle;

wc. lpfnWndProc = pWndProc;

wc. cbClsExtra = 0;

wc. cbWndExtra = 0;

wc. hInstance = hInst;

wc. hIcon = LoadIcon (NULL, IDI_APPLICATION);

wc. hCursor = LoadCursor (NULL, IDC_ARROW);

wc. hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);

wc. lpszMenuName = MAKEINTRESOURCE (IDR_MENU1); // menuName;

wc. lpszClassName = szClassName;

wc. hIconSm = LoadIcon (NULL, IDI_APPLICATION);

// Регистрируем класс окна

if (! RegisterClassEx (&wc)) {

char msg = «Cannot register class: «;

strcat (msg, szClassName);

MessageBox (NULL, msg, «Error», MB_OK);

return;

}

width=640; height=480;

// Создаем окно

hWnd = CreateWindow (szClassName, windowName, windowStyle,

x, y, width, height, hParent, (HMENU) NULL, hInst, NULL);

if (! hWnd) {

char text = «Cannot create window: «;

strcat (text, windowName);

MessageBox (NULL, text, «Error», MB_OK);

return;

}

// Показываем окно

ShowWindow (hWnd, cmdShow);

}

// KDib. cpp

#include «KDib. h»

#include

KDib: KDib () {

fileHeadSize = sizeof (BITMAPFILEHEADER);

fileHead. bfType = 0x4d42;

aBitmapBits = NULL;

}

KDib: ~KDib () {

if (pInfoHead) delete [] pInfoHead;

if (aBitmapBits) delete [] aBitmapBits;

if (outFile) outFile. close ();

}

BOOL KDib: CreateDib24 (int w, int h, const char* fileName) ios: trunc);

if (! outFile) return FALSE;

else return TRUE;

BOOL KDib: LoadFromFile (const char* fileName) {

ifstream inpFile;

inpFile. open (fileName, ios: in | ios: binary);

if (! inpFile) {

error = «Неверное имя файла или каталога. «;

return FALSE;

}

inpFile. read ((char*) &fileHead, fileHeadSize);

if (fileHead. bfType! = 0x4d42) {

error = «Это не BMP-файл» ;

return FALSE;

}

infoHeadSize = fileHead. bfOffBits — fileHeadSize;

int fileSize = fileHead. bfSize;

imageSize = fileSize — (fileHeadSize + infoHeadSize);

pInfoHead = (BITMAPINFOHEADER*) (new BYTE [infoHeadSize]);

inpFile. read ((char*) pInfoHead, infoHeadSize);

width =pInfoHead->biWidth;

height = pInfoHead->biHeight;

aBitmapBits = new BYTE [imageSize];

inpFile. read ((char*) aBitmapBits, imageSize);

return true;

}

int KDib: Draw (HDC hdc, int xDst, int yDst, int wDst, int hDst,

int xSrc, int ySrc, int wSrc, int hSrc, DWORD rop) {

return StretchDIBits (hdc, xDst, yDst, wDst, hDst, xSrc, ySrc, wSrc, hSrc,

aBitmapBits, (CONST BITMAPINFO*) pInfoHead, DIB_RGB_COLORS, rop);

}

void KDib: SetPixel (int x, int y, COLORREF color) {

int row = y;

int col = 3 * x;

aBitmapBits [row*bytesPerLine + col] = GetBValue (color);

aBitmapBits [row*bytesPerLine + col+1] = GetGValue (color);

aBitmapBits [row*bytesPerLine + col+2] = GetRValue (color);

}

void KDib: StoreDib24 () {

// Запись заголовка BMP-файла

outFile. write ((char*) &fileHead, fileHeadSize);

outFile. write ((char*) &infoHead, infoHeadSize);

// Запись массива пикселей

outFile. write ((char*) aBitmapBits, imageSize);

}

Tga: Tga () {

aBitmapBits = NULL;

idlength='0';

colourmaptype='0';

datatypecode='0';

colourmaporigin=0;

colourmaplength=0;

colourmapdepth='0';

x_origin=0;

y_origin=0;

width=0;

height=0;

bitsperpixel='0';

imagedescriptor='0';

imageSize=0;

}

Tga: ~Tga () {}

BOOL Tga: LoadFromFile (char* fileName) {

ifstream inpFile;

inpFile. open (fileName, ios: in | ios: binary);

if (! inpFile) {

error = «Неверное имя файла или каталога. «;

return FALSE;

}

inpFile. read ((char*) &idlength, 1);

inpFile. read ((char*) &colourmaptype, 1);

inpFile. read ((char*) &datatypecode, 1);

inpFile. read ((char*) &colourmaporigin, 2);

inpFile. read ((char*) &colourmaplength, 2);

inpFile. read ((char*) &colourmapdepth, 1);

inpFile. read ((char*) &x_origin, 2);

inpFile. read ((char*) &y_origin, 2);

inpFile. read ((char*) &width, 2);

inpFile. read ((char*) &height, 2);

inpFile. read ((char*) &bitsperpixel, 1);

inpFile. read ((char*) &imagedescriptor, 1);

imageSize = width * height*3;

aBitmapBits = new BYTE [imageSize];

inpFile. read ((char*) aBitmapBits, imageSize);

inpFile. close ();

return true;

}

void Tga: Draw (HDC hdc, BYTE* aBitmapBits) {

int x = GetWidth ();

int y = GetHeight ();

int bytesPerLine = ((x * 24 + 31) / 32) * 4;

for (int row = 0; row < y; row++)

for (int col = 0; col < x; col++) {

SetPixel (hdc, col, row, RGB (aBitmapBits [row*bytesPerLine + col*3+2],

aBitmapBits [row*bytesPerLine + (col*3) +1],

aBitmapBits [row*bytesPerLine + (col*3)]));

}

}

BYTE* Tga: GetA () {

return aBitmapBits;

}

void Tga: RgbToHls () {

BYTE R, G, B, H, L, S;

int x = GetWidth ();

int y = GetHeight ();

int bytesPerLine = ((x * 24 + 31) / 32) * 4;

imageSize = x * y * 3;

aBitmapHLS = new BYTE [imageSize];

for (int row = 0; row < y; row++)

for (int col = 0; col < x; col++) {

R = aBitmapBits [row*bytesPerLine + col*3 + 2];

G = aBitmapBits [row*bytesPerLine + (col*3) + 1];

B = aBitmapBits [row*bytesPerLine + (col*3)];

S = (BYTE) sqrt ((double) (R*R + G*G + B*B — R*G — B*G — R*B));

L = (R + G + B) /3;

H = (BYTE) asin (sqrt (3.0/2.0) * (G — R) / S);

aBitmapHLS [row*bytesPerLine + (col*3)] = S;

aBitmapHLS [row*bytesPerLine + (col*3) + 1] = L;

aBitmapHLS [row*bytesPerLine + col*3 + 2] = H;

}

}

void Tga: HlsToRgb () {

BYTE R, G, B, H, L, S;

int x = GetWidth ();

int y = GetHeight ();

int bytesPerLine = ((x * 24 + 31) / 32) * 4;

for (int row = 0; row < y; row++)

for (int col = 0; col < x; col++) {

H = aBitmapHLS [row*bytesPerLine + col*3 + 2];

L = aBitmapHLS [row*bytesPerLine + (col*3) + 1];

S = aBitmapHLS [row*bytesPerLine + (col*3)];

R = L — (1/3) *S*cos ((double) H) — (1/sqrt (3.0)) *S*sin ((double) H);

G = L + (2/3) *S*cos ((double) H);

B = L — (1/3) *S*cos ((double) H) + (1/sqrt (3.0)) *S*sin ((double) H);

aBitmapBits [row*bytesPerLine + (col*3)] = B;

aBitmapBits [row*bytesPerLine + (col*3) + 1] = G;

aBitmapBits [row*bytesPerLine + col*3 + 2] = R;

}

}

void Tga: NoiseB () {

BYTE B;

int x = GetWidth ();

int y = GetHeight ();

int bytesPerLine = ((x * 24 + 31) / 32) * 4;

for (int row = 0; row < y; row++)

for (int col = 0; col < x; col++) {

B = aBitmapBits [row*bytesPerLine + (col*3)];

B+=rand ();

if (B < 0) B = 0;

if (B > 255) B = 255;

aBitmapBits [row*bytesPerLine + (col*3)] = B;

}

}

void Tga: NoiseS () {

BYTE S;

int x = GetWidth ();

int y = GetHeight ();

int bytesPerLine = ((x * 24 + 31) / 32) * 4;

for (int row = 0; row < y; row++)

for (int col = 0; col < x; col++) {

S = aBitmapHLS [row*bytesPerLine + (col*3)];

S+=rand ();

if (S < 0) S = 0;

if (S > 255) S = 255;

aBitmapHLS [row*bytesPerLine + (col*3)] = S;

}

}

void Tga: TransformPix (int x, int y) {

BYTE NewBGR [3];

int Pixel [3];

BYTE Pix [3];

int w = GetWidth ();

int h = GetHeight ();

int count = 9;

int Matrix ={1,1,1,1,1,1,1,1,1};

int bytesPerLine = ((w * 24 + 31) / 32) * 4;

// x y

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [y*bytesPerLine + x*3 + c];

Pixel [c] = NewBGR [c] * Matrix [4];

}

// x-1 y-1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y-1) *bytesPerLine + (x-1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [0];

}

// x y-1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [y*bytesPerLine + (x-1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [1];

}

// x+1 y-1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y+1) *bytesPerLine + (x-1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [2];

}

// x+1 y

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y+1) *bytesPerLine + x*3 + c];

Pixel [c] += NewBGR [c] * Matrix [5];

}

// x+1 y+1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y+1) *bytesPerLine + (x+1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [8];

}

// x y+1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [y*bytesPerLine + (x+1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [7];

}

// x-1 y+1

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y-1) *bytesPerLine + (x+1) *3 + c];

Pixel [c] += NewBGR [c] * Matrix [6];

}

// x-1 y

for (int c = 0; c < 3; c++) {

NewBGR [c] = aBitmapBits [ (y-1) *bytesPerLine + x*3 + c];

Pixel [c] += NewBGR [c] * Matrix [3];

}

for (int c = 0; c < 3; c++) {

if (count! =0)

Pixel [c] = Pixel [c] /count;

Pix [c] = BYTE (Pixel [c]);

if (Pix [c] < 0)

Pix [c] = 0;

else if (Pix [c] > 255)

Pix [c] =255;

aBitmapHLS [y*bytesPerLine + x*3 + c] = Pix [c];

}

}

void Tga: Filter () {

int w = GetWidth ();

int h = GetHeight ();

imageSize = w * h * 4;

aBitmapHLS = new BYTE [imageSize];

for (int y = 1; y < h-1; y++)

for (int x = 1; x < w-1; x++) {

TransformPix (x, y);

}

aBitmapBits = aBitmapHLS;

}

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

// TgaToBmp. cpp

#include

#include

#include «KWnd. h»

#include «KDib. h»

#include «resource1. h»

KDib bmp;

Tga tga;

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);

// ====================================================

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

{

MSG msg;

KWnd mainWnd («TgaToBmp», hInstance, nCmdShow, WndProc);

while (GetMessage (&msg, NULL, 0, 0)) {

TranslateMessage (&msg);

DispatchMessage (&msg);

}

return msg. wParam;

}

// ====================================================