Колоризация полутоновых изображенийx

РЕФЕРАТ
Дипломный проект
Пояснительная записка покачто53 стр., несчиталеще рисунков, 4
таблиц, 5 источников, 2 приложения.
КОЛОРИЗАЦИЯ, СЕГМЕНТАЦИЯ, ЦВЕТ, НЕЙРОННАЯ СЕТЬ,
МНОГОСЛОЙНЫЙ
ПЕРСЕПТРОН,
ИЗОБРАЖЕНИЕ,
ОТЧЕТ,
ИНТЕРФЕЙС.
В дипломном проекте разработана автоматизированная система,
позволяющая
проводить
колоризацию
монотонное
полутоновое
изображение.
Проведен анализ предметной области и по методологии UML
разработан
логический
проект
автоматизированной
информационной
системы.
Программная реализация выполнена в среде разработки IntelliJ Idea
10.0 на языке программирования Java 6.0 (JDK 1.6).
СОДЕРЖАНИЕ
ВВЕДЕНИЕ.................................................................................................... 4
1 СИСТЕМОТЕХНИЧЕСКАЯ ЧАСТЬ .................................................... 5
1.1 Анализ предметной области и постановка задачи
проектирования ................................................................................................... 5
1.1.1 Методы сегментации изображения .......................................... 5
1.1.2 Сегментация как разбиение изображения на однородные
области
...................................................................................................... 6
1.1.3 Оценка качества работы методов сегментации ...................... 6
1.1.4 Кластеризация цветового пространства .................................. 7
1.1.5 Выращивание регионов, дробление-слияние.......................... 8
1.1.6 Методы, основанные на операторах выделения краев .......... 9
1.1.7 Методы теории графов .............................................................. 9
1.1.8 Колоризация изображения нейронной сетью ....................... 12
1.1.9 Аналитический обзор аналогов .............................................. 13
1.2
Постановка задачи ....................................................................... 15
1.3
Разработка модели анализа по методологии UML ................... 16
1.3.1 Диаграмма вариантов использования .................................... 17
1.3.2 Диаграмма классов .................................................................. 20
1.3.3 Диаграмма состояний .............................................................. 24
1.3.4 Диаграмма последовательности и кооперации..................... 25
1.3.5 Диаграмма компонентов ......................................................... 28
1.3.6 Диаграмма развертывания ...................................................... 29
1.3.7 Диаграмма деятельности ......................................................... 30
1.4
Оценка системных и эксплуатационных характеристик ......... 31
1.4.1 Расчет объема ВЗУ .................................................................. 31
1.4.1 Расчет объема ОЗУ .................................................................. 32
1.4.1 Расчет времени реакции системы .......................................... 33
1.4.4 Минимальные требования к системе ..................................... 35
2 КОНСТРУКТОРСКО-ТЕХНОЛОГИЧЕСКАЯ ЧАСТЬ .................... 36
2.1
Обоснование архитектуры системы ........................................... 36
2.2
Выбор и обоснование средств реализации ................................ 36
2.2.1 Выбор языка программирования............................................ 36
2.2.2 Выбор среды программирования ........................................... 37
2.2.3 Выбор операционной среды ................................................... 38
2.3
Описание программной реализации .......................................... 38
2.4
Описание интерфейса .................................................................. 39
2.5
Описание контрольного примера ............................................... 39
2.6
Разработка методики испытания ................................................ 39
2.7 Руководство пользователя .......................................................... 41
3 ЗАКЛЮЧЕНИЕ ..................................................................................... 42
4 Список использованных источников .................................................. 43
ПРИЛОЖЕНИЕ А ....................................................................................... 44
ПРИЛОЖЕНИЕ Б........................................................................................ 52
ВВЕДЕНИЕ
Стремительное развитие информационных технологий привело к
формированию информационной среды, оказывающей влияние на все сферы
человеческой деятельности. С приходом новых технологий жизнь человека
становится насыщеннее и ярче. Старое наследие культурной деятельности
человека теряется на фоне современного качества получаемой информации.
Но нельзя забывать о важности исторических ценностей.
В рамках дипломного проекта разрабатывается приложение, целью
которого ставится преобразование черно-белых полутоновых монотонных
изображений в цветные. Использование ручных методов обладает такими
недостатками,
как
большие
временные
и
финансовые
затраты,
ресурсоемкость и сложность. Разрабатываемая автоматизированная система
должна обладать следующими свойствами:
1) компактность;
2) быстродействие;
3) простота.
Разработка
будет
вестись
по
технологии
быстрой
разработки
приложений RAD (Rapid Application Development), которая поддерживается
методологиями объектно-ориентированного анализа и проектирования и
структурного проектирования, и методологии UML.
1
СИСТЕМОТЕХНИЧЕСКАЯ ЧАСТЬ
1.1 Анализ предметной области и постановка задачи
проектирования
Совместные программные решения позволяют построить комплексную
систему обработки изображения, базирующуюся на новейших технологиях,
использующих механизмы обучения с помощью нейронных сетей. Процесс
преобразования полутонового изображения можно разбить на следующие
этапы: сегментация полутонового изображения на участки с монотонным
изменением яркости изображения и сам процесс колоризации полученных
участков изображения.
Cегментация — это процесс разделения цифрового изображения на
несколько
сегментов
(множество
пикселей,
также
называемых
суперпикселями). Цель сегментации заключается в упрощении и/или
изменении представления изображения, чтобы его было проще и легче
анализировать.[1] Сегментация изображений обычно используется для того,
чтобы выделить объекты и границы (линии, кривые, и т. д.) на изображениях.
Более точно, сегментация изображений — это процесс присвоения таких
меток каждому пикселю изображения, что пиксели с одинаковыми метками
имеют общие визуальные характеристики.
1.1.1 Методы сегментации изображения
Методы сегментации можно разделить на два класса: автоматические –
не требующие взаимодействия с пользователем и интерактивные –
использующие пользовательский ввод непосредственно в процессе работы. В
данной работе рассматриваются только автоматические методы.
Задачи автоматической сегментации делятся на два класса:
1) выделение областей изображения с известными свойствами;
2) разбиение изображения на однородные области.
1.1.2 Сегментация как разбиение изображения на однородные
области
Вначале рассмотрим постановку задачи сегментации, как разбиения
изображения на однородные области. Такая постановка возникла раньше,
чем задача выделения областей изображения с известными свойствами, и
методы этой группы на данный момент хорошо разработаны.
Ясно, что задача разбиения изображения на однородные области
поставлена некорректно. Внизу приведены четыре варианта сегментации
одного и того же изображения из Berkeley Segmentation Dataset, выполненные
разными людьми.
Рисунок 1.1 – Варианты сегментации изображения
Как видно, среди участников эксперимента нет единства в выборе
разбиения изображения. Далеко не всегда для изображения есть единственно
«правильная» сегментация, и далеко не всегда задача сегментации имеет
единственное решение. По той же причине нет и объективного критерия
оценки качества разбиения изображения.
1.1.3 Оценка качества работы методов сегментации
Поскольку сегментация обычно используется не самостоятельно, а как
часть некоторой системы (например, системы машинного зрения), то с
практической точки зрения, качество работы метода оценивается исходя из
работы системы в целом. Поэтому один и тот же метод сегментации может
оказаться хорошим для одной задачи и плохим для другой.
Для грубой оценки качества метода в конкретной задаче обычно
фиксируют несколько свойств, которыми должна обладать хорошая
сегментация. Качество работы метода оценивается в зависимости от того,
насколько полученная сегментация обладает этими свойствами. Наиболее
часто используются следующие свойства:
1) однородность регионов (однородность цвета или текстуры);
2) непохожесть соседних регионов;
3) гладкость границы региона;
4) маленькое количество мелких «дырок» внутри региона;
и т. д.
1.1.4 Кластеризация цветового пространства
В постановке задачи сегментации прослеживается аналогия с задачей
кластеризации (или обучения без учителя). Для того чтобы свести задачу
сегментации к задаче кластеризации, достаточно задать отображение точек
изображения в некоторое пространство признаков и ввести метрику (меру
близости) на этом пространстве признаков.
В качестве признаков точки изображения можно использовать
представление ее цвета в некотором цветовом пространстве, примером
метрики (меры близости) может быть евклидово расстояние между
векторами в пространстве признаков. Тогда результатом кластеризации будет
квантование цвета для изображения. Задав отображение в пространство
признаков, можно воспользоваться любыми методами кластерного анализа.
Наиболее популярные методы кластеризации, используемые для сегментации
изображений – k-средних (обобщенный метод Ллойда), EM алгоритм.
Основная проблема методов кластеризации, состоит в том, что
пространственное расположение точек либо не учитывается совсем, либо
учитывается косвенно (например, используя координаты точки как один из
признаков). Поэтому обычно после кластеризации точек изображения
проводят процедуру выделения связных компонент.
Методы
кластеризации
плохо
работают
на
зашумленных
изображениях: часто теряют отдельные точек регионов, образуется много
мелких регионов, и. т. п.
1.1.5 Выращивание регионов, дробление-слияние
Методы этой группы учитывают пространственное расположение
точек напрямую.
Методы выращивания регионов основаны на следующей идее. Сначала
по некоторому правилу выбираются центры регионов (seeds), к которым
поэтапно присоединяются соседние точки, удовлетворяющие некоторому
критерию. Процесс выращивания регионов (region growing) останавливается,
когда ни одна точка изображения не может быть присоединена ни к одному
региону.
Применяются
разные
критерии,
на
основании
которых
точка
присоединяется или не присоединяется к региону: близость (в некотором
смысле) точки к центру региона; близость к соседней точке, присоединенной
к региону на предыдущем шаге; близость по некоторой статистике региона;
стоимость кратчайшего пути от точки до центра региона, и т. п.
В основном процедура выращивания региона используется для
получения
отдельных
регионов,
однако,
применяя
эту
процедуру
последовательно или одновременно для нескольких регионов, можно
получить разбиение всего изображения. Существуют различные стратегии
выбора зерен (seeds) и выращивания регионов.
Методы дробления-слияния состоят из двух основных этапов:
дробления и слияния. Дробление начинается с некоторого разбиения
изображения, не обязательно на однородные области. Процесс дробления
областей происходит до тех пор, пока не будет получено разбиение
изображения (пересегментация), удовлетворяющее свойству однородности
сегментов. Затем происходит объединение схожих соседних сегментов до тех
пор, пока не будет получено разбиение изображения на однородные области
максимального размера.
Конкретные методы различаются алгоритмами, используемыми на
этапах дробления и слияния. Для получения пересегментации изображения
используются алгоритмы k-средних, watershed, fuzzy expert systems, на
втором этапе используются алгоритмы k-средних, самоорганизующиеся
карты Кохонена, fuzzy expert systems, и т. д. На этапе слияния регионов
используются
relaxation
process,
k-средних,
SIDE-уравнения,
самоорганизующиеся карты Кохонена, и т. д.
1.1.6 Методы, основанные на операторах выделения краев
При данном подходе задача сегментации формулируется как задача
поиска границ регионов. Методы поиска границ хорошо разработаны для
полутоновых изображений. Полутоновое изображение рассматривается как
функция двух переменных (x и y), и предполагается, что границы регионов
соответствуют максимумам градиента этой функции. Для их поиска
применяется аппарат дифференциальной геометрии (в простейшем случае
это фильтры Roberts, Kirsch, Prewitt, Sobel).
Для повышения устойчивости к шуму, перед применением фильтрации
изображение обычно размывают. Благодаря коммутативности оператора
Лапласа и Гауссова фильтра, можно одновременно осуществлять размытие и
поиск границ. В методе Canny комбинируются результаты поиска границ при
разной степени размытия.
Рисунок 1.2 – Результат применения фильтра Canny
1.1.7 Методы теории графов
Методы теории графов – одно из наиболее активно развевающихся
направлений в сегментации изображений.
Общая
идея
методов
этой
группы
следующая.
Изображение
представляется в виде взвешенного графа, с вершинами в точках
изображения. Вес ребра графа отражает сходство точек в некотором смысле
(расстояние между точками по некоторой метрике). Разбиение изображения
моделируется разрезами графа.
Рисунки 1.3-1.4 – Пример моделирования изображения взвешенным графом.
Обычно в методах теории графов вводится функционал «стоимости»
разреза, отражающий качество полученной сегментации. Так задача
разбиения изображения на однородные области сводится к оптимизационной
задаче поиска разреза минимальной стоимости на графе. Такой подход
позволяет помимо однородности цвета и текстуры сегментов управлять
также формой сегментов, их размером, сложностью границ и т. п.
Для поиска разреза минимальной стоимости применяются различные
методы: жадные алгоритмы (на каждом шаге выбирается такое ребро, чтобы
суммарная стоимость разреза была минимальной), методы динамического
программирования
(гарантируется,
что,
выбирая
на
каждом
шаге
оптимальное ребро, получим в итоге оптимальный путь), алгоритм
Дейкстры, и т. п. Рассмотрим некоторые методы теории графов подробнее.
Метод сегментации SWA (Segmentation by Weighted Aggregation)
основан на группировании схожих точек изображения. Основная идея метода
состоит в построении пирамиды взвешенных графов, каждый из которых
получен из предыдущего путем объединения схожих вершин.
На каждом шаге веса связей пересчитываются. В процессе построения
пирамиды вычисляются различные статистики, характеризующие форму,
цвет, текстуру регионов, эти статистики используются для вычисления меры
сходства регионов. Затем, следуя идеологии методов теории графов, для
полученного графа вводится функционал стоимости разреза и ищется разрез
минимальной стоимости. При этом, в отличие от большинства методов
теории графов, SWA имеет сложность O(n), где n - число точек изображения,
причем число операций для каждой точки составляет всего несколько
десятков.
Рисунок 1.5 – Построение пирамиды взвешенных графов для изображения
Рисунок 1.6 – Сравнение результатов работы алгоритма SWA, его
модификации и Normalized cuts
В модификации алгоритма на каждом следующем шаге анализируется
и
корректируется
результат
предыдущего
агрегирования,
а
также
используется информация о границах полученных сегментов.
1.1.8 Колоризация изображения нейронной сетью
Колоризация – любой процесс в ходе которого в монохромное (чёрнобелое
или
тонированное,
например,
в
сепию)
изображение
или
последовательность изображений добавляется цвет.[1]
Цвет – качественная субъективная характеристика электромагнитного
излучения оптического диапазона, определяемая на основании возникающего
физиологического зрительного ощущения и зависящая от ряда физических,
физиологических и психологических факторов. С точки зрения обработки
изображения цвет – составная (например, состоящая из каналов RGB)
характеристики каждого пикселя изображения.[1]
Нейронная сеть – математические модели, а также их программные
или аппаратные реализации, построенные по принципу организации и
функционирования биологических нейронных сетей — сетей нервных клеток
живого организма.[1]
Многослойный персептрон – частный случай персептрона Розенблатта,
в котором один алгоритм обратного распространения ошибки обучает все
слои. Особенностью является наличие более чем одного обучаемого слоя
(как правило — два или три, для применения большего числа на данный
момент нет обоснования, так как теряется скорость без приобретения
качества). Необходимость в большом количестве обучаемых слоев отпадает,
так как теоретически единственного скрытого слоя достаточно, чтобы
перекодировать входное представление таким образом, чтобы получить
линейную карту для выходного представления. Существует предположение,
что, используя большее число слоев, можно уменьшить число элементов в
них, то есть суммарное число элементов в слоях будет меньше, чем если
использовать один скрытый слой.[1]
Изображение – с точки зрения его обработки это область,
распределенная по пространственным координатам x, y и по длинам волн l
описывается функцией с(x, y, l). Эта функция является неотрицательной; ее
максимальное значение в изображающих системах ограничено предельной
величиной светочувствительности регистрирующих сред, 0 <с(x, y, l) < A, где
A - максимальная яркость изображения.[1]
Пример использования: колоризация фильмов. В 2009 году были
колоризованы фильмы «Семнадцать мгновений весны» и «В бой идут одни
старики». Колоризация была организована компанией «Grading Dimension
Pictures» и выполнена на студии «Legend Films» и в Индии. При колоризации
постарались
воспроизвести
цвета
советской
плёнки
1973
года;
дополнительную сложность представляло обилие оттенков зелёного цвета
(до 27 в одном кадре). Стоимость работ составила около 500 тыс. $.
1.1.9 Аналитический обзор аналогов
Колоризация черно-белых изображений – довольно нетривиальная
задача. На сегодняшний день разработано не так много приложений для
автоматизированной реализации подобных действий. Зачастую колоризация
осуществляется вручную – каждому участку изображения меняется функция
яркости в соответствии с необходимым цветом. Это довольно трудоемкое
занятие и затрачивает много времени. Именно поэтому в современных
рыночных условиях колоризация черно-белых изображения обладает
высокой стоимостью, но пользуется большой популярностью. Так, 2009 год
стал годом раскрашивания старых черно-белых фильмов. Первыми были
«Семнадцать мгновений весны», потом «В бой идут одни старики», ну а
дальше и «Золушка», и «Весёлые ребята», и «Волга-Волга». И на этом никто
не собирается останавливаться, в планах ещё очень много раскрашенных
фильмов. При этом стоимость колоризации первого фильма составила
порядка миллиона долларов и были потрачено многие месяцы работы целой
компании (более 600 человек). В настоящее время стоимость колоризации
одной минуты черно-белого фильма составляет порядка 3-5 тысяч долларов
[2].
На мой взгляд, можно выделить следующие приложения для
колоризации черно-белых изображений:
Таблица 1. Сравнительный обзор приложений-аналогов.
Adobe Photoshop
+ сервис
AKVIS
COLORIAGE
Recolored
BlackMagic
Есть
Есть
Нет
Нет
Нет
Есть
Есть
Нет
Возможность задания
автоматической
колоризации
Нет
Есть
Нет
Нет
Цена, р
22 361 – 25 393
3007 – 7 262
1 519
6 200
Наличие русификации
Есть
Нет
Есть
Интерфейс
Удобный
интерфейс,
огромные
возможности по
обработке
изображения
Доступный и
интуитивно
понятный в
работе
интерфейс.
Простой
интерфей
с. Ничего
лишнего
Есть
Требуется
некоторое
время, чтобы
привыкнуть к
расположению
кнопок и
таблиц
Есть
Характеристика
www.colorhunter.c
om
Колоризация путем
изменения параметров
изображения
Возможность выбора
областей колоризации
Наличие справки
Прочие достоинства
Прочие недостатки
Есть
Поддержка
плагинов, лидер
в области
работы с
изображениями
Колоризация не
является
основной целью
работы
продукта.
Высокая
стоимость
Есть
Высокие
показатели
качества
работы
Есть
Лучшие
показател
ь в плане
цены/каче
ства
Высокая
стоимость
Ограничи
вается
числом
шаблонов
Работа
напрямую с
внешними
устройствами
Низкие
показатели
качества
работы
Каждое из перечисленных технических средств обладает своими
плюсами
и
минусами,
но
процесс
выполнения
колоризации
везде
одинаковый – выделяется область монотонной полутоновой части и
обрабатывается отдельно. В рамках разрабатываемого дипломного проекта
выполняется автоматизация именно этого действия.
Таблица 2 – Характеристики проектируемой системы
Характеристика
Колоризация путем
изменения параметров
изображения
Возможность выбора
областей колоризации
Возможность задания
автоматической
колоризации
Цена, р
Наличие русификации
Интерфейс
Наличие справки
Проектируемый комплекс
Есть
Есть
Есть
На стадии тестирования - бесплатно
Есть
Удобный интерфейс, прост в использовании
Есть
Возможность расширения, широкая полоса цветового выбора
для различных яркостей
Ограничен в применении для монотонной колоризации
полутоновых изображений
Прочие достоинства
Прочие недостатки
Вывод: Разрабатываемая АС обладает следующими преимуществами,
по сравнению с аналогами: широкая цветовая полоса для одного значения
яркости
за
счет
использования
нейронных
сетей,
возможность
автоматической сегментации изображения.
1.2 Постановка задачи
В рамках дипломного проекта перед автором поставлена задача
разработать
проект
АС
колоризации
полутонового
монотонного
изображения. Автоматизированная система колоризации должна обладать
следующими функциями:
1) анализ предметной области;
2) разработка логического проекта системы;
3) реализация
и
отладка
алгоритма сегментации
полутонового
изображения;
4) реализация и отладка нейронной сети в виде многослойного
персептрона (MLP);
5) реализация алгоритма преобразования яркости изображения в RGBформат, обучения нейронной сети;
6) программная
реализация
преобразования
полутонового
изображения в цветное с помощью обученной нейронной сети,
выполненной в виде MLP;
7) анализ качества преобразования полутонового изображения в
цветное, расчет погрешности преобразования;
8) описание контрольного примера и результатов испытания.
Подаваемое
изображение
должно
соответствовать
следующим
требованиям:
1) полутоновое;
2) стандартный формат хранения (jpg, png, bmp и т.д.);
3) сравнительно небольшое разрешение обучающих изображений, не
более 800х600 (это связано с тем, что время обучение увеличивается
по
экспоненциальному
закону
при
увеличении
размеров
изображения).
1.3 РАЗРАБОТКА МОДЕЛИ АНАЛИЗА ПО МЕТОДОЛОГИИ
UML
Унифицированный
Languadge),
который
язык
моделирования
предназначен
для
–
UML(Unified
описания,
Modeling
визуализации
и
документирования объектно-ориентированных систем и бизнес процессов с
ориентацией их на последующую реализацию в виде программного
обеспечения. При создании учитывались следующие требования:
1) позволять моделировать не только программное обеспечение, но и
более
широкие
классы
систем
и
бизнес-приложений,
с
использованием объектно-ориентированных понятий;
2) явным
образом
обеспечивать
взаимосвязь
между
базовыми
понятиями для моделей концептуального и физического уровней;
3) обеспечивать масштабируемость моделей, что является важной
особенностью сложных многоцелевых систем;
4) быть
понятным
поддерживать
аналитикам
специальными
и
программистам,
инструментальными
а
также
средствами,
реализованными на различных компьютерных платформах.
Язык
UML
ориентирован
моделирования
для
ориентированного
для
решения
анализа
и
применения
широкого
в
класса
проектирования.
качестве
задач
При
языка
объектно-
этом
термин
«унифицированный» в названии UML не является случайным и имеет два
аспекта.
С
одной
стороны,
он
фактически
устраняет
многие
из
несущественных различий между известными языками моделирования и
методиками построения диаграмм. С другой стороны, создает предпосылки
для унификации различных моделей и этапов их разработки для широкого
класса систем, не только программного обеспечения, но и бизнес-процессов.
Семантика языка UML определена таким образом, что она не является
препятствием для последующих усовершенствований при появлении новых
концепций
моделирования.
Язык
UML
может
быть
расширен
без
переопределения его ядра.
В рамках языка UML все представления о модели сложной системы
фиксируются в виде специальных графических конструкций – диаграмм.
Процесс объектно-ориентированного анализа и проектирования неразрывно
связан с процессом построения диаграмм. При этом совокупность
построенных диаграмм является самодостаточной в том смысле, что в них
содержится вся информация, которая необходима для реализации проекта
сложной системы.
Построение диаграмм для АС «Колоризация монотонных полутоновых
изображений» было
произведено с помощью
CASE-средства UML-
проектирования Enterprise Architect 8.0.864.
1.3.1 Диаграмма вариантов использования
Диаграмма
вариантов
использования
описывает
функциональное
назначение системы, то есть то, что система будет делать в процессе своего
функционирования. Диаграмма вариантов использования является исходным
концептуальным представлением или концептуальной моделью системы в
процессе ее проектирования и разработки.
Разработка диаграммы вариантов использования преследует следующие
цели:
1) определить общие границы и контекст моделируемой предметной
области на начальных этапах проектирования системы;
2) сформулировать общие требования к функциональному поведению
проектируемой системы;
3) разработать концептуальную модель системы для ее последующей
детализации в форме логических и физических моделей;
4) подготовить
исходную
документацию
для
взаимодействия
разработчиков системы с ее заказчиками и пользователями.
Суть данной диаграммы состоит в следующем: проектируемая система
представляется
в
виде
множества
сущностей
или
акторов(actor),
взаимодействующих с системой с помощью так называемых вариантов
использования. При этом актором (actor) или действующим лицом
называется любая сущность, взаимодействующая с системой извне. Это
может быть человек, техническое устройство, программа или любая другая
система, которая может служить источником воздействия на моделируемую
систему так, как определит сам разработчик. В свою очередь вариант
использования (use case) служит для описания сервисов, которые система
предоставляет актору. Другими словами, каждый вариант использования
определяет некоторый набор действий, совершаемый системой при диалоге с
актором. При этом ничего не говорится о том, каким образом будет
реализовано взаимодействие акторов с системой.
Помимо акторов и вариантов использования, на данной диаграмме можно
расположить:
Интерфейсы – служащие для спецификации параметров модели, которые
видимы
извне
без
указания
внутренней
структуры.[1]
Интерфейсы
определяют совокупность операций, которые обеспечивают необходимый
набор сервисов или функциональности для акторов.
Примечания – предназначенные для включения в модель произвольной
текстовой информации, имеющей непосредственное отношение к контексту
разрабатываемого проекта.
Отношения – описывающие взаимодействия экземпляров одних акторов
и вариантов использования с экземплярами других акторов и вариантов. В
языке UML имеется несколько стандартных видов отношений между
акторами и вариантами использования:
Отношение ассоциации – служит для обозначения специфической роли
актора в отдельном варианте использования.
Отношение
расширения
–
определяет
взаимосвязь
экземпляров
отдельного варианта использования с более общим вариантом, свойства
которого определяются на основе способа совместного объединения данных
экземпляров. Отношение расширения является направленным и отмечает тот
факт, что один из вариантов использования может присоединить к своему
поведению некоторое дополнительное поведение, определенное для другого
варианта использования.
Отношение обобщения – применяется в том случае, когда необходимо
отметить, что дочерние варианты использования обладают всеми атрибутами
и особенностями родительских вариантов. При этом дочерние варианты
использования участвуют во всех отношениях родительских вариантов. В
свою очередь, дочерние варианты могут наделяться новыми свойствами
поведения, которые отсутствуют у родительских вариантов использования, а
также уточнять или модифицировать наследуемые от них свойства
поведения.
Отношение включения – указывает, что некоторое заданное поведение
для одного варианта использования включается в качестве составного
компонента
в
последовательность
поведения
другого
варианта
использования. Данное отношение является направленным и бинарным [3].
На диаграмме вариантов использования подсистемы принятия решения
были предложены следующие акторы:
пользователь – – использует подсистему для редактирования настроек
сетей, проводит ее обучение с заданными параметрами и тестирование
обученной сети, проводит сегментацию и колоризацию изображения.
Также на диаграмме предложены следующие варианты использования
подсистемы:
 работа с изображением;
 работа с сетью.
