Пороговая обработка в задачах сегментации изображений

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

3. ИССЛЕДОВАНИЯ

3.1 Исследования на искусственных изображениях

Рассмотрим работу алгоритмов на искусственно созданных изображениях. Методика создания и анализа качества работы алгоритмов:

1) создается «эталон» изображения, то есть совершенно черный объект на совершенно белом фоне4⁴⁾ эталон подвергается сегментации пороговой обработкой, что всегда обеспечивает 100% результат);

2) изображение искусственно подвергается искажению. Под искажением понимают какую-либо совокупность вариантов:

а) однородный белый фон становится неоднородным;

б) появление шумов на изображении;

в) использование различных фильтров.

3) выполняется сегментация определенным методом;

4) выполняется подсчет площади (в пикселях) эталона изображения и результата;

5) производится сравнение величин и вычисление потерь алгоритма в %.

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

- ГПО - глобальная пороговая обработка;

- АПО - адаптивная пороговая обработка;

- МДК - обработка методом дискриминантного критерия;

- ЛПО - локальная пороговая обработка.

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

- адаптивная пороговая обработка: (, );

- локальная пороговая обработка: (, , ).

Рассмотрим, как ведут себя алгоритмы при работе с простейшими изображениями.

Исследование 1:

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

= 13415

Рисунок 3.1 - Исходное изображение

Рисунок 3.2 - ГПО

Рисунок 3.3 - АПО

Рисунок 3.4 - МДК

Рисунок 3.5 - ЛПО (3, 0, 25)

Таблица 1 - Результаты исследования 1

	Площадь (в пикселях)		Потери (в %)
ГПО	13415	0	0
АПО	13425	10	0.08
МДК	13417	2	0.02
ЛПО	13415	0	0

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

Исследование 2:

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

= 18748

Рисунок 3.6 - Исходное изображение

Рисунок 3.7 - ГПО

Рисунок 3.8 - АПО (2, 0.92)

Рисунок 3.9 - МДК

Рисунок 3.10 - ЛПО (2, 0, 15)

Таблица 2 - Результаты исследования 2

	Площадь (в пикселях)		Потери (в %)
ГПО	18885	137	0.73
АПО	18813	65	0.35
МДК	18835	87	0.47
ЛПО	18865	117	0.63

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

Исследование 3:

Цель: установить качество работы алгоритмов на объектах, имеющих элемент, толщиной в 1 пиксель. Фон неоднородный, тем самым попытаемся «сбить» алгоритм от определения тонкого элемента объекта.

Рисунок 3.11 - Исходное изображение

= 11867

Рисунок 3.12 - ГПО

Рисунок 3.13 - АПО

Рисунок 3.15 - ЛПО

Таблица 3 - Результаты исследования 3

	Площадь (в пикселях)		Потери (в %)
ГПО	11521	346	2.92
АПО	11867	0	0
МДК	11523	344	2.90
ЛПО	11597	270	2.27

Вывод: лучше всех с алгоритмом справляется адаптивный метод. Как и утверждается теорией, параметр лучше выбирать равным примерно той толщине объекта, который хотим выделить. Поэтому =1 по умолчанию и привел к самой лучшей 100% сегментации. Параметр не менялся (0.66), однако, если его повысить, то можно ожидать, что часть точек в рассмотрение не попадут (учитывая формулы (2.25) и (2.26)), а значит, могут быть потери. Хуже всего ведет себя локальный метод. Несмотря на то, что он «ближе» к эталону, он не только не выделил тонкий объект, но еще и «отреагировал» на шумы, что неприемлемо. Повысим значение параметра и продемонстрируем пример обработки.

Рисунок 3.16 - АПО ()

Исследование 4:

Цель: проверить, как распознают алгоритмы цветные объекты различной яркости. Изображение цветное.

= 18018, то есть все три объекта.

Рисунок 3.17 - Исходное изображение

Рисунок 3.18 - ГПО

Рисунок 3.19 - АПО

Рисунок 3.20 - МДК

Рисунок 3.21 - ЛПО

Вывод: глобальный и дискриминантный методы не справляются с поставленной задачей. Причина в том, что они обрабатывают все изображение целиком. А адаптивный и локальный по областям. Поэтому, последние два алгоритма «замечают» объекты более низкой яркости. Следовательно, если на изображении есть объекты, которые мы хотим выделить, и они имеют разную яркость пикселей, то следует пользоваться адаптивным и глобальным алгоритмами.

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

Исследование 5:

Цель: определение влияния черного цвета на изображении на работу алгоритмов.

Рисунок 3.22 - Исходное изображение

Результатом являются пустые изображения, то есть эти алгоритмы глобальной и дискриминантной обработки не нашли ни одного объекта. Результаты работы адаптивного и локального методов по-прежнему полностью 100% и совпадают с результатами на изображениях 3.19 и 3.21.

Вывод: исследуемые два алгоритма не справляются с поставленной задачей.

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

Исследование 6:

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

Рисунок 3.23 - Исходное изображение

Рисунок 3.24 - ГПО

Рисунок 3.25 - МДК

Вывод: как видно из рисунка 3.24 глобальный алгоритм определил лишь те пиксели объекта, которые перекрывает шум. Потому что в этих частях шум является более темным, чем цвета объектов. Из рисунка 3.25 видно, что алгоритм, построенный на использовании дискриминантной функции, очень хорошо определил объекты. Причиной резкого улучшения работы алгоритма стало то, что теперь на изображении не 3 цвета, а гораздо больше. О чем свидетельствует гистограмма, приведенная на рисунке 3.26

Рисунок 3.26 - Гистограмма рисунка 3.22

Три области гистограммы соответствуют трем объектам на изображении. Так как они не одноцветные, то эти три области имеют ширину, большую одного пикселя, и, благодаря шуму, сильно изрезаны. Гистограмма исходного изображения 3.22, очевидно, представляет собой три прямых.

Исследование 7:

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

Рисунок 3.27 - Вложенные круги