Диаграмма вариантов использования подсистемы принятия решения
представлена на рисунке 1.7.
uc UseCase
Работать с
изображением
Сохранить
изображение
«extend»
«extend»
«extend»
«extend»
Загрузить
изображение
Сегментировать
изображение
Пользователь
«include»
Колоризация
изображения
«include»
«include»
Работать с сетью
«extend»
«include»
Загрузить сеть
«extend»
«extend»
Удалить сеть
Сохранить сеть
«extend»
Обучить сеть
Рисунок 1.7 – Диаграмма вариантов использования
1.3.2 Диаграмма классов
Диаграмма классов служит для представления статической структуры
модели системы в терминологии классов объектно-ориентированного
программирования. Диаграмма классов может отражать, в частности,
различные взаимосвязи между отдельными сущностями предметной области,
такими как объекты и подсистемы, а также описывает их внутреннюю
структуру и типы отношений. Диаграмма классов является дальнейшим
развитием концептуальной модели проектируемой системы.
Диаграмма классов состоит из множества элементов, которые в
совокупности отражают декларативные знания о предметной области. Эти
знания интерпретируются в базовых понятиях языка UML, таких как классы,
интерфейсы и отношения между ними и их составляющими компонентами.
Класс в языке UML служит для обозначения множества объектов,
которые обладают одинаковой структурой, поведением и отношениями с
объектами из других классов. Обязательным элементом обозначения класса
является его имя. Оно должно быть уникальным. По мере проработки
отдельных
компонентов
диаграммы,
описания
классов
дополняются
атрибутами (свойствами) и операциями (сервисами).
Кроме
внутреннего
устройства
или
структуры
классов,
на
соответствующей диаграмме указываются различные отношения между
классами. Базовыми отношениями или связями в языке UML являются:
Отношение зависимости – в общем случае указывает некоторое
семантическое отношение между двумя элементами модели или двумя
множествами таких элементов, которое не является отношением ассоциации,
обобщения или реализации. Отношение зависимости используется в такой
ситуации, когда некоторое изменение одного элемента модели может
потребовать изменения другого зависимого от него элемента модели.
Отношение
ассоциации
–
соответствует
наличию
некоторого
отношения между классами. Частным случаем отношения ассоциации
является отношение агрегации (когда один из классов представляет собой
некоторую сущность, включающую в себя в качестве составных частей
другие сущности), которые, в свою очередь, тоже имеет специальную форму
– отношение композиции (служит для выделения специальной формы
отношения «часть-целое», при которой составляющие части не могут
выступать в отрыве от целого, т.е. с уничтожением целого уничтожаются и
все его части).
Отношение обобщения – отношение между более общим элементом
(родителем или предком) и более частным и специальным элементом
(дочерним или потомком) [3].
В качестве нейронной сети была выбрана структура многослойного
персептрона с одним нейроном во входном слое (на него подается
нормализованное значение яркости изображения), опциональное значение
нейронов в скрытом слое и 3 нейрона в выходном слое (соответственно
каналы RGB).
class core
-parentNetwork
Observable
Runnable
Serializable
NeuralNetw ork
-
serialVersionUID: long = 4L {readOnly}
type: NeuralNetworkType
layers: List<Layer>
inputNeurons: List<Neuron>
outputNeurons: List<Neuron>
learningRule: LearningRule
learningThread: Thread
plugins: Map<Class, PluginBase>
label: String = ""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
NeuralNetwork()
addLayer(Layer) : void
addLayer(int, Layer) : void
removeLayer(Layer) : void
removeLayerAt(int) : void
getLayersIterator() : Iterator<Layer>
getLayers() : List<Layer>
getLayerAt(int) : Layer
indexOf(Layer) : int
getLayersCount() : int
setInput(double) : void
getOutput() : double[]
calculate() : void
reset() : void
run() : void
learnInNewThread(TrainingSet) : void
learnInNewThread(TrainingSet, LearningRule) : void
learnInSameThread(TrainingSet) : void
learnInSameThread(TrainingSet, LearningRule) : void
stopLearning() : void
pauseLearning() : void
resumeLearning() : void
randomizeWeights() : void
randomizeWeights(double, double) : void
initializeWeights(double) : void
initializeWeights(Random) : void
initializeWeights(double, double) : void
getNetworkType() : NeuralNetworkType
setNetworkType(NeuralNetworkType) : void
getInputNeurons() : List<Neuron>
setInputNeurons(List<Neuron>) : void
getOutputNeurons() : List<Neuron>
setOutputNeurons(List<Neuron>) : void
getLearningRule() : LearningRule
setLearningRule(LearningRule) : void
getLearningThread() : Thread
notifyChange() : void
createConnection(Neuron, Neuron, double) : void
toString() : String
save(String) : void
load(String) : NeuralNetwork
load(InputStream) : NeuralNetwork
addPlugin(PluginBase) : void
getPlugin(Class) : PluginBase
removePlugin(String) : void
getLabel() : String
setLabel(String) : void
Serializable
Layer
#
-
serialVersionUID: long = 3L {readOnly}
parentNetwork: NeuralNetwork
neurons: List<Neuron>
label: String
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Layer()
Layer(int, NeuronProperties)
setParentNetwork(NeuralNetwork) : void
getParentNetwork() : NeuralNetwork
getNeuronsIterator() : Iterator<Neuron>
getNeurons() : List<Neuron>
addNeuron(Neuron) : void
addNeuron(int, Neuron) : void
setNeuron(int, Neuron) : void
removeNeuron(Neuron) : void
removeNeuronAt(int) : void
getNeuronAt(int) : Neuron
indexOf(Neuron) : int
getNeuronsCount() : int
calculate() : void
reset() : void
randomizeWeights() : void
randomizeWeights(double, double) : void
initializeWeights(double) : void
initializeWeights(Random) : void
initializeWeights(double, double) : void
getLabel() : String
setLabel(String) : void
Serializable
Connection
#
#
#
serialVersionUID: long = 1L {readOnly}
fromNeuron: Neuron
toNeuron: Neuron
weight: Weight
+
+
+
+
+
+
+
+
+
+
+
Connection(Neuron, Neuron)
Connection(Neuron, Neuron, Weight)
Connection(Neuron, Neuron, double)
getWeight() : Weight
setWeight(Weight) : void
getInput() : double
getWeightedInput() : double
getFromNeuron() : Neuron
setFromNeuron(Neuron) : void
getToNeuron() : Neuron
setToNeuron(Neuron) : void
Serializable
#parentLayer
Neuron
#
#
#
#
#
#
#
#
-
+
+
+
+
+
+
+
+
+
+
+
+
#
+
+
+
+
#fromNeuron +
+
+
+
+
+
+
+
+
+
+
#toNeuron +
+
+
+
+
+
serialVersionUID: long = 3L {readOnly}
parentLayer: Layer
inputConnections: List<Connection> = new ArrayList<C...
outConnections: List<Connection> = new ArrayList<C...
netInput: double = 0
output: double = 0
error: double = 0
inputFunction: InputFunction
transferFunction: TransferFunction
label: String
Neuron()
Neuron(InputFunction, TransferFunction)
calculate() : void
reset() : void
setInput(double) : void
getNetInput() : double
getOutput() : double
hasInputConnections() : boolean
getInputsIterator() : Iterator<Connection>
addInputConnection(Connection) : void
addInputConnection(Neuron) : void
addInputConnection(Neuron, double) : void
addOutputConnection(Connection) : void
getInputConnections() : List<Connection>
getOutConnections() : List<Connection>
removeInputConnectionFrom(Neuron) : void
getConnectionFrom(Neuron) : Connection
setInputFunction(InputFunction) : void
setTransferFunction(TransferFunction) : void
getInputFunction() : InputFunction
getTransferFunction() : TransferFunction
setParentLayer(Layer) : void
getParentLayer() : Layer
getWeightsVector() : List<Weight>
getError() : double
setError(double) : void
setOutput(double) : void
randomizeInputWeights() : void
randomizeInputWeights(double, double) : void
initializeWeights(double) : void
initializeWeights(Random) : void
initializeWeights(double, double) : void
getLabel() : String
setLabel(String) : void
java.io.Serializable
Weight
#weight +
+
+
+
+
+
+
+
+
+
+
serialVersionUID: long = 1L {readOnly}
trainingData: TrainingData
value: double
Weight()
Weight(double)
initTrainingDataBuffer(int) : void
inc(double) : void
dec(double) : void
setValue(double) : void
getValue() : double
toString() : String
randomize() : void
randomize(double, double) : void
getTrainingData() : TrainingData
Рисунок 1.8 – Диаграмма классов структуры нейросети
На рисунке 1.8 изображена диаграмма классов структуры нейросети.
Класс NeuralNetwork представляет собой нейронную сеть, состоящую из
слоев (класс Layer), которые в свою очередь состоят из нейронов (класс
Neuron). Нейроны соединяются между собой связями (класс Connection),
которые имеют в качестве характеристики определенный вес (класс Wieght).
class learning
SupervisedLearning
Serializable
DynamicBackPropagation
-
serialVersionUID: long = 1L {readOnly}
maxLearningRate: double = 0.9d
minLearningRate: double = 0.1d
learningRateChange: double = 0.99926d
useDynamicLearningRate: boolean = true
maxMomentum: double = 0.9d
minMomentum: double = 0.1d
momentumChange: double = 0.99926d
useDynamicMomentum: boolean = true
+
#
#
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
DynamicBackPropagation()
adjustLearningRate() : void
adjustMomentum() : void
doLearningEpoch(TrainingSet) : void
getLearningRateChange() : double
setLearningRateChange(double) : void
getMaxLearningRate() : double
setMaxLearningRate(double) : void
getMaxMomentum() : double
setMaxMomentum(double) : void
getMinLearningRate() : double
setMinLearningRate(double) : void
getMinMomentum() : double
setMinMomentum(double) : void
getMomentumChange() : double
setMomentumChange(double) : void
getUseDynamicLearningRate() : boolean
setUseDynamicLearningRate(boolean) : void
getUseDynamicMomentum() : boolean
setUseDynamicMomentum(boolean) : void
SigmoidDeltaRule
LMS
#
serialVersionUID: long = 1L {readOnly}
batchMode: boolean = false
trainingDataBufferSize: int = 2
+
#
#
#
#
+
+
+
#
#
+
#
+
+
#
LMS()
updatePatternError(double[]) : void
updateTotalNetworkError() : void
updateNetworkWeights(double[]) : void
updateNeuronWeights(Neuron) : void
isBatchMode() : boolean
setBatchMode(boolean) : void
doLearningEpoch(TrainingSet) : void
applyWeightChange(Weight, double) : void
batchModeWeightsUpdate() : void
setNeuralNetwork(NeuralNetwork) : void
initTrainingDataBuffer() : void
getTrainingDataBufferSize() : int
setTrainingDataBufferSize(int) : void
updateTotalNetworkError(double[]) : void
-
serialVersionUID: long = 1L {readOnly}
+
#
#
SigmoidDeltaRule()
updateNetworkWeights(double[]) : void
adjustOutputNeurons(double[]) : void
-
serialVersionUID: long = 1L {readOnly}
+
#
#
-
BackPropagation()
updateNetworkWeights(double[]) : void
adjustHiddenLayers() : void
calculateDelta(Neuron) : double
#
serialVersionUID: long = 1L {readOnly}
momentum: double = 0.25d
+
#
+
+
MomentumBackpropagation()
updateNeuronWeights(Neuron) : void
getMomentum() : double
setMomentum(double) : void
BackPropagation
MomentumBackpropagation
Рисунок 1.9 – Диаграмма классов обучения нейросети
class lerning
Observable
Runnable
Serializable
Serializable
EngineIndexableSet -trainingSet
TrainingSet
Serializable
SupervisedLearning
LearningRule
-
serialVersionUID: long = 2L {readOnly}
elements: List<TrainingElement>
inputVectorSize: int = 0
outputVectorSize: int = 0
label: String
filePath: String
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
TrainingSet()
TrainingSet(String)
TrainingSet(int)
TrainingSet(int, int)
addElement(TrainingElement) : void
removeElementAt(int) : void
iterator() : Iterator<TrainingElement>
trainingElements() : List<TrainingElement>
elementAt(int) : TrainingElement
clear() : void
isEmpty() : boolean
size() : int
getLabel() : String
setLabel(String) : void
setFilePath(String) : void
getFilePath() : String
toString() : String
save(String) : void
save() : void
load(String) : TrainingSet
getIdealSize() : int
getOutputSize() : int
getInputSize() : int
isSupervised() : boolean
getRecord(long, EngineData) : void
getRecordCount() : long
openAdditional() : EngineIndexableSet
#
-
serialVersionUID: long = 1L {readOnly}
neuralNetwork: NeuralNetwork
trainingSet: TrainingSet
stopLearning: volatile boolean = false
+
+
+
+
+
+
+
+
+
#
+
LearningRule()
setTrainingSet(TrainingSet) : void
getTrainingSet() : TrainingSet
getNeuralNetwork() : NeuralNetwork
setNeuralNetwork(NeuralNetwork) : void
run() : void
setStarted() : void
stopLearning() : void
isStopped() : boolean
notifyChange() : void
learn(TrainingSet) : void
Serializable
IterativeLearning
Serializable
EngineData
Serializable
TrainingElement
TrainingData
+
+
serialVersionUID: long = 1L {readOnly}
trainingDataBuffer: double ([])
DELTA_WEIGHT_SUM: int = 0 {readOnly}
PREVIOUS_WEIGHT: int = 1 {readOnly}
+
+
+
TrainingData(int)
get(int) : double
set(int, double) : void
#
serialVersionUID: long = 1L {readOnly}
input: double ([])
+
+
+
+
+
+
+
+
TrainingElement(double)
getInput() : double[]
setInput(double[]) : void
isSupervised() : boolean
getIdealArray() : double[]
getInputArray() : double[]
setIdealArray(double[]) : void
setInputArray(double[]) : void
#
#
#
#
-
serialVersionUID: long = 1L {readOnly}
learningRate: double = 0.1d
currentIteration: int = 0
maxIterations: int = Integer.MAX_VALUE
iterationsLimited: boolean = false
pausedLearning: volatile boolean = false
+
+
+
+
+
+
+
+
#
+
+
+
+
IterativeLearning()
getLearningRate() : double
setLearningRate(double) : void
setMaxIterations(int) : void
getCurrentIteration() : Integer
isPausedLearning() : boolean
pause() : void
resume() : void
reset() : void
learn(TrainingSet) : void
learn(TrainingSet, int) : void
doOneLearningIteration(TrainingSet) : void
doLearningEpoch(TrainingSet) : void
#
#
#
#
#
-
serialVersionUID: long = 3L {readOnly}
totalNetworkError: double
patternErrorSqrSum: double
totalPatternErrorSqrSum: double
previousEpochError: double
maxError: double = 0.01d
minErrorChange: double = Double.POSITIVE...
minErrorChangeIterationsLimit: int = Integer.MAX_VALUE
minErrorChangeIterationsCount: int
+
+
+
#
+
#
#
#
#
+
+
+
+
+
+
+
+
+
#
#
#
#
SupervisedLearning()
learn(TrainingSet, double) : void
learn(TrainingSet, double, int) : void
reset() : void
doLearningEpoch(TrainingSet) : void
hasReachedStopCondition() : boolean
errorChangeStalled() : boolean
learnPattern(SupervisedTrainingElement) : void
getPatternError(double[], double[]) : double[]
setMaxError(double) : void
getMaxError() : double
getTotalNetworkError() : double
getPreviousEpochError() : double
getMinErrorChange() : double
setMinErrorChange(double) : void
getMinErrorChangeIterationsLimit() : int
setMinErrorChangeIterationsLimit(int) : void
getMinErrorChangeIterationsCount() : int
updateTotalNetworkError(double[]) : void
updateNetworkWeights(double[]) : void
updatePatternError(double[]) : void
updateTotalNetworkError() : void
Serializable
Superv isedTrainingElement
-
serialVersionUID: long = 1L {readOnly}
desiredOutput: double ([])
+
+
+
+
+
+
SupervisedTrainingElement(double[], double[])
getDesiredOutput() : double[]
setDesiredOutput(double[]) : void
getIdealArray() : double[]
setIdealArray(double[]) : void
isSupervised() : boolean
Рисунок 1.10 – Диаграмма классов обучающих выборок сети
Обучение нейросети может производиться различными алгоритмами.
Диаграмма классов обучения нейронной сети изображена на рисунке 1.9. Как
видно из диаграммы, новые алгоритмы являются улучшением старых, но при
этом в них используются возможности прежних алгоритмов обучения.
Для работы с выборками используется универсальная структура
данных работы с выборками, связанная со всеми обучающими алгоритмами.
Диаграмма классов работы с выборками изображена на рисунке 1.10.
1.3.3 Диаграмма состояний
Главное предназначение этой диаграммы – описать возможные
последовательности состояний и переходов, которые в совокупности
характеризуют поведение элемента модели в течение его жизненного цикла.
Диаграмма состояний представляет динамическое поведение сущностей, на
основе спецификации их реакции на восприятие некоторых конкретных
событий. Системы, которые реагируют на внешние действия от других
систем или от пользователей, иногда называют реактивными. Если такие
действия инициируются в произвольные случайные моменты времени, то
говорят об асинхронном поведении модели.
Хотя диаграммы состояний чаще всего используются для описания
поведения отдельных экземпляров классов (объектов), но они также могут
быть применены для спецификации функциональности других компонентов
моделей, таких как варианты использования, актеры, подсистемы, операции
и методы.
Диаграмма состояний по существу является графом специального вида,
который представляет некоторый автомат. Понятие автомата в контексте
UML обладает довольно специфической семантикой, основанной на теории
автоматов. Вершинами этого графа являются состояния и некоторые другие
типы
элементов
автомата
(псевдосостояния),
которые
изображаются
соответствующими графическими символами. Дуги графа служат для
обозначения переходов из состояния в состояние. Диаграммы состояний
могут быть вложены друг в друга, образуя вложенные диаграммы более
детального представления отдельных элементов модели [3].
На рисунке 1.11 представлена «Общая» диаграмма состояний. Далее на
рисунке 1.12 диаграмма раскрывается до работы приложения и ведения
справочника.
stm Stage Diagram
Работа приложения
[нажатие кнопки "Отмена"]
Завершение работы
[подтверждение выхода]
[выбор пункта меню "Выход"]
Final
Рисунок 1.11 – Общая диаграмма состояний
stm Работа приложения
[выбор пункта
меню "Работа
с нейронными
сетями"]
Работа с нейронными сетями
Ожидание действий
пользователя
[нажитие кнопки "Обучить"]
[выход из режима
обучения сети]
[нажате кнопки "Удалить"]
[нажате
кнопки
"Закрыть"]
Обучение сети
Завершени работы
программы
Ожидание действий
пользователя
[нажатие
кнопки
"Закрыть"]
[Нажате кнопки
"Колоризация
изображения"]
Выбор изображения
Удаление сети
[нажате
кнопки
"Создать"]
[нажатие кнопки "Выход"]
Создание сети
[закрытие окна работы с сетями]
[нажатие
кнопки
"Закрыть"]
[нажатие кнопки "Выбор"]
Настрока параметров
сегментации
Завершение работы с
нейронными сетями
[нажатие
кнопки
"Закрыть"]
Просмотр
колоризированного
изображения
[нажатие кнопки "Сегментировать"]
[нажатие кнопки "Колоризировать"]
Сопоставление
сегментированных
участков и нейронных
сетей
Рисунок 1.12 – Диаграмма состояний «Работа приложения»
Из диаграммы видно поведение и состояние системы в ходе
выполнения различных действий пользователем.
1.3.4 Диаграмма последовательности и кооперации
В
языке
UML
взаимодействие
элементов
рассматривается
в
информационном аспекте их коммуникации, т. е. взаимодействующие
объекты обмениваются между собой некоторой информацией. При этом
информация принимает форму законченных сообщений. Другими словами,
хотя сообщение и имеет информационное содержание, оно приобретает
дополнительное свойство оказывать направленное влияние на своего
получателя. Это полностью согласуется с принципами ООАП, когда любые
виды информационного взаимодействия между элементами системы должны
быть сведены к отправке и приему сообщений между ними.
Для
моделирования
взаимодействия
объектов
в
языке
UML
используются соответствующие диаграммы взаимодействия. Говоря об этих
диаграммах, имеют в виду два аспекта взаимодействия. Во-первых,
взаимодействия объектов можно рассматривать во времени, и тогда для
представления временных особенностей передачи и приема сообщений
между объектами используется диаграмма последовательности. Этот вид
канонических диаграмм является предметом изучения настоящей главы.
Ранее, при изучении диаграмм состояния и деятельности, было
отмечено
одно
немаловажное
обстоятельство.
Хотя
рассмотренные
диаграммы и используются для спецификации динамики поведения систем,
время в явном виде в них не присутствует. Однако временной аспект
поведения может иметь существенное значение при моделировании
синхронных процессов, описывающих взаимодействия объектов. Именно для
этой цели в языке UML используются диаграммы последовательности.
Во-вторых,
можно
рассматривать
структурные
особенности
взаимодействия объектов. Для представления структурных особенностей
передачи и приема сообщений между объектами используется диаграмма
кооперации [3].
На рисунке 1.13 изображена диаграмма последовательности действий
системы при выполнении процесса сегментирования изображения.
На рисунке 1.14
использования
изображена диаграмма кооперации для варианта
«Колоризация
изображения».
Из
рисунка
видна
последовательность действий системы и пользователя в ходе выполнения
колоризации изображения.
sd Sequence Diagram
Форма загрузки
изобрежения
Менеджер
приложения
Форма заполнения
параметров
с егментирования
Пользователь
Форма с опос тавления
учас тков изображения
с етям
показать()
с пис ок изображений() :List()
выбрать изображение()
изображение()
отобразить изображение()
Форма заполнения параметров() :Form
параметры()
параметры()
Сегментация изображения()
Сегментированное изображение()
Форма с с егментированным изображением() :Form
Рисунок 1.13 – Диаграмма последовательности для варианта
«Сегментировать сеть»
sd Communication Diagram
:NeuralNetw ork
6: network() :NeuralNetwork
5: loadNetwork(networkID)
2: ShowForm()
9: ShowColorizedImage()
1: CreateForm()
:ImageForm
:AppManager
Пользователь
4: selectNetwokt(networkID)
3: selectNetwork(networkName)
8: :Image
10: CloseForm()
7: colorizeImage()
:BufferredImage
Рисунок 1.14 – Диаграмма кооперации для варианта «Колоризация
изображения»
1.3.5 Диаграмма компонентов
Диаграмма компонентов, в отличие от ранее рассмотренных диаграмм,
описывает особенности физического представления системы. Диаграмма
компонентов позволяет определить архитектуру разрабатываемой системы,
установив зависимости между программными компонентами, в роли которых
может выступать исходный, бинарный и исполняемый код. Во многих средах
разработки модуль или компонент соответствует файлу. Пунктирные
стрелки, соединяющие модули, показывают отношения взаимозависимости,
аналогичные тем, которые имеют место при компиляции исходных текстов
программ. Основными графическими элементами диаграммы компонентов
являются компоненты, интерфейсы и зависимости между ними.
Диаграмма компонентов разрабатывается для следующих целей:
 Визуализации общей структуры исходного кода программной
системы.
 Спецификации исполнимого варианта программной системы.
 Обеспечения
многократного
использования
отдельных
фрагментов программного кода.
 Представления концептуальной и физической схем баз данных
[3].
Диаграмма компонентов клиентской и серверной частей представлена
на рисунке:
cmp Component Diagram
«executable»
JDK1.6 j av a.exe
«library»
io.j ar
«use»
«use»
Интерфейс работы с нейросетями
«component»
Модуль
представления
«library»
sw ing.j ar
«use»
«component»
Модуль работы с
нейросетями
Интерфейс работы с изображениями
«component»
Модуль работы с
изображениями
Рисунок 1.15 – Диаграмма компонентов
 JDK 1.6 java.exe – JVM (Java Virtual Machine): основной модуль для
работы java-приложений;
 swing.jar
–
библиотека
для
отображения
компонентов
пользовательского интерфейса;
 io.jar – библиотека для ввода/вывода данных из/в файла.
 Модуль представления – компонент, работающий с объектами
пользовательского интерфейса;
 Модуль работы с изображениями – компонент, служащий с обработки
операций работы с изображениями.
1.3.6 Диаграмма развертывания
Диаграмма развертывания предназначена для визуализации элементов
и компонентов программы, существующих лишь на этапе ее исполнения
(runtime).
При
этом
представляются
только
компоненты-экземпляры
программы, являющиеся исполнимыми файлами или динамическими
библиотеками. Те компоненты, которые не используются на этапе
исполнения, на диаграмме развертывания не показываются. Так, компоненты
с исходными текстами программ могут присутствовать только на диаграмме
компонентов. На диаграмме развертывания они не указываются.
Диаграмма
развертывания
содержит
графические
изображения
процессоров, устройств, процессов и связей между ними. В отличие от
диаграмм логического представления, диаграмма развертывания является
единой для системы в целом, поскольку должна всецело отражать
особенности ее реализации. Эта диаграмма, по сути, завершает процесс
ООАП для конкретной программной системы и ее разработка, как правило,
является последним этапом спецификации модели.
Цели, преследуемые при разработке диаграммы развертывания:
 Определить
распределение
компонентов
системы
по
ее
физическим узлам.
 Показать физические связи между всеми узлами реализации
системы на этапе ее исполнения.
 Выявить узкие места системы и реконфигурировать ее топологию
для достижения требуемой производительности [3].
deployment Deployment Diagram
«device»
Рабочая станция пользователя
«executable»
Component
Diagram::JDK1.6
j av a.exe
«use»
«component»
Component
Diagram::Модуль
представления
Интерфейс работы с изображениями
«use»
«use»
Интерфейс работы с нейросетями
«component»
Component
Diagram::Модуль
работы с
изображениями
«library»
Component
Diagram::io.j ar
«library»
Component
Diagram::sw ing.j ar
«component»
Component
Diagram::Модуль
работы с
нейросетями
Рисунок 1.16 – Диаграмма развертывания
На рисунке 1.16 предоставления диаграмма развертывания системы.
Каждая рабочая станция содержит все приложение целиком. Общим у всех
станций является сервер базы данных.
1.3.7 Диаграмма деятельности
Диаграммы деятельности используются для моделирования процесса
выполнения операций. Каждое состояние на диаграмме деятельности
соответствует выполнению некоторой элементарной операции, а переход в
следующее состояние срабатывает только при завершении этой операции в
предыдущем состоянии [3].
На рисунке 1.17 изображена диаграмма деятельности обучения
нейросети на основе эталонного изображения.
act Activ ity
Загрузка картинок
Задание максимальной
ошибки обучения
Создание сети с
начальными параметрами
Присвоение начальных
значений нейронам сети
переход к начальной
точке изображения
Вс е точки пройдены
[no]
Расчет ошибки
[yes]
Значение ошибки выше указанной
[no]
[yes]
Уточнение параметров
сети
Рисунок 1.17 – Диаграмма деятельности обучения нейросети
1.4 ОЦЕНКА СИСТЕМНЫХ И ЭКСПЛУАТАЦИОННЫХ
ХАРАКТЕРИСТИК
1.4.1 Расчет объема ВЗУ
Для того чтобы определить минимальные требования к системе,
требуется рассчитать объём используемой памяти как на жёстком диске, так
и в оперативной памяти:
На жестком диске:
 WindowsXP – 750 Мб
 Oracle XE 10 – 980 Мб
 Исполняемый файл программы colorizer.jar – 3 Мб
 Подгружаемые библиотеки .jar – 15 Мб
 Папка с рисунками – 8 Мб
Со временем количество используемых сетей накапливается. Но
следует учитывать, что система рассчитана на использование готовых
обученных сетей. То есть чем больше накапливается в системе готовых
решений, тем меньше будет создаваться новых нейронных сетей. Каждая
сеть занимает примерно 4Кб на жестком диске. Изначально создается 8-9
нейронных сетей в день. Со временем требование к созданию новых сетей,
учитывая использование старых отпадает, и будет создаваться 1-3 нейронные
сети в день. Учитывая среднее число за 5 лет использования программы
будет создано максимум 1000 нейронных сетей.
Расчёт объёма жёсткого диска ведётся по формуле:
Vжд = Voc + Vд + [Vсоп.прог.]
Vжд = 750 Mб + 3 Мб +8 Мб + 15 Мб = 786 Мб
В результате минимальный объём памяти на жёстком диске составляет
около 1 Гб.
1.4.1 Расчет объема ОЗУ
Расчёт объёма ОЗУ ведётся по формуле:
Vозу = Voc + Vпс + Vд + [Vсоп.прог.]
Vозу = 300 Mб + 4.5 Мб + 512 Мб = 816.5 Мб
Учитывая, что работа будет проводиться с графической информацией,
округляем объем ОЗУ в большую сторону. В результате минимальный объём
оперативной памяти составляет около 1 Гб.
Расчет необходимого объема ОЗУ производится по формуле (1.1) .
ОП
ОП
V ОП  VОС
 Vпрограммы
(1.1)
ОП
где VОС
– объем оперативной памяти, необходимой операционной
системе;
ОП
Vпрограммы
– объем оперативной памяти, необходимый программе..
В оперативной памяти.
ОП
VОС
=8812 Мб;
ОП
Vпрограммы
=5,79 Мб;
В качестве данных, используемых системой, выступают обучающие
данные, картинки и нейронные сети. Тогда объем оперативной памяти,
необходимой для хранения данных можно вычислить по формуле (1.2).
ОП
ОП
ОП
V Данных
 Vвыборки
 Vнейросети
(1.2)
ОП
где Vвыборки
– объем оперативной памяти, необходимой для хранения
выборки;
ОП
– объем оперативной памяти, необходимый для хранения
Vнейросети
структуры нейронной сети.
В любой момент работы программы используется не более одной
обучающей выборки (одной тестирующей выборки), и одной нейронной
сети. Максимальный объем обучающей выборки – 480000 пикселей.
ОП
Vвыборки
 480000  4 10 6
Мб=200Кб;
При расчете объема оперативной памяти, занимаемого нейронной
сетью, будем считать, что максимальное число входов равно 1(для функции
яркости), число нейронов промежуточного слоя 50, выходного слоя 3.
ОП
Vнейросети
 N нейронов  vнейрона  v управления
ОП
Vнейросети
 (50  72  104)  10 6
(1.3)
Мб=3,704 Кб.
ОП
ОП
ОП
V Данных
 Vвыборки
 Vнейросети
=2,8Кб + 3,704Кб=6,504Кб.
Тогда из (1.6) следует, что минимальный объем оперативной памяти,
необходимый для функционирования системы равен:
VОП=812 Мб + 5,79 Мб + 6.804Кб=819 Мб.
1.4.1 Расчет времени реакции системы
Время реакции системы рассчитывается по формуле (1.4).
tреакции=tввода+tвычисления+tвывода
где tввода – время ввода параметров сети и алгоритма обучения;
tвычисления – время вычислений, связанных с обучением сети;
tвывода – время вывода результатов на экран.
Время ввода параметров вычисляется по формуле (1.5).
(1.4)
tввода=Lсимв ∙ tсимв
(1.5)
где Lсимв – количество символов в запросе;
tсимв – время ввода одного символа, обычно tсимв=1.5 с
Время вычислений, т.е. процесса обучения рассчитывается по формуле
(1.6).
t вычисления 
N опер  k м к
(1.6)
f
где Nопер – количество операторов,
kмк – среднее количество машинных команд, затрачиваемых на
реализацию одного оператора,
f – тактовая частота процессора в герцах.
Время вывода результатов на экран tвывода обычно составляет 0,5с.
Рассчитаем время реакции системы для случая обучения сети.
Размерность входного вектора 100, число нейронов 7, число итераций
обучения нейрона на всем задачнике 50, на одном примере – 1.
Время ввода параметров tввода=Lсимв ∙ tсимв=16·1,5 с=24 с.
Количество операторов для формирования обучающей выборки 4255.
Количество
операторов
для
обучения
одного
«нейрона»
149782.
Следовательно, общее количество операторов Nопер=4255+449346=453601.
Принимая среднее количество машинных команд, затрачиваемых на
выполнение одного оператора равным kмк=60, частоту процессора в герцах
равной f=1,4∙109, получим, согласно (1.6), tвычисления=
453601  60
 19,44  10 3 с.
9
1,4  10
Тогда по (1.9) tреакции=24 с + 19,44·10-3 с + 0,5 с=25 с, что соответствует
нормам времени для диалогового режима (до 30 с). В данном случае при
расчете времени реакции учитывалось время ввода всех параметров. При
инициализации системы уже введены оптимальные параметры, поэтому
время реакции системы может быть значительно сокращено до 0,5 с.
Рекомендуемая конфигурация комплекса технических средств:
- Программное обеспечение, необходимое для функционирования
программы: ОС MS Windows 98 или более новые версии.
- Тип компьютера и устройств, используемых при работе программы:
процессор AMD Athlon, INTEL Pentium-IV, Celeron, тактовая частота
процессора 1,4 ГГц и выше, ОЗУ 1 Гб и выше. Программа занимает
объем памяти на жестком диске, равный 786 Мб.
1.4.4 Минимальные требования к системе
На основе выполненных расчётов занимаемой памяти и исходя из
основного назначения программы, сделаем вывод о рекомендуемой
конфигурации комплекса технических средств:
 IBM – совместимый компьютер с тактовой частотой процессора 233
МГц и более;
 объем оперативной памяти не менее 1 Гб;
 жесткий диск не менее 1 Гб
 монитор с разрешением 800x600;
 видеокарта 512Mб с поддержкой 256 цветов;
 манипулятор мышь.
2
КОНСТРУКТОРСКО-ТЕХНОЛОГИЧЕСКАЯ ЧАСТЬ
2.1 ОБОСНОВАНИЕ АРХИТЕКТУРЫ СИСТЕМЫ
Автоматизированная система является приложением.
Приложение устанавливается на рабочие станции пользователей. С
помощью него производится обучение, хранение нейронной сети, а также
производится колоризация изображений с помощью обученных нейронных
сетей.
2.2 ВЫБОР И ОБОСНОВАНИЕ СРЕДСТВ РЕАЛИЗАЦИИ
2.2.1 Выбор языка программирования
Автоматизирования система колоризации монотонных полутоновых
изображений реализована с помощью языка Java 1.6.
Java
объектно-ориентированный
-
язык
программирования,
разработанный компанией Sun Microsystems. Приложения Java обычно
компилируются в специальный байт-код, поэтому они могут работать на
любой виртуальной Java-машине (JVM) независимо от компьютерной
архитектуры [1].
Достоинство подобного способа выполнения систем — в полной
независимости байт-кода от операционной системы и оборудования, что
позволяет выполнять Java-приложения на любом устройстве, для которого
существует
соответствующая
виртуальная
машина.
Другой
важной
особенностью технологии Java является гибкая система безопасности
благодаря тому, что исполнение системы полностью контролируется
виртуальной
машиной.
установленные
Любые
полномочия
операции,
программы
которые
превышают
(например,
попытка
несанкционированного доступа к данным или соединения с другим
компьютером) вызывают немедленное прерывание.
Кроме кроссплатформенности, Java имеет еще одно несомненное
достоинство:
ориентация
программирования.
Это
на
позволяет
объектно-ориентированный
наиболее
быстро,
подход
эффективно
и
качественно осуществить разработку системы, а также ее дальнейшую
поддержку [1].
Поэтому Java была выбрана в качестве языка для реализации
автоматизированной системы.
2.2.2 Выбор среды программирования
Реализация автоматизированной системы осуществляется в среде
Intellij Idea 10.
IntelliJ IDEA - интеллектуальная интегрированная среда разработки
Java,
сосредоточенная
на
производительности
разработчика,
которая
обеспечивает устойчивую комбинацию расширенных инструментальных
средств. Расширенная проектная навигация структуры кода упрощает анализ
даже больших файлов, обеспечивая удобный способ их просмотра. Поиск
распознает элементы языков, показывая результаты в интерактивной
навигационной панели, помогая проанализировать все найденные файлы [1].
Первая версия IntelliJ IDEA появилась в январе 2001 года и быстро
приобрела популярность, как первая Java IDE с широким набором
интегрированных инструментов для рефакторинга[1], которые позволяли
программистам быстро реорганизовывать исходные тексты программ.
Дизайн среды ориентирован на продуктивность работы программистов,
позволяя им сконцентрироваться на разработке функциональности, в то
время как IntelliJ IDEA берет на себя выполнение рутинных операций.
Начиная с шестой версии продукта IntelliJ IDEA предоставляет
интегрированный
инструментарий
для
разработки
графического
пользовательского интерфейса.
Начиная с версии 9.0, IntelliJ IDEA доступна в двух версиях:
Community Edition и Ultimate Edition. Community Edition является полностью
open-source версией, доступной под лицензией Apache 2.0. В ней реализована
полная поддержка Java SE, Groovy, Scala, а также интеграция с наиболее
популярными системами управления версиями. В версии Ultimate Edition
реализована поддержка Java EE, UML-диаграмм, подсчет покрытия кода, а
также
поддержка
других
систем
управления
версиями,
языков
и
фреймворков.
Таким образом, возможности
данной
среды
программирования
полностью соответствуют требованиям при разработке автоматизированной
системы (поддерживает язык Java, имеет полный набор инструментов для
создания интерфейса, написания и отладки кода).
2.2.3 Выбор операционной среды
В качестве языка программирования был выбран язык Java (п. 2.2.1),
который является кроссплатформенным. Таким образом, полученный
исполняемый файл .jar может быть запущен в любой операционной системе.
Единственным требованием является наличие установленной Java Machine
(JVM).
Разработка и отладка автоматизированной системы осуществляется в
MS Windows 7, т.к. это одна из самых распространенных и удобных
операционных систем, и на нее можно поставить JVM.
2.3 ОПИСАНИЕ ПРОГРАММНОЙ РЕАЛИЗАЦИИ
Автоматизированная система колоризации монотонного полутонового
изображения нейронной сетью включает в себя несколько подсистем
(рисунок 2.1):
 подсистему обучения нейронной сети;
 подсистему сегментации изображения;
 подсистему колоризации изображения нейронной сетью;
 подсистему отображения интерфейса.
В подсистеме отображения интерфейса участвуют все граничные
классы.
В подсистеме работы с нейронной сетью используется API класс
NeuralNetworkHelper.java.
В
подсистеме
колоризации
изображения
нейронной
используется класс NetworkWorker.java и ImageHelper.java
сетью
В
подсистеме
сегментации
изображения
используется
класс
ImageProxy.java и SegmentationEngine.java.
obj ect Subsystems
Автоматизированная система
колоризации полутоновых
изображений
Подсистема
отображения
интерфейса
Подсистема
сегментации
изображения
Подсистема работы с
нейронными сетями
Подсистема
обучения
нейронной сети
Подсистема
колоризации
изображения
Рисунок 2.1 – Структура автоматизированной системы
.
2.4 ОПИСАНИЕ ИНТЕРФЕЙСА
Интерфейс автоматизированной системы был разработан с учетом
функциональных требований. Используется диалоговый режим общения с
пользователем.
Пользователь может загружать полутоновые изображения,
колоризировать их и сохранять результат колоризации в файл (рисунок 2.6).
Далее эксперт может запустить обучение сети (Рисунок 2.5) и
редактировать список пользователей (рисунок 2.8).
2.5 ОПИСАНИЕ КОНТРОЛЬНОГО ПРИМЕРА
….
2.6 РАЗРАБОТКА МЕТОДИКИ ИСПЫТАНИЯ
Объектом
испытания
является
автоматизированная
«Колоризация монотонных полутоновых изображений».
система
Целью испытания является проверка работоспособности системы.
1. Проверка возможности запуска программы.
Действия:
1) Запустить Colorizator.jar
Результат:
1) На экране появится окно авторизации пользователя.
2. Проверка создания пользователя
Действие:
1) Запустить Colorizator.jar
2) Авторизоваться как Эксперт
3) Открыть форму эксперта
4) Выбрать действие «Редактировать справочник пользователей»
5) Добавить нового пользователя
6) Закрыть приложение
7) Запустить приложение
8) Авторизоваться под новым пользователем
Результат:
1) Авторизация пройдена успешно
3. Проверка создания новой сети
Действие:
1) Запустить Colorizator.jar
2) Авторизоваться как Эксперт
3) Открыть форму эксперта
4) Выбрать действие «Работать с нейронными сетями»
5) Задать параметры новой сети и добавить ее
6) Обучить сеть
7) Перейти в главное окно программы
8) Перейти в меню работы с изображением
9) Выбрать изображение
10)
Выполнить колоризацию с помощью новой сети
Результат:
1) Изображение должно колоризоваться
2.7 РУКОВОДСТВО ПОЛЬЗОВАТЕЛЯ
Данная система рассчитана на неквалифицированного пользователя.
Для того, чтобы авторизоваться, загрузить картинку, выбрать сеть из списка
сеть, нажать кнопку колоризации и сохранить изображение не требуется
никаких дополнительных знаний.
К эксперту прилагаются небольшие требования к знаниям
нейронных сетей, в частности к их обучению. Эксперту необходимо
понимать значение ошибки обучения, значение шага обучения и значение
момента обучения. При создании сети эксперт должен понимать, какую
лучше выбрать функцию активации и какое использовать число нейронов в
скрытом слое.
Полное
ПРИЛОЖЕНИЕ А.
руководство
пользователя
приведен
в
разделе
3
ЗАКЛЮЧЕНИЕ
В соответствии с требованиями дипломного проекта была разработана
автоматизированная
система
колоризации
монотонных
полутоновых
изображений. В ходе работы над дипломным проектом были изучены
методики обработки изображения, способы представления нейронной сети в
хранимой виде для возможности сохранения ее в базу данных. Были
проведены испытания на различных функциях активации нейронной сети и
различных параметрах обучения. Выявлено, что линейная и тангенсальная
функция активации показывает наилучший показатель обучения. Создана
информационно-логическая модель автоматизированной системы в нотации
UML с помощью инструментального средства Enterprise Architect 8.0. в ходе
работы были сформулированы требования к техническому обеспечению и
обоснован выбор средств автоматизации. Программное обеспечение системы
разработано в среде IDEA 10.0 на языке высокого уровня Java 1.6 под
управлением
ОС
Windows
7.
Программное
обеспечение
соответствует требованиям, описанным в техническом задании.
полностью
4
СПИСОК ИСПОЛЬЗОВАННЫХ ИСТОЧНИКОВ
1. Онлайн энциклопедия: www.wikipedia.org
2. Дерябкин В.П. Проектирование автоматизированных систем обработки
информации и управления. Курс лекций. СГАУ, 2011 г. – 120с.;
3. Хорстман К.С., Корнелл Г.Java 2 для профессионалов Том 2, 2009 г. – 586
с.;
4. СТО СГАУ 02068410-004-2007. Общие требования к оформлению
учебных текстовых документов: Методические указания. – Самара, 2007
5. СТП СГАУ 6.1.4. Общие требования к оформлению учебных текстовых
документов [Текст]. - Самара, Самарский аэрокосмический университет,
1997. - 16 с.
ПРИЛОЖЕНИЕ А
Руководство пользователя
МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ
РОССИЙСКОЙ ФЕДЕРАЦИИ
ФЕДЕРАЛЬНОЕ АГЕНТСТВО ПО ОБРАЗОВАНИЮ
ГОСУДАРСТВЕННОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ
ВЫСШЕГО ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ
«САМАРСКИЙ ГОСУДАРСТВЕННЫЙ АЭРОКОСМИЧЕСКИЙ
УНИВЕРСИТЕТ
им. АКАДЕМИКА С. П. КОРОЛЁВА
(научный исследовательский университет)»
УТВЕРЖДАЮ
Автоматизированная система
«Колоризация полутоновых монотонных изображений»
Руководство пользователя
ЛИСТ УТВЕРЖДЕНИЯ
А.В.00001-01 33 01-1-ЛУ
(вид носителя данных)
Листов
СОГЛАСОВАНО
РУКОВОДИТЕЛЬ РАЗРАБОТКИ
ИСПОЛНИТЕЛЬ
НОРМОКОНТРОЛЕР
Лёзина И.В.
Платонов А.П.
2012
УТВЕРЖДЕНО
А.В.00001-01 33 01-1-ЛУ
Автоматизированная система
«Колоризация полутоновых монотонных изображений»
Руководство пользователя
А.В.00001-01 33 01-1-ЛУ
(вид носителя данных)
Листов
2012
А.1 Введение
Автоматизированная система предназначена для колоризации чернобелых изображений. Пользователь должен войти в систему, авторизовавшись
под своим логином и паролем. После авторизации пользователь сможет
загружать черно-белые изображения, колоризировать их сохранять в файл.
А.2 Необходимые условия применения
Минимальные системные требования к техническому и программному
обеспечению:
 IBM – совместимый компьютер с тактовой частотой процессора 233