На данном рисунке расположено 4 вложенных друг в друга круга. Все они имеют различную яркость. Необходимо определить, что выдаст каждый из алгоритмов в качестве фона, а что в качестве объекта. Как уже говорилось выше, вообще говоря, выбор объекта - задача неоднозначная. Кто-то скажет, что на этом изображении всего один объект, серый круг. И неважно что он содержит еще 3 других круга. Кто-то скажет, что объект только белый круг. А объектом на самом деле может быть и красный и белый круги. Поэтому решено было провести исследование, что же будет являться объектом для алгоритмов. Глобальная обработка и обработка методом дискриминантного критерия все отнесли к одному классу , что очевидно нас не устраивает.

Посмотрим на работу других алгоритмов

Рисунок 3.28 - АПО

Рисунок 3.29 - ЛПО

Вывод: адаптивная пороговая обработка «не увидела» розовый круг внутри серого, а локальная «увидела». ЛПО выдала объектами в данной ситуации розовый и белый круг. Однако, такое утверждение носит относительный характер. На самом деле, здесь присутствует всего 2 класса: H0 и H1. Так вот серый и синие круги относятся к классу H1. Белый и розовый - к H0. И сказать в данном случае какой из классов является объектом, а какой фоном - решение сугубо субъективное. Можно сказать, что локальный алгоритм пороговой обработки гораздо чувствительнее к всему спектру находящихся на изображении вариаций яркостей, чем глобальная и пороговые обработки. Адаптивный алгоритм чувствителен больше к сильной разнице по яркости между объектами, чем к числу нахождения различных уровней яркости на изображении. Чувствителен он также и к темным объектам.

Исследование 8:

Цель: определить, насколько «усредняет» каждый алгоритм объект, подвергшийся сильному смазыванию.

= 8636

Рисунок 3.30 - Эталон

Рисунок 3.31 - Исходное изображение

Рисунок 3.32 - ГПО



Рисунок 3.33 - АПО

Рисунок 3.34 - МДК

Рисунок 3.35 - ЛПО

Таблица 4 - Результаты исследования 8

	Площадь (в пикселях)		Потери (в %)
ГПО	8628	8	0.1
АПО	8715	79	0.91
МДК	11252	2616	23.24
ЛПО	9294	658	7.07

Вывод: из результата видно, что глобальный алгоритм лучше всего справляется со смазыванием на простых объектах, то есть находит объект наиболее ближе всего к эталону. Очень хорошо справляется адаптивная обработка. Хуже локальная, а обработка методом дискриминантного критерия не справляется вовсе.

В большинстве результатов глобальная обработка дает неплохие результаты только на искусственных простых изображениях. Однако, говорить что этим ограничивается ее применение попросту нельзя. Например, на рисунке 3.36 показано созданное на листке бумаги и сфотографированное изображение и глобальная обработка на нем справляется лучше всего.

Исследование 9:

Цель: показать, что в некоторых изображениях глобальная пороговая обработка, хоть и является самой простой, но показывает самые лучшие результаты.

На рисунке 3.36 представлено сфотографированное изображение. Слово RGB резко выделяется из фона и, очевидно, является объектом интереса. Однако изображение было нарисовано простым карандашом так, что, по сути, искусственно созданные шумы имеют практически ту же яркость, что и слово RGB, поскольку и те и те нарисованы одним и тем же графитом, а слово RGB лишь немного было усилено интенсивностью. Очевидно, что при разбиении изображения на части (как в адаптивной и локальной обработках) алгоритмы могут начать сбиваться, несмотря на то, что гистограмма изображения (рисунок 3.36) поддается весьма явному разделению на два класса.

Рисунок 3.36 - Исходное изображение

Рисунок 3.37 - Гистограмма изображения

Рисунок 3.38 - ГПО

Рисунок 3.39 - АПО

Рисунок 3.40 - МДК

Рисунок 3.41 - ЛПО

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

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

3.2 Исследования на предметных изображениях

Теперь рассмотрим различные применения пороговой обработки в задачах конкретных предметных областей.

Пороговая обработка часто применяется в микробиологии. Например, при выделении микроорганизмов из их естественной среды обитания. Примером такой сегментации может быть исследование 10.

Исследование 10:

Цель: сравнить работоспособность алгоритмов на реально существующих задачах. Задача определения микроорганизма на изображении. Изображение плохого качества, фон непростой структуры, вокруг «Хромосомы» также имеется свечение, которое будет неблагоприятно реагировать на работу алгоритмов.

Эталон был получен путем ручной «попиксельной» обводки объекта черным маркером и его закрашиванием.

= 11473,

= 52787,

= 64260.

Рисунок 3.42 - Эталон

Рисунок 3.43- Изображение «Хромосома»

Рисунок 3.44 - ГПО Рисунок 3.45 - АПО

Рисунок 3.46 - МДК Рисунок 3.47 - ЛПО

Таблица 5 - Результаты исследования 10

	Площадь (в пикселях)		Потери (в %)
ГПО	13497	2024	14.26%
АПО	12386	913	7.38%
МДК	12451	978	7.06%
ЛПО	12241	768	6.43%

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

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

Исследование 11:

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

Рисунок 3.48 - Инвертированное изображение

Рисунок 3.49 - ГПО Рисунок 3.50 - АПО

Рисунок 3.51 - МДК

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

Таблица 6 - Результаты исследования 11

	Площадь (в пикселях)		Потери (в %)
ГПО	12641	1168	9.24
АПО	16258	4785	29.44
МДК	14878	3405	22.89

Вывод: из результатов работы алгоритма на инвертированном изображении видно, что глобальная пороговая обработка улучшает качество сегментирования на 5.02%, что весьма существенно. Однако, остальные алгоритмы показывают себя хуже. Но так как глобальная обработка самая простая и быстрая, то зачастую путем инвертирования можно добиться схожих с другими методами результатов, а вычислительных затрат при этом получается в разы меньше.

Исследование 12:

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

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

Рисунок 3.52 - Шов сварки цветных металлов

Рисунок 3.53 - Гистограмма изображения 3.35

Гистограмма, изображенная на рисунке 3.53 является сильно изрезанной, более того, она не унимодальная, что сразу говорит о том, что простые алгоритмы пороговой обработки, например, глобальная пороговая обработка, не справятся с таким изображением.

Рисунок 3.54 - ГПО

Рисунок 3.55 - АПО (3, 0.30)

Рисунок 3.56 - МДК

Рисунок 3.57 - ЛПО

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