МГц и более;
 объем оперативной памяти не менее 1 Гб;
 жесткий диск не менее 1 Гб
 монитор с разрешением 800x600;
 видеокарта 512Mб с поддержкой 256 цветов;
 манипулятор мышь;
 Операционная система с поддержкой JVM.
А.3 Подготовка к работе
Для работы системы необходимо запустить модуль start.bat.
А.4 Описание операций
Чтобы приблизиться к теме сегментации изображений, описание
продолжим в терминологии пикселей изображения и их цвета. Допустим, мы
сегментируем попугайчика на фоне какого-нибудь Японского синего моря.
Сначала каждый пиксель (вершина графа) будет сам по себе – в собственном
сегменте (множестве), но в ходе алгоритма пиксели (вершины) «схожего»
цвета (одного объекта) постепенно объединяются в один сегмент.
Допустим,
на
определенном
шаге
алгоритма
попалось
ребро,
соединяющее два соседних пикселя: на одном конце ребра пиксель
«оранжевый», а на другом «красный». Длину ребра определим как «разницу
цвета» между пикселями. Все ребра меньшей длины (со схожим цветом) уже
объединены: наверняка уже выделен оранжевый и красный сегмент
попугайчика. Следуя алгоритму, нам нужно узнать, в одном ли сегменте
лежат текущие «оранжевый» и «красный» пиксель? Если в разных, и мы
считаем, что сегменты по цвету схожи, то объединяем их в один и
продолжаем построение… В общем, тот же алгоритм Краскала, только с
пикселями.
Используемая для этих операций структура – очень похожа на дерево
(хотя и реализуется массивом индексов). В ней для каждого пикселя указан
предок, т.е. указатель (индекс) на некоторый схожий по цвету пиксель,
находящийся в том же самом сегменте. Основные операции:
Поиск сегмента некоторого пикселя 'x': идем по предкам до самого
верха. Самый верхний пиксель – это корень дерева, «представитель» данного
сегмента на текущий момент.
Объединение сегментов. Если у пикселей разные «представители» —
значит, они принадлежат различным сегментам, иначе корень был бы один.
Для их объединения «представителя» сегмента меньшей высоты (от самого
далекого пикселя до корня) ссылаем (из него указываем) на более длинного
«представителя», чтобы не увеличивать высоту дерева. Теперь имеем
объединенный сегмент с общим представителем.
Для того, чтобы в следующий раз не бегать далеко от пикселя к корню,
после того, как «представитель» будет успешно обнаружен, устанавливаем
прямую ссылку из пикселя – сразу на него. Это сокращает путь следующих
поисков, и называется "path compression".
Рисунок 11 – Алгоритм Краскала
Отлично, теперь мы можем эффективно искать сегменты по пикселям и
объединять их, а так же выстраивать MST по алгоритму Краскала. Решение о
том, соединять области или нет принимается на основании введённых
пользователем коэффициентов.
Рисунок 12 – выбор параметров сегментирования
В разработанном приложении перед сегментацией изображения
пользователь задает следующие параметры: Функция сегментирования
(Лаплас или Гаусс), Коэффициент размытия (для функции Гаусса),
коэффициент
сегментирования
(на
основании
которого
принимается
решении о соединении двух графов), минимальный размер сегмента (в
пикселях).
После
этого
происходит
автоматическая
изображения на основе выбранных параметров (рисунок 13).
сегментация
Рисунок 13 – сегментированное изображение
Для
сегментированного
изображения
пользователь
выбирает
обученную нейросеть для каждого участка, с помощью которой будет
производиться колоризация выбранного участка изображения.
Обучение сетей производится так же пользователем:
Рисунок 14 – обучение нейросети
Пользователь выбирает алгоритм обучения для сети (параметры
которой, число нейронов в скрытом слое и функция активации, задал при ее
создании), задает параметры обучения сети согласно выбранному алгоритму,
выбирает изображения на которых собирается обучить сеть и производит ее
обучение. В ходе обучения пользователю предоставляется график ошибки
обучения:
Рисунок 15 – График ошибки обучения
ПРИЛОЖЕНИЕ Б
В качестве алгоритма сегментации изображения был реализован
алгоритм Efficient Graph-Based Image Segmentation авторов Pedro F.
Felzenszwalb (MIT) и Daniel P. Huttenlocher (Cornell University). Для
повышения производительности работы приложения было решено хранить
изображение в форме одномерного вектора:
public class Image {
private int w;
private int h;
public int[] data;
private BufferedImage cache;
public Image(BufferedImage image) {
w = image.getWidth();
h = image.getHeight();
data = new int[w * h]; // allocate space for image data
for (int i = 0; i < w * h; i++)
data[i] = image.getRGB(i % w, i / w);
}
public Image(int width, int height) {
w = width;
h = height;
data = new int[w * h]; // allocate space for image data
}
public int getIJ(int i, int j) {
return data[j * w + i];
}
public void setIJ(int i, int j, int val) {
data[j * w + i] = val;
}
//caching buffered image for more high speed work
public void resetCache() {
cache = null;
}
public BufferedImage toBufferedImage() {
if (null == cache) {
cache = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
for (int i = 0; i < w; i++) {
for (int j = 0; j < h; j++) {
cache.setRGB(i, j, getIJ(i, j));
}
}
}
return cache;
}
}
В качестве универсальной структуры работы с графами, позволяющей
быстро соединять несколько графов и пересчитывать минимальные веса для
решения «задачи Штейнера», была выбрана структура Disjoint-set data structure:
public class DisjointSet {
private int num;
private UniElt[] elts;
public DisjointSet(int elements) {
elts = new UniElt[elements];
for (int ii = 0; ii < elts.length; ii++)
elts[ii] = new UniElt();
num = elements;
for (int i = 0; i < elements; i++) {
elts[i].rank = 0;
elts[i].p = i;
elts[i].size = 1;
}
}
public int find(int x) {
int y = x;
while (y != elts[y].p)
y = elts[y].p;
elts[y].p = y;
return y;
}
public void join(int x, int y) {
if (elts[x].rank > elts[y].rank) {
elts[y].p = x;
elts[x].size += elts[y].size;
} else {
elts[x].p = y;
elts[y].size += elts[x].size;
if (elts[x].rank == elts[y].rank)
elts[y].rank++;
}
num--;
}
}
Для
реализации
понятия
«множество»
в
алгоритме
Краскала
применяется структура данных Disjoint-set data structure. Работа с ней
оптимизирована на выполнение двух основных операций:
Узнать для некоторой вершины, какому множеству в текущий момент
она принадлежит
Быстро объединить эти множества в одно