Вывод: по рисункам 3.54-3.57 можно сделать вывод, что глобальная обработка, как и ожидалось, не дает совершенно никаких результатов. Дискриминантная обработка тоже не показывает даже удовлетворительной сегментации. А вот адаптивная и локальные обработки дают весьма неплохие результаты на таком сложном изображении. Зрительно, они примерно одинаково выделили шов. Адаптивную обработку можно «упрекнуть» лишь за появившиеся в правой крайней части помехи.

Исследование 13:

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

Рисунок 3.58 - Исходное изображение

Рисунок 3.59 - ГПО Рисунок 3.60 - АПО

Рисунок 3.61 - МДК Рисунок 3.62 - ЛПО

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

Исследование 14:

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

На рисунке 3.63 представлено космическое радиолокационное изображение акватории Северной Атлантики вблизи побережья Испании. Темным шлейфом на снимке тянется пятно от того места, где тонет танкер “Престиж”. Танкер ушел под воду 19 ноября, унеся с собой на дно более чем 50 тысяч тонн топлива.

Рисунок 3.63 - Исходное изображение

Рисунок 3.64 - ГПО

Рисунок 3.65 - АПО

Рисунок 3.66 - МДК

Рисунок 3.67 - ЛПО

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

Исследование 15:

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



Рисунок 3.68 - Исходное изображение

Рисунок 3.69 - ГПО Рисунок 3.70 - АПО

Рисунок 3.71 - МДК Рисунок 3.72 - ЛПО

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

Исследование 16:

Пороговая обработка применяется в робототехнике в самых разнообразных областях. Она также применяется для автоматического распознавания разрывов (или пробоев) на листах металла. На рисунке 3.73 показан пример такого разрыва на металлическом листе.

Рисунок 3.73 - Исходное изображение

Рисунок 3.74 - ГПО Рисунок 3.75- АПО

Рисунок 3.76 - МДК Рисунок 3.77 - ЛПО

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

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

Метод дискриминантного критерия хорошо справляется с изображениями, гистограмма которых сильно изрезана. Алгоритм дает очень хорошие результаты, когда площади двух классов и сравнимы по величине.

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

Данные методы хорошо подходят для «сложных» по структуре изображений. Однако если на изображении присутствуют сильные шумы, данные алгоритмы могут «реагировать» на них. Для самых простых изображений применение данных методов нецелесообразно.

4. РАЗРАБОТАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ

4.1 Общие сведения

Разработанная программа называется «Программа пороговой обработки изображений». Данное программное обеспечение (далее ПО) написано на языке высокого уровня C++, с использованием Microsoft Visual Studio 2008. Программа написана с использованием набора компонент стандарта .NET Framework версии 2.0. Для работы программы необходима операционная система Windows XP Sp3 и установленная платформа не ниже версии .NET Framework 2.0.

Windows Forms - это совершенно новый стиль построения приложения на базе классов .NET Framework. Основное отличие Windows Forms от уже разработанных ранее моделей построения приложений, таких как Win 32 API и MFC, заключается в том, что Windows Forms создает более однородную структуру программной модели. Также преимущество в том, что с использованием Windows Forms легко можно программировать на разных языках (C++, C# и так далее).

Консольная версия программы написана с использованием Open GL 1.1, поэтому для использования консольной версии необходима видеокарта с поддержкой OpenGL не ниже версии 1.1.

4.2 Входные данные

На входе подается 24-х-битное изображение формата .bmp любого разрешения. Также для работы программы следует выбрать файл результата в формате .txt. Для выбора этих файлов программа контактирует с пользователем посредством диалогового режима5⁵⁾ в имени пути файла не должно быть символов кириллицы). Диалоговый режим работы с пользователем для выбора файлов представлен на рисунке А.1

4.3 Выходные данные

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

1) координаты пикселей выделенного класса H1 (класс «интереса»);

2) значения составляющих исходного изображения в этих пикселях;

3) значение яркостей всех пикселей объекта;

4) общее количество пикселей класса H0, класса H1 и всего изображения.

4.4 Описание структуры ПО

Для создания данного ПО было написано две отдельных программы, которые были впоследствии связаны друг с другом. Первая программа была написана в консольном приложении и включала в себя все описанные алгоритмы, а также все необходимые данные и параметры. Вторая программа была написана с использованием средств Windows Forms для создания визуального интерфейса. Для работы с изображениями были использованы встроенные средства Visual Studio. Поэтому, в итоговой программе Open GL не используется, он используется только в отдельной версии консольной программы.

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

На изображении А.3 Приложения А показан общий вид главной формы. В левой верхней части находится область работы с файлами: исходным файлом изображения и текстовым файлом результата.

Если какой-либо файл не был выбран, возникает ошибка. Пример изображен на рисунке А.6.

В левой нижней части предоставлена работа непосредственно с данными алгоритмов и управляющими элементами по запуску сегментации. По нажатию на кнопку «Запуск!» выполняется работа алгоритма с заданными параметрами.

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

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

При нажатии на красные маленькие кнопки рядом с выбором методов сегментации и масштабом гистограмм можно вызвать краткую подсказку, пример которой приведен на рисунке А.4.

Подробнее о программной реализации можно узнать в Приложении Б.

ЗАКЛЮЧЕНИЕ

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

Основными результатами данной работы являются:

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

· изучены и реализованы следующие методы пороговой обработки:

o глобальная пороговая обработка;

o локальная пороговая обработка;

o пороговая обработка методом дискриминантного критерия;

o адаптивная пороговая обработка.

· проведены сравнительные исследования работы алгоритмов;

· проведены исследования влияния характеристик изображения на работу алгоритмов;

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

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

СПИСОК ЛИТЕРАТУРЫ

1. Вудс, Р. Цифровая обработка изображений / Р. Вудс, Р. Гонсалес. - Москва : ТЕХНОСФЕРА, 2005. - 1072 с.

2. Визильтер, Ю.В. Обработка и анализ цифровых изображений с примерами на LabVIEW и IMAQ VIsion / Ю.В. Визильтер [и др.]. - Москва : ДМК, 2077. - 464 с.

3. Яне, Б. Цифровая обработка изображений / Б. Яне. - Москва : ТЕХНОСФЕРА, 2007. - 584 с.

4. Грузман, И.С Цифровая обработка изображений в информационных системах / И.С Грузман [и др.]. - Новосибирск : НГТУ, 2002. - 352 с.

5. Вудс, Р. Цифровая обработка изображений в среде MATLAB / Р. Вудс, Р. Гонсалес, С. Эддинс. - Москва : ТЕХНОСФЕРА, 2006. - 616 с.

6. Вежневец В. Выделение связных областей в цветных и полутоновых изображениях [Электронный ресурс] / И.М. Журавель. - Режим доступа: http://www.ict.edu.ru/lib/index.php?a=elib&c=getForm&r=resDesc&d=light&id_res=2397.

7. И.М. Журавель "Краткий курс теории обработки изображений" [Электронный ресурс]. - Режим доступа: http://matlab.exponenta.ru/imageprocess/book2/76.php.

8. ТелеМедТехника - Системы ввода и анализа изображений [Электронный ресурс]. - Режим доступа: http://telemed-spb.narod.ru/defect.htm.

9. Процессор распознавания нефтяных пятен [Электронный ресурс]. - Режим доступа: http://www.racurs.ru/?page=378.

10. Технологии будущего [Электронный ресурс] : Новости журнала Технологии Будущего. - Режим доступа: http://transchelovek.moy.su/forum/5-290-2.

11. Препарирование изображения [Электронный ресурс]. - Режим доступа: http://www.masters.donntu.edu.ua/2006/kita/yevstyunicheva/library/art06.htm.

12. Антощук, С.Г. Информационная технология для распознавания лиц в реальном времени с использованием WEB-камеры С.Г. Антощук, Н.А. Крысенко, Т.А. Бурак // Міжвідомчий науково - технічний збірник. - 2007. - Выпуск 69. - С. 67-71.

13. Френсис, Хилл Open GL для профессионалов: программирование компьютерной графики / Хилл Френсис. - 2-ое изд.. - Санкт-Петербург : ПИТЕР, 2002. - 1088 с.

14. Страуструп, Б. Язык программирования C++ / Б. Страуструп. - Москва : БИНОМ, 2002. - 1099 с.

ПРИЛОЖЕНИЕ А

ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ

Рисунок А.1 - Диалоговый режим выбора файла

Рисунок А.2 -Результат сегментации

Рисунок А.3 - Главная форма программы

Рисунок А.4 - Общий вид подсказки

Рисунок А.5 - «Помощь»

Рисунок А.6 - Ошибка

ПРИЛОЖЕНИЕ Б

ПРОГРАММНАЯ РЕАЛИЗАЦИЯ

В данном приложении будут представлены только основные выкладки из кода программы, чтобы сократить размерность данной пояснительной записки.6⁶⁾ код финальной версии программы может отличаться от представленного. В данном приложении представлен не весь код программы.)

Основная часть программы написана с использованием Open GL. Класс RGBPixmap был взят и немного переработан из [13] с использованием приемов из [14].

Основная часть программы:

PROG.CPP

//--------------- основные библиотеки для работы с программой -----//

#include <windows.h>

#include <stdio.h>

#include <conio.h>

#include <math.h>

#include <assert.h>

#include <GL/gl.h> //библиотека для работы с Open GL

#include <GL/glu.h> //библиотека для работы с Open GL

#include <GL/glaux.h> //библиотека для работы с Open GL

#include "glut.h"

#include <fstream>

#include <iostream>

using namespace std;

namespace globa //вся программа заключена в область globa

{

//---------------------------------------------------------------------------//

//---------------------------------------------------------------------------//

//------------------- параметры обработки изображения ------------------//

//---------------------------------------------------------------------------//

//---------------------------------------------------------------------------//

int a_kol_razb; //количество областей при разбиении изображения

int loc2al_tochka_razbienija; //переменная, отвечающая за определения порога разбиения области на принадлежащую фону или объекту (локальная обработка)

int loc2al_dispers_fone; //перменная, отвечающая за добавление яркости к пикселям фона (локальная обработка)

int loc2al_dispers_object; //перменная, отвечающая за добавление яркости к пикселям объекта (локальная оработка)

double alfa=2./3.; //порог, для адаптивной локальной обработки

int KK=1; //праметр, определяющий область соседей (адаптивная обработка)

char *filename; //имя файла с изображением

FILE *rez; //результирующий файл с данными об изображении

//---------------------------------------------------------------------------//

//----------------- конец параметры обработки изображения ------//

//---------------------------------------------------------------------------//

//---------------------------------------------------------------------------//

int screenWidth=1024, screenHeight=768; //размеры рисуемого изначально окна

//************** переопределение типов *************************************//

typedef unsigned short ushort;

typedef unsigned long ulong;

typedef unsigned char uchar;

int histogramma[256][4]; //область памяти для хранения 4х гистограмм

int what_draw=0, one_raz=0; //что будем рисовать и флаг на копирование исходного изображения

int adpt_porog[3]; //порог, для локальной обработки

FILE *f1;

fstream inf;

long i_flag=0, loc2al_i_flag=0;

long j_flag=0, loc2al_j_flag=0;

int whichPic=0,otstyp=10;

int delRGB=40, delR=40; //для наглядной визуализации гистограмм

int *a_peresek; //массив для определения областей,содержащих и фон и объект.

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

ushort getShort()

{

char ic;

ushort ip;

inf.get(ic);

ip=ic;

inf.get(ic);

ip |=((ushort)ic << 8);

return ip;

}

ulong getLong()

{

ulong ip=0;

char ic=0;

unsigned char uc=ic;

inf.get(ic);

uc=ic;

ip=uc;

inf.get(ic);

uc=ic;

ip |=((ulong)uc << 8);

inf.get(ic);

uc=ic;

ip |=((ulong)uc << 16);

inf.get(ic);

uc=ic;

ip |=((ulong)uc << 24);

return ip;

}

//****************** класс RGB для каждого пикселя ************************//

class mRGB{

public: uchar r,g,b;

mRGB() //конструкторы

{

r=0;

g=0;

b=0;

}

mRGB(mRGB& p)

{

r=p.r;

g=p.g;

b=p.b;

}

mRGB(uchar rr, uchar gg, uchar bb)

{

r=rr;

g=gg;

b=bb;

}

void set(uchar rr, uchar gg, uchar bb)

{

r=rr;

g=gg;

b=bb;

}

};

class mmRGB{

public: double r,g,b;

mmRGB()

{

r=0;

g=0;

b=0;

}

mmRGB(mmRGB& p)

{

r=p.r;

g=p.g;

b=p.b;

}

};

mRGB* pixel; //массив пикселов основного рисунка

mRGB* px1; //массив пикселов, принадлежащих фону

mRGB* px2; //массив пикселов, принадлежащих объекту

mRGB* pixel2; //массив пикселов (вспомогательный)

//****************** класс пиксельной карты ******************************//

class RGBpixmap{

public:

int nRows, nCols;

RGBpixmap()

{

nRows=nCols=0;

pixel=0;

}

RGBpixmap(int r, int c)

{

nRows = r;

nCols = c;

pixel = new mRGB[r*c];

}

void setPixel(int x, int y, mRGB color) //процедура установки пикселя

{

if(x>=0 && x<nCols && y>=0 && y<nRows)

pixel[nCols*y+x]=color;

}

mRGB getPixel(int x, int y) //процедура получения пикселя

{

return pixel[nCols*y+x];

}

void draw() //процедура рисования массива пикселей

{

if (nRows ==0 || nCols==0) return;

glPixelStorei(GL_UNPACK_ALIGNMENT,1);

glDrawPixels(nCols, nRows, GL_RGB, GL_UNSIGNED_BYTE,pixel);

}

void freeIt() //освобождение памяти

{

delete []pixel;

nRows=0;

nCols=0;

}

void copy(int x, int y, int wid, int ht) //копирование пикселя

{

glCopyPixels(x,y,wid,ht,GL_COLOR);

}

int readBMPFile(char * fname) //функция чтения BMP файла

{

inf.open(fname, ios::in | ios::binary);

if(!inf)

{

cout << "can't open file: " << fname << endl;

return 0;

}

int k, row, col, numPadBytes, nBytesInRow;

char ch1, ch2;

inf.get(ch1);

inf.get(ch2);

//получение всей необходимой о файле информации

ulong fileSize = getLong();

ushort reserved1 = getShort();

ushort reserved2 = getShort();

ulong offBits = getLong();

ulong headerSize = getLong();

ulong numCols = getLong();

ulong numRows = getLong();

ushort planes = getShort();

ushort bitsPerPixel = getShort();

ulong compression = getLong();

ulong xPels = getLong();

ulong yPels = getLong();

ulong numLUTentries = getLong();

ulong impColors = getLong();

if(bitsPerPixel != 24) //если изображение не 24 бита, то ошибка

{

cout << "not a 24-bit pixel image\n";

inf.close();

return 0;

}

nBytesInRow = ((3*numCols+3)/4)*4;

numPadBytes = nBytesInRow-3*numCols;

nRows = numRows;

nCols = numCols;

pixel = new mRGB[nRows * nCols]; //выделение памяти

px1 = new mRGB[nRows* nCols];

px2 = new mRGB[nRows* nCols];

//adapt = new mRGB[adaptRows*adaptCols][3];

if(!pixel) return 0;

long count = 0;

char dum;

//запись в основной массив пикселей (pixel) считанных пикселей изображения

for (row=0; row<nRows;row++)

{

for(col=0; col<nCols; col++)

{

char r,g,b;

inf.get(r);

inf.get(b);

inf.get(g);

pixel[count].r=r;

pixel[count].g=g;

pixel[count].b=b;

count++;

}

for(k=0;k<numPadBytes;k++)

inf >> dum;

}

inf.close();

return 1;

}

void copy_image(mRGB *copy_pixel, mRGB *isxod_pixel)

{

int all;

all=nRows*nCols;

for(int i=0;i<all;i++)

{

copy_pixel[i].r = isxod_pixel[i].r;

copy_pixel[i].g = isxod_pixel[i].g;

copy_pixel[i].b = isxod_pixel[i].b;

}

}

//************* функция определения принадлежности пикселя фону или объекту *************************//

int func_glob_porog(int num, double sr[3])

{

int min_porog=0, max_porog,rez=0;

max_porog=110;

if(pixel[num].r<=sr[0] && pixel[num].g<=sr[1] && pixel[num].b<=sr[2]) rez=1;

else rez=0;

return rez;

}

//****************** процедура для фонового пикселя ***********************//

void pixel_in_fone(int num)

{

px1[i_flag].r=pixel[num].r;

px1[i_flag].g=pixel[num].g;

px1[i_flag].b=pixel[num].b;

i_flag++;

}

//***************** процедура для пикселя объекта ************************//

void pixel_in_object(int num)

{

px2[j_flag].r=pixel[num].r;

px2[j_flag].g=pixel[num].g;

px2[j_flag].b=pixel[num].b;

j_flag++;

}

//********************* функция средней яркости (по RGB) *********************//

int sred_rgb(int razm, int flg, int what)

{

double a=0,b=0,c=0;

if (what==0)

{

for(int i=0;i<razm;i++)

{

a+=px1[i].r;

b+=px1[i].g;

c+=px1[i].b;

}

}

else

{

for(int i=0;i<razm;i++)

{

a+=px2[i].r;

b+=px2[i].g;

c+=px2[i].b;

}

}

a=a/razm;

b=b/razm;

c=c/razm;

if(flg==0) return a;

if(flg==1) return b;

if(flg==2) return c;

}

};

RGBpixmap pic[1]; //элемент класса пиксельной карты, содержащий изображение

//----------------------------------------------------------------//

//************** процедура глобального порога ******************//

//----------------------------------------------------------------//

void glob_porog()

{

long ct=0;

int flag=0,pf=0,po=0,cvet_fon,cvet_object,fon_or_object=1;

char ch1='r',ch2='g',ch3='b';

double T0=1.0,argb[3],zrgb[3],Trgb[3],TTrgb[3],mxrgb=0.0,mnrgb=0.0;

int max_rgb[3],min_rgb[3],skok;

cvet_fon=0; //цвет фона

cvet_object=255; //цвет объекта

skok=pic[whichPic].nCols*pic[whichPic].nRows; //количество пикселей

for(int i=0;i<3;i++) //зануление массивов

{

TTrgb[i]=0;

max_rgb[i]=0;

min_rgb[i]=0;

}

for(int i=0;i<skok;i++)

{

if ( max_rgb[0] < pixel[i].r ) max_rgb[0]=pixel[i].r;

if ( max_rgb[1] < pixel[i].g ) max_rgb[1]=pixel[i].g;

if ( max_rgb[2] < pixel[i].b ) max_rgb[2]=pixel[i].b;

if ( min_rgb[0] > pixel[i].r ) min_rgb[0]=pixel[i].r;

if ( min_rgb[1] > pixel[i].g ) min_rgb[1]=pixel[i].g;

if ( min_rgb[2] > pixel[i].b ) min_rgb[2]=pixel[i].b;

}

for(int i=0; i<3; i++)

{

mxrgb+=max_rgb[i];

mnrgb+=min_rgb[i];

}

mxrgb=0.3*max_rgb[0]+0.59*max_rgb[1]+0.11*max_rgb[2]; //max яркость

mnrgb=0.3*min_rgb[0]+0.59*min_rgb[1]+0.11*min_rgb[2]; //min яркость

for(int i=0; i<3; i++)

Trgb[i]=(mxrgb+mnrgb)/2;

rez=fopen("rezult.txt","w"); //файл результата

fprintf(rez,"Method: global\n\n");

//алгоритм автоматического вычисления порога

while (abs(TTrgb[0]-Trgb[0])>T0 && abs(TTrgb[1]-Trgb[1])>T0 && abs(TTrgb[2]-Trgb[2])>T0 ) //итерационный процесс

{

ct=0;

po=0;

pf=0;

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

TTrgb[y]=Trgb[y];

for (int i=0; i<pic[0].nRows;i++) //цикл по строкам

{

for(int j=0; j<pic[0].nCols; j++) //цикл по столбцам

{

flag=pic[whichPic].func_glob_porog(ct,Trgb); //определение принадлежности пикселя

if (flag==1) //установка нового значения пикселя

{

pic[whichPic].pixel_in_fone(ct);

fprintf(rez,"x=%i\ty=%i\tR=%i\tG=%i\tB=%i\tRGB=%lf\n",j,i,pixel[ct].r,pixel[ct].g,pixel[ct].b,0.3*pixel[ct].r+0.59*pixel[ct].g+0.11*pixel[ct].b);

pixel[ct].r=cvet_fon;

pixel[ct].g=cvet_fon;

pixel[ct].b=cvet_fon;

po++;

}

else //установка нового значения пикселя (фон)

{

pic[whichPic].pixel_in_object(ct);

pixel[ct].r=cvet_object;

pixel[ct].g=cvet_object;

pixel[ct].b=cvet_object;

pf++;

}

ct++;

}

}

fprintf(rez,"\n\nPixel_in_object = %i\nPixel_in_fone = %i\nPixel_in_image = %i\n",po,pf,ct);

fclose(rez);

i_flag=0;

j_flag=0;

for(int q=0;q<3;q++)

{

argb[q]=pic[whichPic].sred_rgb(pf,q,fon_or_object); //среднее по пикселям фона

}

argb[0]*=0.3;

argb[1]*=0.59;

argb[2]*=0.11;

fon_or_object=0;

for(int q=0;q<3;q++)

{

zrgb[q]=pic[whichPic].sred_rgb(pf,q,fon_or_object); //среднее по пикселям объекта

}

zrgb[0]*=0.3;

zrgb[1]*=0.59;

zrgb[2]*=0.11;

for(int u=0;u<3;u++)

Trgb[u]=(argb[u]+zrgb[u])/2;

}

}

//конец класса пиксельная карта

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//+++++++++++++++++ начало класса локальная обработка +++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class loc2al_class{

public:

int aRows,aCols;

ulong raspred[255];

double dispers;

ulong mat_ozhid;

mRGB** loc2al_img;

mRGB** px1;

mRGB** px2;

mRGB* a_pixel; //массив пикселов рисунка, подвергнувшегося адаптивной обработке

int *sksk;

void opred() //выделение памяти, определение необходимых переменных и т.д.

{

int adaptRows,adaptCols,a,b;

adaptRows=pic[whichPic].nRows/a_kol_razb;

adaptCols=pic[whichPic].nCols/a_kol_razb;

aRows=adaptRows;

aCols=adaptCols;

a=adaptRows*adaptCols;

b=a_kol_razb*a_kol_razb;

a_pixel = new mRGB[pic[whichPic].nRows * pic[whichPic].nCols];

loc2al_img = new mRGB*[a];

px1 = new mRGB*[a];

px2 = new mRGB*[a];

sksk = new int[b];

for(int i=0;i<a;i++)

{

loc2al_img[i] = new mRGB[b];

px1[i] = new mRGB[b];

px2[i] = new mRGB[b];

}

}

void a_draw() //процедура рисования массива пикселей (Open GL)

{

if (pic[whichPic].nRows ==0 || pic[whichPic].nCols==0) return;

glPixelStorei(GL_UNPACK_ALIGNMENT,1);

glDrawPixels(pic[whichPic].nCols, pic[whichPic].nRows, GL_RGB, GL_UNSIGNED_BYTE,a_pixel);

}

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//Часть кода, расположенная ниже, была изменена в отчете для лучшего восприятия основных моментов, которые выполнялись при работе алгоритма

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//***** локальная пороговая обработка (главная процедура локальной обработки)

void loc2al_glob_porog()

{

int cvet_fon=0, cvet_object=255, skok, ct, fon_or_object=0, opred_prinadl_f=0,opred_prinadl_o=0;

int *only_oo,*only_ff, razm, flag, po, pf;

double *mxrgb,*mnrgb, T0=5.0;

FILE *file;

file = fopen("info.txt","w");

razm=a_kol_razb*a_kol_razb;

int glob_pf=0,glob_po=0,glob_ct=0;

mRGB *max_rgb,*min_rgb,*Trgb,*TTrgb,*argb,*zrgb;

max_rgb = new mRGB[razm];

min_rgb = new mRGB[razm];

mxrgb = new double[razm];

mnrgb = new double[razm];

only_oo = new int[razm];

only_ff = new int[razm];

Trgb = new mRGB[razm];

TTrgb = new mRGB[razm];

argb = new mRGB[razm];

zrgb = new mRGB[razm];

skok=aCols*aRows;

for(int i=0;i<razm;i++)

{

only_oo[i]=0;

only_ff[i]=0;

}

for(int i=0;i<razm;i++)

{

TTrgb[i].r=0;

TTrgb[i].g=0;

TTrgb[i].b=0;

max_rgb[i].r=0;

max_rgb[i].g=0;

max_rgb[i].b=0;

min_rgb[i].r=0;

min_rgb[i].g=0;

min_rgb[i].b=0;

mxrgb[i]=0;

mnrgb[i]=0;

}

// ШАГ 1: определяем для каждой области максимум и минимум по каждой из составляющей RGB

for(int k=0;k<razm;k++) //главный цикл по всем областям

{

for(int i=0;i<skok;i++)

{

if ( max_rgb[k].r < loc2al_img[i][k].r ) max_rgb[k].r=loc2al_img[i][k].r;

if ( max_rgb[k].g < loc2al_img[i][k].g ) max_rgb[k].g=loc2al_img[i][k].g;

if ( max_rgb[k].b < loc2al_img[i][k].b ) max_rgb[k].b=loc2al_img[i][k].b;

if ( min_rgb[k].r > loc2al_img[i][k].r ) min_rgb[k].r=loc2al_img[i][k].r;

if ( min_rgb[k].g > loc2al_img[i][k].g ) min_rgb[k].g=loc2al_img[i][k].g;

if ( min_rgb[k].b > loc2al_img[i][k].b ) min_rgb[k].b=loc2al_img[i][k].b;

}

// ШАГ 1: конец.

// ШАГ 2: вычисляем максимальную и минимальную яркость для каждой области

mxrgb[k]=0.3*max_rgb[k].r+0.59*max_rgb[k].g+0.11*max_rgb[k].b;

mnrgb[k]=0.3*min_rgb[k].r+0.59*min_rgb[k].g+0.11*min_rgb[k].b;

// ШАГ 2: конец.

// ШАГ 3: вычисляем среднюю яркость для каждой области (пишем их во все составляющие RGB)

Trgb[k].r=(mxrgb[k]+mnrgb[k])/2;

Trgb[k].g=(mxrgb[k]+mnrgb[k])/2;

Trgb[k].b=(mxrgb[k]+mnrgb[k])/2;

// ШАГ 3: конец.

//алгоритм автоматического вычисления порога

while (abs(TTrgb[k].r-Trgb[k].r)>T0 && abs(TTrgb[k].g-Trgb[k].g)>T0 && abs(TTrgb[k].b-Trgb[k].b)>T0 )

{

ct=0;

po=0;

pf=0;

// ШАГ 4: вычисляем среднюю яркость для каждой области (фиксирует ПРОШЛУЮ итерацию)

for(int kk=0;kk<razm;kk++)

{

TTrgb[kk].r=Trgb[kk].r;

TTrgb[kk].g=Trgb[kk].g;

TTrgb[kk].b=Trgb[kk].b;

}

// ШАГ 4: конец.

for (int i=0; i<aRows; i++) //цикл по строкам

{

for(int j=0; j<aCols; j++) //цикл по столбцам

{

flag=loc2al_func_glob_porog(ct,k,Trgb); //определение принадлежности пикселя

if (flag==1) //установка нового значения пикселя (фон)

{

loc2al_pixel_in_fone(ct,k);

pf++;

opred_prinadl_f++;

}

else //установка нового значения пикселя (объект)

{

loc2al_pixel_in_object(ct,k);

po++;

opred_prinadl_o++;

}

ct++;

}

}

if (opred_prinadl_o==0) only_ff[k]++; //если в области только фон

if (opred_prinadl_f<loc2al_tochka_razbienija) only_oo[k]++; //если в области только объект

loc2al_i_flag=0;

loc2al_j_flag=0;

fprintf(file, "opred_prinadl_o=%i\tonly_ff[%i]=%i\topred_prinadl_f=%i\tonly_oo[%i]=%i\n",opred_prinadl_o,k,only_ff[k],opred_prinadl_f,k,only_oo[k]);

// ШАГ 5: вычисляем среднюю яркость для каждой области только по пикселям фона

argb[k].r=loc2al_sred_rgb(pf,0,fon_or_object,k); //среднее по пикселям фона

argb[k].g=loc2al_sred_rgb(pf,1,fon_or_object,k);

argb[k].b=loc2al_sred_rgb(pf,2,fon_or_object,k);

argb[k].r*=0.3;

argb[k].g*=0.59;

argb[k].b*=0.11;

// ШАГ 5: конец.

fon_or_object=1; //теперь для объекта

// ШАГ 6: вычисляем среднюю яркость для каждой области только по пикселям объекта

zrgb[k].r=loc2al_sred_rgb(pf,0,fon_or_object,k); //среднее по пикселям объекта

zrgb[k].g=loc2al_sred_rgb(pf,1,fon_or_object,k);

zrgb[k].b=loc2al_sred_rgb(pf,2,fon_or_object,k);

zrgb[k].r*=0.3;

zrgb[k].g*=0.59;

zrgb[k].b*=0.11;

// ШАГ 6: конец.

// ШАГ 7: переход на следующую итерацию (мнимый, естественно)

Trgb[k].r=(argb[k].r+zrgb[k].r)/2;

Trgb[k].g=(argb[k].g+zrgb[k].g)/2;

Trgb[k].b=(argb[k].b+zrgb[k].b)/2;

// ШАГ 7: конец.

opred_prinadl_o=0;

opred_prinadl_f=0;

}

}

fclose(file);

//**************** ок ************************

for(int i=0;i<razm;i++)

{

TTrgb[i].r=0;

TTrgb[i].g=0;

TTrgb[i].b=0;

max_rgb[i].r=0;

max_rgb[i].g=0;

max_rgb[i].b=0;

min_rgb[i].r=0;

min_rgb[i].g=0;

min_rgb[i].b=0;

mxrgb[i]=0;

mnrgb[i]=0;

}

rez=fopen("rezult.txt","w");

fprintf(rez,"Method: adapt\n\n");

raspredeleneie();

mat_ozhida();

dispersia();

for(int k=0;k<razm;k++)

{

for(int i=0;i<skok;i++)

{

if ( max_rgb[k].r < loc2al_img[i][k].r ) max_rgb[k].r=loc2al_img[i][k].r;

if ( max_rgb[k].g < loc2al_img[i][k].g ) max_rgb[k].g=loc2al_img[i][k].g;

if ( max_rgb[k].b < loc2al_img[i][k].b ) max_rgb[k].b=loc2al_img[i][k].b;

if ( min_rgb[k].r > loc2al_img[i][k].r ) min_rgb[k].r=loc2al_img[i][k].r;

if ( min_rgb[k].g > loc2al_img[i][k].g ) min_rgb[k].g=loc2al_img[i][k].g;

if ( min_rgb[k].b > loc2al_img[i][k].b ) min_rgb[k].b=loc2al_img[i][k].b;

}

mxrgb[k]=max_rgb[k].r + max_rgb[k].g + max_rgb[k].b;

mnrgb[k]=min_rgb[k].r + min_rgb[k].g + min_rgb[k].b;

mxrgb[k]=0.3*max_rgb[k].r+0.59*max_rgb[k].g+0.11*max_rgb[k].b;

mnrgb[k]=0.3*min_rgb[k].r+0.59*min_rgb[k].g+0.11*min_rgb[k].b;

//принимаем решение об изменении дисперсии объекта или фона

if(only_oo[k]>=aCols*aRows*0.1)

{

Trgb[k].r=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_object;

Trgb[k].g=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_object;

Trgb[k].b=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_object;

}

else

{

Trgb[k].r=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_fone;

Trgb[k].g=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_fone;

Trgb[k].b=(mxrgb[k]+mnrgb[k])/2+loc2al_dispers_fone;

}

ct=0;

po=0;

pf=0;

for(int kk=0;kk<razm;kk++)

{

TTrgb[kk].r=Trgb[kk].r;

TTrgb[kk].g=Trgb[kk].g;

TTrgb[kk].b=Trgb[kk].b;

}

fprintf(rez,"\n\n sector №%i \n\n",k);

for (int i=0; i<aRows; i++) //цикл по строкам

{

for(int j=0; j<aCols; j++) //цикл по столбцам

{

flag=loc2al_func_glob_porog(ct,k,Trgb); //определение принадлежности пикселя

if (flag==1) //установка нового значения пикселя

{

loc2al_pixel_in_fone(ct,k);

fprintf(rez,"x=%i\ty=%i\tR=%i\tG=%i\tB=%i\tRGB=%lf\n",j,i,pixel[ct].r,pixel[ct].g,pixel[ct].b,0.3*pixel[ct].r+0.59*pixel[ct].g+0.11*pixel[ct].b);

loc2al_img[ct][k].r=cvet_fon;

loc2al_img[ct][k].g=cvet_fon;

loc2al_img[ct][k].b=cvet_fon;

po++;

glob_pf++;

}

else //установка нового значения пикселя

{

loc2al_pixel_in_object(ct,k);

loc2al_img[ct][k].r=cvet_object;

loc2al_img[ct][k].g=cvet_object;

loc2al_img[ct][k].b=cvet_object;

pf++;

glob_po++;

}

ct++;

glob_ct++;

}

}

fprintf(rez,"\n\nPixel_in_object = %i\nPixel_in_fone = %i\nPixel_in_image = %i\n",po,pf,ct);

loc2al_i_flag=0;

loc2al_j_flag=0;

argb[k].r=loc2al_sred_rgb(pf,0,fon_or_object,k); //среднее по пикселям фона

argb[k].g=loc2al_sred_rgb(pf,1,fon_or_object,k);

argb[k].b=loc2al_sred_rgb(pf,2,fon_or_object,k);

argb[k].r*=0.3;

argb[k].g*=0.59;

argb[k].b*=0.11;

fon_or_object=0;

zrgb[k].r=loc2al_sred_rgb(pf,0,fon_or_object,k); //среднее по пикселям объекта

zrgb[k].g=loc2al_sred_rgb(pf,1,fon_or_object,k);

zrgb[k].b=loc2al_sred_rgb(pf,2,fon_or_object,k);

zrgb[k].r*=0.3;

zrgb[k].g*=0.59;

zrgb[k].b*=0.11;

Trgb[k].r=(argb[k].r+zrgb[k].r)/2;

Trgb[k].g=(argb[k].g+zrgb[k].g)/2;

Trgb[k].b=(argb[k].b+zrgb[k].b)/2;

}

fprintf(rez,"\n VSEGO:\n\nPixel_in_object = %i\nPixel_in_fone = %i\nPixel_in_image = %i\n",glob_pf,glob_po,glob_ct);

fclose(rez);

//**************************************************

// ШАГ 8: переписываем все области в сплошной массив

int count,fun=0,sek=-1,ss=0;

for(int k=0; k<razm; k++)

{

count=0;

sek++;

if(sek==a_kol_razb)

{

sek=0;

fun++;

}

for(int i=0; i<aRows; i++)

{

for(int j=0; j<aCols; j++)

{

ss=j+aCols*a_kol_razb*i+k*aCols+fun*aCols*(aRows-1)*a_kol_razb; //вычисляем нужную область пикселей

a_pixel[ss].r=loc2al_img[count][k].r;

a_pixel[ss].g=loc2al_img[count][k].g;

a_pixel[ss].b=loc2al_img[count][k].b;

count++;

}

}

}

// ШАГ 8: конец.

}

};

loc2al_class loc2; //элемент локальной обработки

//******************************************************************************

//******************************************************************************//************* класс дискриминантного критерия **************************//

//******************************************************************************

//******************************************************************************

//*** ТОЛЬКО ВЫЧИСЛЕНИЯ ПОРОГА!!!

class diskr_class{

public:

ulong diskr_func[255];

ulong mat_ozhid_all_image;

ulong disp_all_image;

double p0,p1;

double m0,m1;

double klass_disp,raspred_func[255];

int porog[3];

int global_flag;

void copy_histo(int flag)

{

switch(flag) //выбираем для какой состовляющей цветового пространства определяем порог