Разработка информационной системы для деканата высшего учебного заведения

Размещено на http://www.allbest.ru/

Введение

Изучение особенностей рельефа морского дна является одной из важнейших задач морской геологии и геофизики, картографии и навигации. Батиметрия - изучение рельефа морского дна, получение данных о глубинах в зоне исследования. Также данный термин может использоваться как совокупность данных о глубинах водного объекта, результат батиметрической съёмки. Подстроение батиметрии применяется для решения множества задач:

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

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

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

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

Глобальное исследование глубин океанского дна позволяет сформировать полное представление о рельефе земли.

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

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

Импорт батиметрическиз данных из исходных треков, получаемых с картплоттера-эхолота, береговых линий из GPS-навигатора а также загрузка сторонних искусственно созданных данных.

Совмещение, компоновка и редактирование данных, исправление ошибок.

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

Построение и импорт батиметрических карт.

Построение карт сравнения динамики рельефа.

Экспорт данных в различные форматы.

Создаваемое программное обеспечение опирается на анализ предметной области по методике объектно-ориентированного подхода с использованием рационального унифицированного процесса, предложенного авторами языка UML - американской фирмой Rational [6]. На основе результатов анализа должен быть разработан проект программного обеспечения для компьютеризации перечисленных выше функций обработки батиметрических данных.

Итоговый требуемый результат выполнения работы программный косплекс для автоматизации обработки и визуализации батиметрических данных. Спецификация разделов работы дана в таблице 1.

Таблица 1 - Спецификация разделов работы

Обозначение	Наименование	Приме-чание
4217.02067988.09 - 2599 12	Текст программы
4217.02067988.09 - 2599 13	Описание программы
4217.02067988.09 - 2599 33	Руководство программиста
4217.02067988.09 - 2599 34	Руководство оператора
4217.02067988.09 - 2599 51	Программа и методика испытаний
4217.02067988.09 - 2599 90	Техническое задание
4217.02067988.09 - 2599 92	Организационно - экономическая часть

1. ТЕХНИЧЕСКОЕ ЗАДАНИЕ

1.1. Общие сведения

1.1.1 Полное наименование программного обеспечения и его условное обозначение

Полное наименование - Разработка программного косплекса обработки, визуализации и анализа батиметрических данных.

Условное обозначение - ПО «СОКО».

1.1.2 Шифр темы

Шифр темы - код 4217.02067988.09 - 2599, «Дипломная работа».

1.1.3 Сведения о разработчике и заказчике

Разработчик - студент группы ВТ-51 ГОУВПО «КнАГТУ» Филипп Андреевич Плеханов.

Заказчик - ИМГИГ ДВО РАН, лаборатория Волновой динамики и прибрежных течений, в лице заведующего лабораторией Петра Дмитриевича Ковалёва.

программа модуль сообщение эксплуатация

1.1.4 Перечень документов, на основании которых создается программное обеспечение

Перечень документов, на основании которых создается программное обеспечение:

задание на дипломное проектирование;

техническое задание;

календарный план-график выполнения этапов работы (см. п. 1.5 данного технического задания).

1.1.5 Плановые сроки начала и окончания работы по созданию программного обеспечения

Плановый срок начала работ: 20 февраля 2012 г.

Плановый срок окончания работ: 10 июня 2012 г.

1.1.6 Сведения об источниках и порядке финансирования работ

Данная работа выполняется в рамках дипломного проектирования, финансирование не производится.

1.1.7 Порядок оформления и предъявления заказчику результатов работы по созданию программного обеспечения

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

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

Работа осуществляется в соответствии с графиком (см. п. 1.5 данного технического задания). По окончании работ программное обеспечение тестируется и передается заказчику для эксплуатации.

Также заказчику передается комплект технической документации, оформленный в соответствии с ГОСТ 34.201 и ЕСПД.

1.2. Назначение и цели создания программного обеспечения

1.2.1 Назначение программного обеспечения

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

1.2.2 Цели создания программного обеспечения

Целями разрабатываемой системы являются:

Ускорение, упрощение и автоматизация чтения и подготовки исходных данных из различных форматов.

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

Быстрое построение батиметрической карты в процессе её съемки на основе имеющихся данных

Экспорт данных в различные графические, текстовые и двоичные форматы.

1.3. Характеристики предметной области

1.3.1 Краткие сведения о предметной области

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

Проектируемое программное обеспечение используется для автоматизации следующих объектов:

процесс подготовки батиметрических данных, выбора необходимых треков, исправления ошибок, сведения в единое целое;

процесс построения батиметрических карт в различных вариантах;

процесс получения результатов в графическом, анимированном, текстовом или бинарном формате;

Форматы выходных данных определяются стандартами фирм-производителей оборудования, такими как Garmin и Lowrance, а форматы исходных определяются стандартами на батиметрические карты, принятыми в РАН, а также форматами входных данных других программных комплексов, предназначенных для обработки батиметрических данных, таких как ANI. К основным данным предметной области относятся батиметрические треки, треки-пути, полученные с помощью GPS-навигатора, коэффициенты приливных гармоники и гармоник сезонных изменений уровня моря исследуемых областей.

Структура деятельности процессов обработки батиметрических данных изображена на диаграммах объектно-ориентированной модели данной предметной области, выполненных в нотации языка UML (см. приложение 1, рисунки 1.1-1.5) [2,6,9].

1.3.2 Сведения об условиях эксплуатации объекта автоматизации характеристик окружающей среды

Разрабатываемая система предназначена для использования на персональных IBM-совместимых компьютерах с центральным Intel-совместимом процессором с частотой работы не менее 1ГГц, оперативным запоминающим устройством объёмом не менее 512 Мб, свободным дисковым пространством не менее 25 Мб для хранения программного обеспечения и произвольным, но желательно не менее 500 мб объёмом для хранения промежуточных результатов работы. Обязательным условием является наличие манипулятора типа «мышь», SVGA-адаптера, совместимого со стандартом OpenGL, и монитора с разрешением не менее 1024х768 [7].

1.4. Требования к программному обеспечению

1.4.1 Требования к программному обеспечению в целом

Требования к структуре и функционированию программного обеспечения

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

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

К основным входным данным создаваемой системы можно отнести следующие:

батиметрические треки, получаемые посредством съёмки с помощью картплоттера-эхолота;

береговые треки, получаемые с помощью GPS-навигатора;

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

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

Выходными данными разрабатываемой системы являются:

батиметрические карты и карты разницы для выбранных участков в чёрно-белом и цветом варианте;

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

видео-файлы, представляющие собой съёмку трёхмерной батиметрической карты с различных ракурсов;

батиметрические треки и сетки, готовые для отображения в программе Google Earth;

батиметрические сетки в формате.inf для обработки в программном комплексе ANI.

Требования к численности и квалификации персонала

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

Требования к надежности

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

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

Требования к эргономике и технической эстетике

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

Требования к эксплуатации и техническому обслуживанию

Условия и режим эксплуатации ПО определяются условиями эксплуатации использующихся технических средств. Техническое обслуживание ПО не требуется.

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

Требования к защите информации от несанкционированного доступа

Защита информации от несанкционированного доступа не предусмотрена.

Требования по сохранности информации при авариях

Сохранность данных при авариях не гарантируется в случае непредвиденного прерывания работы программы.

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

Требования к защите от влияния внешних воздействий

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

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

Требования к стандартизации и унификации

ПО должно предоставлять пользователю стандартный графический интерфейс операционной системы Microsoft Windows. Сопутствующая программная документация, поставляемая с программным обеспечением, должна быть оформлена в соответствии со стандартом ЕСПД.

1.4.2 Требования к функциям, выполняемым системой

Разрабатываемое приложение должно обеспечивать выполнение следующих основных функций:

Импорт батиметрическиз данных из исходных треков, получаемых с картплоттера-эхолота, береговых линий из GPS-навигатора а также загрузка сторонних искусственно созданных данных.

Совмещение, компоновка и редактирование данных, исправление ошибок.

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

Построение и импорт батиметрических карт.

Построение карт сравнения динамики рельефа.

Экспорт данных в различные форматы.

1.4.3 Требования к видам обеспечения

Требования к математическому обеспечению

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

Требования к информационному обеспечению

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

Требования к лингвистическому обеспечению

Программное обеспечение и интерфейс пользователя в среде разработки приложений Borland C++ Builder 6 [11, 12]. В своей работе программное обеспечение не требует установки никаких сторонних библиотек, отсутствующих в стандарте Microsoft Windows.

Языком ввода-вывода данных, манипулирования данными, способа организации диалога с пользователем является русский язык.

Требования к программному обеспечению

Перечень программных средств, необходимых для проектирования и функционирования системы:

операционная система Microsoft Windows версии не ниже 98;

редактор диаграмм и блок-схем Microsoft Visio;

среда разработки приложений Borland C++ Builder 6;

Raize Components - набор визуальных компонентов для Delphi / C++Builder версии не ниже 4.3.2;

приложение для предвычисления приливов wxtide версии не ниже 4.7;

Требования к техническому обеспечению

Для создания данного программного обеспечения необходимы:

персональный компьютер совместимый с IBM PC с тактовой частотой процессора не ниже 1000 МГц, оперативная память 1024 Мб и более;

накопитель данных со свободным объёмом не менее 3 Гб;

видеокарта и монитор, поддерживающие разрешение 1024*768 точек и выше, с частотой обновления не менее 60 Гц, а также поддерживающие стандарт OpenGL;

устройства ввода клавиатура и манипулятор «мышь» (стандартные);

1.5 Состав и содержание работ по созданию программного обеспечения

Этапы выполнения работ по созданию «Регистрация компьютерной техники» приведены в таблице 1.1.

Таблица 1.1 - Этапы выполнения работ

Этап	Дата начала	Срок окончания
		Минимальный	Максимальный
Разработка и утверждение технического задания	09.02.12	18.02.12	23.02.12
Проектирование системы	21.02.12	11.03.12	14.03.12
Программная реализация	14.03.12	21.04.12	25.04.12
Оформление технической документации (Техническое задание)	25.04.12	02.05.12	03.05.12
Оформление технической документации (Описание программы)	03.05.12	07.05.12	08.05.12
Оформление технической документации (Теоретическое описание)	08.05.12	10.05.12	11.05.12
Оформление технической документации (Текст программы)	11.05.12	13.05.12	14.05.12
Оформление технической документации (Руководство программиста)	14.05.12	16.05.12	17.05.12
Оформление технической документации (Руководство пользователя)	17.05.12	21.05.12	22.05.12
Оформление технической документации (Программа и методика испытаний)	22.05.12	24.05.12	25.05.12
Оформление технической документации (Организационно-экономическая часть)	27.05.12	28.05.12	10.06.12

1.6 Порядок контроля и приемки программного обеспечения

При приёмке системы проводится её тестирование. Порядок и методики тестирования определяются в соответствии с ГОСТ 34.301-89. После завершения тестов и исправления недоработок система сдаётся в опытную эксплуатацию программы.

1.7 Требования к документации

Пояснительная записка оформляется в соответствии с ГОСТ 19.106-78 от 01.01.80 «Требования к программным документам, выполненным печатным способом», ГОСТ 19.101-77 от 01.01.80 «Виды программ и программных документов», ГОСТ 2.301-68 от 01.01.71 «Форматы ЕСКД», ЕСПД ГОСТ 19.001-77 от 1.01.80.

2. ОПИСАНИЕ ПРОГРАММЫ

2.1 Описание программы в целом

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

Модель предметной области, использованная для разработки программного обеспечения в нотации UML дана в приложении (см. приложение 1, рисунок 1.1 - 1.5). Схемы выполнения основных функций программы приведены в приложении 1 на рисунках 1.6 - 1.9.

Разработанный программный продукт называется «СОКО». Система функционирует в операционных системах Microsoft Windows любых версий, начиная с Windows 98.

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

Программное обеспечение создано в среде разработки приложений Borland C++ Builder 6 на языке программирования C++. Для исполнения двоичных модулей программного обеспечения не требуется установки дополнительных библиотек.

Главный исполняемый двоичный файл называется Soko.exe.

2.1.2 Функциональное назначение

Созданная система реализует следующие основные функции:

Импорт батиметрическиз данных из исходных треков, получаемых с картплоттера-эхолота;

Импорт береговых линий из GPS-навигатора;

Импорт данных, искусственно созданных с помощью приложения Google Maps;

Наглядное совмещение, компоновка и редактирование данных, исправление ошибок;

Подготовка данных к отображению и обработке: вычитание высоты прилива и сезонных колебаний уровня моря;

Выбор необходимого участка для расчёта посредством введения географических координат прямоугольника, либо в графическом режиме;

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

Построение и батиметрических карт;

Построение карт сравнения динамики рельефа;

Сохранение готовых карт в виде изображений любого размера;

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

Экспорт данных в различные форматы;

Сохранение текущего состояния системы для дальнейшей обработки.

2.1.3 Описание логической структуры

Программа включает в себя 74 файла кода на языке программирования C++ (модулей) и 35 форм рабочих окон и вспомогательных диалоговых окон.

Перечень модулей и их назначение указаны далее в таблице 2.1.

Таблица 2.1 - Перечень модулей проекта

Название модуля	Назначение модуля
soko.cpp	Входная точка программного приложения, содержит функцию main и запускает главный исполняемый поток.
soko_code.cpp soko_code.h soko_code.dfm	Основной модуль класса окна, сожержит основные методы, управляющие интерфейсом приложения и связывающие его с другими объектами. Также ссылки на остальные модули.
cursor.cpp cursor.h	Класс курсора. Сожержит методы получения координат курсора на экране, преобразования их в проекцию OpenGL и обратно.
camera.cpp camera.h	Класс камеры. Содержит методы упрощённого управления камерой в проекции OpenGL.
3dcontrol.cpp 3dcontrol.h	Класс управления сценой, наследник классов камеры и курсора, управлять просмотром трёхмерного изображения с помощью мыши: вращать, перемещать, масштабировать.
camerasequence.cpp camerasequence.h	Класс-массив камер, является наследником класса камеры, применяется для создания видеороликов.
chizu.cpp chizu.h	Основной класс для расчёта батиметрии. Содержит все функции обработки и анализа данных.
averagelevel.cpp averagelevel.h	Класс, применяемый для расчёта сезонных изменений уровня моря.
dinmas.cpp dinmas.h	Модуль, сожержащий различные варианты динамических массивов: одномерный, двумерный, трёхмерный, одномерный с двойной адресацией и древовидную структуру. Применяется как контейнер для большинства массивов проекта.
doubletable.cpp doubletable	Класс, позволяющий читать ascii-файл, представляющий собой таблицу из чисел, разделённых табуляцией и создающий на выходе двумерный массив. Применяется для чтения исходных данных.
geometry.cpp geometry.h	Модуль, содержащий функции, решающий некоторые геометрические задачи, связанные с триангуляцией.
glWindow.cpp glWindow.h	Класс API-окна, реализующего вывод OpenGL-графики.
lamp.cpp lamp.h	Класс, упрощяющий работу с освещением в OpenGL.
lotexture.cpp lotexture.h	Класс, предназначенный для чтения и записи файлов в формате TGA. Применяется как в качестве контейнера текстуры батиметрической карты, так и для сохранения изображений и видео.
material.cpp material.h	Класс, упрощающий работу с материалами в OpelGL.
mathadv.cpp mathadv.h	Модуль, содержащий некоторые дополнительные математические функции.
merkator.cpp merkator.h	Модуль, содержащий фунцции преобразования географических координат в координаты Меркатора и обратно.
point3d.cpp point3d.h	Класс, представляющий собой трёхмерную точку. Сожержит некоторые методы обработки.
rastrfont.cpp rastrfont.h	Класс, упрощающий работу с выводом текста в среде OpenGL.

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

2.1.4 Используемые технические средства

Техническое обеспечение для разработчика:

Персональный компьютер совместимый с IBM PC, тактовой частотой процессора не ниже 1000 МГц с объёмом оперативной памяти 1024 Мб и более, свободным дисковое пространством не менее 50 Мб, видеокартой и монитором, поддерживающие разрешение 1024х768 точек (или выше) и частотой обновления не менее 60 Гц, оборудованный стандартными устройствами ввода и вывода (клавиатура, мышь).

2.1.5 Используемые программные средства

Программное обеспечение для разработчика программной системы:

операционная система - Microsoft Windows 98 или более поздняя;

редактор диаграмм и блок-схем Microsoft Visio;

интегрированная среда разработки программных приложений Borland C++ Builder 6;

приложение для предрасчёта приливов wxtide версии 4,7 или выше;

консольное приложение для расчёта триангуляции qdelaunay из группы библиотек Qhull;

консольное приложение Slg2Txt для преобразования бинарных файлов формата slg в текстовый формат, предоставленной фирмой-производителем картплоттеров-эхолотов Lowrance;

консольное приложение tga2avi для преобразования последовательности изображений tga в видеоряд avi.

2.1.6 Вызов и загрузка

Вызов и загрузка программного обеспечения осуществляется запуском исполняемого файла soko.exe. Исполняемый файл должен находится в одной папке с представленными выше консольными приложениями.

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

Входными данными приложения являются:

1) батиметрические треки, получаемые посредством съёмки с помощью картплоттера-эхолота;

2) береговые треки, получаемые с помощью GPS-навигатора;

3) название региона и его координаты для определения уровня прилива и сезонных изменений уровня моря;

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

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

Выходными приложения являются:

1) батиметрические карты и карты разницы для выбранных участков в чёрно-белом и цветом варианте;

2) изображения трёхмерных срезов батиметрических данных, показанные с определённого ракурса;

3) видео-файлы, представляющие собой съёмку трёхмерной батимет-рической карты с различных ракурсов;

4) батиметрические треки и сетки, готовые для отображения в про-грамме Google Earth;

5) батиметрические сетки в формате.inf для обработки в программном комплексе ANI.

3. ТЕКСТ ПРОГРАММЫ

3.1 Модуль soko.cpp

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

Автор: Плеханов Ф. А.

Назначение: Входная точка программного приложения, содержит функцию WinMain

и запускает главный исполняемый поток.

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

#include <vcl.h>

#pragma hdrstop

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

USEFORM("soko_code.cpp", BathWin);

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

using namespace std;

//Аргументы командной строки

extern AnsiString args;

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR Args, int)

{

args=Args;

try

{

Application->Initialize();

Application->CreateForm(__classid(TBathWin), &BathWin);

Application->Run();

}

catch (Exception &exception)

{

Application->ShowException(&exception);

}

catch (...)

{

try

{

throw Exception("");

}

catch (Exception &exception)

{

Application->ShowException(&exception);

}

}

return 0;

}

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

3.2 Модуль dinmas.cpp (выборочно)

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

Автор: Плеханов Ф.А.

Назначение: Модуль контейнерных классов

Входные данные: размер контейнера

Выходные данные: готовый к использванию динамический массив

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

#ifndef DINMAS_CPP

#define DINMAS_CPP

#include <vcl>

#include <fstream>

#include <ComCtrls.hpp>

#define SIZETYPE long

//Обычный одномерный динамический массив

export template<typename type>

class dinmas

{

protected: public:

type* data;

public:

SIZETYPE siz;

dinmas();

dinmas(SIZETYPE);

~dinmas();

bool make(SIZETYPE);

void clear();

type& operator[](SIZETYPE);

int bytes();

void insert(type &, int);

void erase(int);

push(type &);

pop();

type& top();

bool SaveToFile(AnsiString);

bool LoadFromFile(AnsiString);

SIZETYPE& size();

#ifndef NOCOPY

operator=(dinmas<type> &);

#endif

};

//Обычный двумерный динамический массив

template<typename type>

class dinmas2d

{

public:

type** data;

SIZETYPE n,m;

bool exists;

dinmas2d();

dinmas2d(SIZETYPE, SIZETYPE);

~dinmas2d();

bool make(SIZETYPE, SIZETYPE);

void clear();

type* operator[](SIZETYPE);

int bytes();

#ifndef NOCOPY

operator=(dinmas2d<type> &);

#endif

};

//Одномерный динамический массив с двойной адресацией, может содержать в себе

//другие динамические массивы

template<typename type>

class smartcont

{

private:

type** graphs;

int _size;

int selected;

public:

smartcont(int);

smartcont();

make(int n);

int &size();

void clear();

type& operator[](int);

type& operator()();

~smartcont();

insert(type &value);

insert();

void copy();

void erase(int);

void erase();

bool select(int);

int SelectedItem();

void MoveUp();

void MoveDown();

};

using namespace std;

template<typename type>dinmas<type>::dinmas()

{

siz=0;

}

template<typename type>dinmas<type>::dinmas(SIZETYPE Size)

{

Beep(2500,100);

siz=0;

make(Size);

}

template<typename type>dinmas<type>::~dinmas()

{

clear();

}

template<typename type> bool dinmas<type>::make(SIZETYPE Size)

{

if(siz>0) clear();

siz=Size;

data=new type[siz];

return 1;

}

template<typename type> void dinmas<type>::clear()

{

if(siz<=0) return;

delete[] data;

siz=0;

}

template<typename type> type& dinmas<type>::operator[](SIZETYPE i)

{

return data[i];

}

template<typename type> int dinmas<type>::bytes()

{

return siz*sizeof(type);

}

template<typename type> void dinmas<type>::insert(type &variable, int position)

{

if(siz==0)

{

make(1);

data[0]=variable;

return;

}

if(position<0) position=0;

if(position>siz) position=siz;

type *buff1, *buff2;

buff1=new type[position];

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

{

buff1[i]=data[i];

}

buff2=new type[siz-position];

for(int i=0;i<siz-position;i++)

{

buff2[i]=data[position+i];

}

siz++;

make(siz);

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

{

data[i]=buff1[i];

}

data[position]=variable;

for(int i=0;i<siz-1-position;i++)

{

data[position+1+i]=buff2[i];

}

delete[] buff1;

delete[] buff2;

}

template<typename type> void dinmas<type>::erase(int position)

{

if(position<0) position=0;

if(position>siz-1) position=siz-1;

if(siz==0) return;

type *buff1, *buff2;

buff1=new type[position];

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

{

buff1[i]=data[i];

}

buff2=new type[siz-position-1];

for(int i=0;i<siz-position-1;i++)

{

buff2[i]=data[position+1+i];

}

siz--;

make(siz);

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

{

data[i]=buff1[i];

}

for(int i=0;i<siz-position;i++)

{

data[position+i]=buff2[i];

}

delete[] buff1;

delete[] buff2;

}

template<typename type> dinmas<type>::push(type &variable)

{

insert(variable, 0);

}

template<typename type> dinmas<type>::pop()

{

erase(0);

}

template<typename type> type& dinmas<type>::top()

{

return data[0];

}

template<typename type> bool dinmas<type>::SaveToFile(AnsiString FileName)

{

ofstream file(FileName.c_str(), ios::binary);

file.write((char*)&siz,sizeof(siz));

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

{

file.write((char*)&data[i],sizeof(type));

}

file.close();

return 1;

}

template<typename type> bool dinmas<type>::LoadFromFile(AnsiString FileName)

{

ifstream file(FileName.c_str(), ios::binary);

file.read((char*)&siz,sizeof(siz));

make(siz);

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

{

file.read((char*)&data[i],sizeof(type));

}

file.close();

return 1;

}

template<typename type> SIZETYPE& dinmas<type>::size()

{

return siz;

}

#ifndef NOCOPY

template<typename type> dinmas<type>::operator=(dinmas<type> &object)

{

if(object.size()>0)

{

make(object.size());

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

{

data[i]=object.data[i];

}

}

}

#endif

template<typename type> dinmas2d<type>::dinmas2d()

{

exists=0;

n=m=0;

}

template<typename type> dinmas2d<type>::dinmas2d(SIZETYPE N, SIZETYPE M)

{

exists=0;

n=m=0;

make(N,M);

}

template<typename type> dinmas2d<type>::~dinmas2d()

{

clear();

}

template<typename type> bool dinmas2d<type>::make(SIZETYPE N, SIZETYPE M)

{

if(N==0 || M==0) return 0;

clear();

n=N; m=M;

data=new type*[n];

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

{

data[i]=new type[m];

}

exists=1;

return 1;

}

template<typename type> void dinmas2d<type>::clear()

{

if(!exists) return;

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

{

delete data[i];

}

delete[] data;

exists=0;

}

template<typename type> type* dinmas2d<type>::operator[](SIZETYPE i)

{

return data[i];

}

template<typename type> int bytes()

{

return n*m*sizeof(type);

}

#ifndef NOCOPY

template<typename type> dinmas2d<type>::operator=(dinmas2d<type> &object)

{

if(object.exists)

{

make(object.n,object.m);

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

{

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

{

data[i][j]=object.data[i][j];

}

}

exists=1;

}

}

#endif

template<typename type> smartcont<type>::smartcont(int n)

{

_size=selected=0;

make(n);

}

template<typename type> smartcont<type>::smartcont()

{

_size=selected=0;

make(0);

}

template<typename type> smartcont<type>::make(int n)

{

if(_size>0) clear();

_size=n;

if(_size!=0)

{

graphs = new type*[n];

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

{

graphs[i] = new type[1];

}

}

}

template<typename type> int & smartcont<type>::size()

{

return _size;

}

template<typename type> void smartcont<type>::clear()

{

if(_size<=0) return;

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

{

delete[] graphs[i];

}

delete[] graphs;

_size=0;

}

template<typename type> type& smartcont<type>::operator[](int n)

{

if(_size>0 && n<_size)

return *graphs[n];

else

{

MessageBox(NULL,"Ошибка массива","Ошибка",MB_OK|MB_ICONERROR);

}

}

template<typename type> type& smartcont<type>::operator()()

{

if(_size>0 && selected<_size)

return *graphs[selected];

else

{

MessageBox(NULL,"Ошибка массива","Ошибка",MB_OK|MB_ICONERROR);

}

}

template<typename type> smartcont<type>::~smartcont()

{

clear();

}

template<typename type> smartcont<type>::insert(type &value)

{

insert();

graphs[selected]=value;

}

template<typename type> smartcont<type>::insert()

{

if(_size!=0)

{

selected++;

type** buff;

buff = new type*[_size];

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

{

buff[i]=graphs[i];

}

_size++;

graphs = new type*[_size];

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

{

graphs[i]=buff[i];

}

graphs[selected] = new type[1];

for(int i=selected+1;i<_size;i++)

{

graphs[i]=buff[i-1];

}

delete[] buff;

select(selected);

}

else

{

make(1);

selected=0;

select(selected);

}

}

template<typename type> void smartcont<type>::copy()

{

insert();

*graphs[selected]=*graphs[selected-1];

select(selected);

}

template<typename type> void smartcont<type>::erase(int n)

{

int buff=selected;

select(n);

erase();

select(selected);

}

template<typename type> void smartcont<type>::erase()

{

if(_size==0) return;

delete[] graphs[selected];

type** buff;

buff = new type*[_size];

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

{

buff[i]=graphs[i];

}

_size--;

graphs = new type*[_size];

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

{

graphs[i]=buff[i];

}

for(int i=selected;i<_size;i++)

{

graphs[i]=buff[i+1];

}

delete[] buff;

if(selected>0)

select(selected-1);

}

template<typename type> bool smartcont<type>::select(int item)

{

if(_size==0) return 0;

selected=item;

return 1;

}

template<typename type> int smartcont<type>::SelectedItem()

{

return selected;

}

template<typename type> void smartcont<type>::MoveUp()

{

if(selected<1) return;

type* buff;

buff=graphs[selected-1];

graphs[selected-1]=graphs[selected];

graphs[selected]=buff;

selected--;

}

template<typename type> void smartcont<type>::MoveDown()

{

if(selected>_size-1) return;

type* buff;

buff=graphs[selected+1];

graphs[selected+1]=graphs[selected];

graphs[selected]=buff;

selected++;

}

#endif

3.3 Модуль lotexture

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

Автор: Плеханов Ф.А.

Назначение: Класс для чтения файлов изображений в формате TGA и преобразования

в готовые для использования в среде OpenGL текстуры, также позволяет сохранять

изображения в формате TGA.

Входные данные: файл TGA, настройки чтения

Выходные данные: ID текстуры в OpenGL

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

3.3.1 Заголовочный файл lotexture.h

#ifndef LOTEXTURE_H

#define LOTEXTURE_H

#include <vcl.h>

#include <windowsx.h>

#include <winuser.h>

#include <gl>

#include <glu>

#include "mathadv.h"

#include "dinmas.cpp"

#define LT_IGNORE_ERROR 1

using namespace std;

#pragma pack (push, 1)

//Заголовок TGA-файла

struct TgaHeader

{

byte idLength;

byte colormapType;

byte imageType;

unsigned __int16 colormapIndex;

unsigned __int16 colormapLength;

byte colormapEntrySize;

unsigned __int16 xOrigin;

unsigned __int16 yOrigin;

unsigned __int16 width;

unsigned __int16 height;

byte pixelSize;

byte imageDesc;

};

#pragma pack (pop)

//Структуры точнек в формате TGA

struct RGBApixel

{

GLubyte r,g,b,a;

RGBApixel(GLubyte, GLubyte, GLubyte, GLubyte);

RGBApixel();

void GetPixel(GLubyte &, GLubyte &, GLubyte &, GLubyte &);

RGBApixel ToBGRA();

};

struct RGBpixel

{

GLubyte r,g,b;

RGBpixel(GLubyte, GLubyte, GLubyte);

GBpixel();

void GetPixel(GLubyte &, GLubyte &, GLubyte &);

RGBpixel ToBGR();

RGBApixel ToBGRA();

};

//Основной класс текстуры

class texture

{

protected:

bool exsist; //суествует

bool binded; //уже применяется

int width; //ширина

int height; //высота

int RealWidth; //ширина, приближённая к степени двойки

int RealHeight; //высота, приближённая к степени двойки

int PixelsQnt; //количество точек

int ID; //идентификационный номер текстуры в OpelGL

float hcoeff; //отношение height к RealHeight

float wcoeff; //отношение width к RealWidth

public:

//поля

dinmas<RGBApixel> imageData; //массив точек

//методы

//исправление целочисленного цвета,

//если он выходит из диапазона 0-255

GLubyte correct(float);

//копировать текстуру

void operator=(texture &);

//задать одну точку целыми числами

void SetPixel(int, int, GLubyte, GLubyte, GLubyte, GLubyte);

//задать одну точку числами с плавающей точкой

void SetPixelf(int, int, float, float, float, float);

//получить одну точку

void GetPixel(int, int, GLubyte &, GLubyte &, GLubyte &, GLubyte &);

texture(); //конструктор

//выделение памяти c проверкой на степень двойки

bool MakeArray(int, int);

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

bool MakeArraySimple(unsigned int, unsigned int);

//применение текстуры

bool BindTexture(unsigned int, bool, bool);

//сохранение в TGA

bool SaveToTGA(AnsiString);

//чтение из TGA

bool LoadFromTGA(AnsiString, unsigned int, bool, bool);

~texture(); //деструктор

void DeleteArray(); //очистить массив

void UnBind(); //отменить текстуру

//Методы получения величин

unsigned int GetWidth();

unsigned int GetHeight();

unsigned int GetRealWidth();

unsigned int GetRealHeight();

unsigned int GetPixelsQnt();

unsigned int GetID();

bool GetExsist();

bool GetBinded();

float GetWCoeff();

float GetHCoeff();

float GetWCoeffF();

float GetHCoeffF();

//Методы установки величин

void PutWidth(unsigned int);

void PutHeight(unsigned int);

void PutRealWidth(unsigned int);

void PutRealHeight(unsigned int);

void PutPixelsQnt(unsigned int);

void PutID(unsigned int);

void PutExsist(bool);

void PutBinded(bool);

void PutWCoeff(float);

void PutHCoeff(float);

};

#endif

3.3.2 Реализация lotexture.cpp

#ifndef LOTEXTURE_CPP

#define LOTEXTURE_CPP

#include "lotexture.h"

using namespace std;

RGBApixel::RGBApixel(GLubyte R, GLubyte G, GLubyte B, GLubyte A)

{

r=R; g=G; b=B; a=A;

}

RGBApixel::RGBApixel()

{

r=0; g=0; b=0; a=255;

}

void RGBApixel::GetPixel(GLubyte &R, GLubyte &G, GLubyte &B, GLubyte &A)

{

R=r; G=g; B=b; A=a;

}

RGBApixel RGBApixel::ToBGRA()

{

return RGBApixel(b,g,r,a);

}

RGBpixel::RGBpixel(GLubyte R, GLubyte G, GLubyte B)

{

r=R; g=G; b=B;

}

RGBpixel::RGBpixel()

{

r=0; g=0; b=0;

}

void RGBpixel::GetPixel(GLubyte &R, GLubyte &G, GLubyte &B)

{

R=r; G=g; B=b;

}

RGBpixel RGBpixel::ToBGR()

{

return RGBpixel(b,g,r);

}

RGBApixel RGBpixel::ToBGRA()

{

return RGBApixel(b,g,r,255);

}

GLubyte texture::correct(float x)

{

if(x<=0) return 0;

if(x>=1) return 255;

return floor(255*x);

}

void texture::operator=(texture &object)

{

exsist=object.exsist;

}

void texture::SetPixel(int Col, int Row, GLubyte r, GLubyte g, GLubyte b, GLubyte a)

{

int i=Row*RealWidth+Col;

if(i<PixelsQnt) imageData[i]=RGBApixel(r,g,b,a);

}

void texture::SetPixelf(int Col, int Row, float r, float g, float b, float a)

{

int i=Row*RealWidth+Col;

if(i<PixelsQnt) imageData[i]=RGBApixel(correct(r),correct(g),correct(b),correct(a));

}

void texture::GetPixel(int Col, int Row, GLubyte &r, GLubyte &g, GLubyte &b, GLubyte &a)

{

int i=Row*RealWidth+Col;

if(i<PixelsQnt)

{

imageData[i].GetPixel(r,g,b,a);

}

}

texture::texture()

{

exsist=0; binded=0;

}

bool texture::MakeArray(int w, int h)

{

if(w==0 || h==0) return 0;

width=w; height=h;

#ifdef LT_IGNORE_ERROR

{

RealWidth =NearestPow2(w);

RealHeight=NearestPow2(h);

wcoeff=1-1.*(RealWidth -width )/RealWidth ;

hcoeff=1-1.*(RealHeight-height)/RealHeight;

}

#else

{

RealWidth=width;

RealHeight=height;

hcoeff=wcoeff=1;

}

#endif

PixelsQnt=RealWidth*RealHeight;

if(imageData.make(PixelsQnt))

{

exsist=1;

return 1;

}

else

{

ShowMessage("Ошибка");

return 0;

}

}

bool texture::MakeArraySimple(unsigned int w, unsigned int h)

{

if(w==0 || h==0) return 0;

width=w; height=h;

RealWidth=width;

RealHeight=height;

hcoeff=wcoeff=1;

PixelsQnt=RealWidth*RealHeight;

if(imageData.make(PixelsQnt))

{

exsist=1;

return 1;

}

else

{

ShowMessage("Ошибка");

return 0;

}

}

bool texture::BindTexture(unsigned int TexID, bool Interpolation, bool Multiply)

{

if(!exsist) return 0;

ID=TexID;

glBindTexture(GL_TEXTURE_2D, TexID);

if (Interpolation)

{

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

}

else

{

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

}

if (Multiply)

{

glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_REPEAT);

glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_REPEAT);

}

else

{

glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_CLAMP);

glTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_CLAMP);

}

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, RealWidth, RealHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageData.data);

binded=1;

return 1;

}

bool texture::SaveToTGA(AnsiString fileName)

{

if(!exsist) return 0;

TgaHeader hdr;

memset ( &hdr, '\0', sizeof ( hdr ) );

hdr.imageType = 2; // unencoded image

hdr.width = width;

hdr.height = height;

hdr.pixelSize = 32;

FILE *pFile;

pFile=fopen(fileName.c_str(), "wb");

fwrite(&hdr, sizeof(hdr),1,pFile);

int WritedPxlQnt=width*height;

RGBApixel *temp = new RGBApixel[WritedPxlQnt];

int i=0;

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

{

for(int col=0;col<width;col++)

{

temp[i]=imageData[row*RealWidth+col].ToBGRA();

i++;

}

}

fwrite(temp, WritedPxlQnt*4, 1, pFile);

fclose(pFile);

free ( temp );

return 1;

}

bool texture::LoadFromTGA(AnsiString fileName, unsigned int TexID, bool Interpolation, bool Multiply)

{

TgaHeader hdr;

FILE *pFile;

pFile=fopen(fileName.c_str(), "rb");

if(pFile==NULL) return 0;

fread(&hdr, sizeof(hdr),1,pFile);

if(!(hdr.pixelSize==32 || hdr.pixelSize==24) || hdr.imageType!=2) return 0;

MakeArray(hdr.width,hdr.height);

int ReadPxlQnt=hdr.width*hdr.height;

if(hdr.pixelSize==32)

{

RGBApixel *temp = new RGBApixel[ReadPxlQnt];

fread(temp, ReadPxlQnt*4, 1, pFile);

int i=0;

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

{

for(int col=0;col<width;col++)

{

imageData[row*RealWidth+col]=temp[i].ToBGRA();

i++;

}

}

free(temp);

}

if(hdr.pixelSize==24)

{

RGBpixel *temp = new RGBpixel[ReadPxlQnt];

fread(temp, ReadPxlQnt*3, 1, pFile);

int i=0;

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

{

for(int col=0;col<width;col++)

{

imageData[row*RealWidth+col]=temp[i].ToBGRA();

i++;

}

}

free(temp);

}

fclose(pFile);

BindTexture(TexID,Interpolation,Multiply);

return 1;

}

texture::~texture()

{

DeleteArray();

}

void texture::DeleteArray()

{

if(!exsist) return;

imageData.clear();

exsist=0;

}

void texture::UnBind()

{

if(!binded) return;

glBindTexture(GL_TEXTURE_2D, ID);

char data[4]="1111";

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

binded=0;

}

unsigned int texture::GetWidth()

{

return width;

}

unsigned int texture::GetHeight()

{

return height;

}

unsigned int texture::GetRealWidth()

{

return RealWidth;

}

unsigned int texture::GetRealHeight()

{

return RealHeight;

}

unsigned int texture::GetPixelsQnt()

{

return PixelsQnt;

}

unsigned int texture::GetID()

{

return ID;

}

bool texture::GetExsist()

{

return exsist;

}

bool texture::GetBinded()

{

return binded;

}

float texture::GetWCoeff()

{

return wcoeff;

}

float texture::GetHCoeff()

{

return hcoeff;

}

float texture::GetWCoeffF()

{

return 1-1.*(RealWidth-width-2)/RealWidth;

}

float texture::GetHCoeffF()

{

return 1-1.*(RealHeight-height-2)/RealHeight;

}

void texture::PutWidth(unsigned int w)

{

width=w;

}

void texture::PutHeight(unsigned int h)

{

height=h;

}

void texture::PutRealWidth(unsigned int rw)

{

RealWidth=rw;

}

void texture::PutRealHeight(unsigned int rh)

{

RealHeight=rh;

}

void texture::PutPixelsQnt(unsigned int pq)

{

PixelsQnt=pq;

}

void texture::PutID(unsigned int id)

{

ID=id;

}

void texture::PutExsist(bool ex)

{

exsist=ex;

}

void texture::PutBinded(bool bd)

{

binded=bd;

}

void texture::PutWCoeff(float wc)

{

wcoeff=wc;

}

void texture::PutHCoeff(float hc)

{

hcoeff=hc;

}

#endif

3.4 Модуль chizu

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

Автор: Плеханов Ф.А.

Назначение: Класс батиметрии. Производит всю обработку батиметрических данных

и построение батиметрической сетки.

Входные данные: исходные треки, множество настроек, таких как частота изолиний

Выходные данные: трёхмерная батиметрическая карта с изолиниями и подписями

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

3.4.1 Заголовочный файл chizu.h

#ifndef CHIZU_H

#define CHIZU_H

#include <vector>

#include <map>

#include <list>

//Пользовательские модули

#include "merkator.h"

#include "doubletable.h"

#include "spline.h"

#include "lotexture.h"

#include "material.h"

#include "geometry.h"

#include "mathadv.h"

using namespace std;

//Константы максимума и минимума

#define MAX 9999999999

#define MIN -9999999999

//Цветовые константы

#define COLOR_RED 0

#define COLOR_GREEN 1

#define COLOR_BLUE 2

//Стандартизация исходных

AnsiString ReplaceComma(AnsiString);

//Получение строки из числа

AnsiString PointDouble(double);

//Получние строки с градусами и минутами из градусов с нецелой частью

AnsiString DegToDegMin(double);

//Получение строки с градусами,

//минутами и секундами из градусов с нецелой частью

AnsiString DegToCoord(double);

//Получение строки из градусов с нецелой частью, добавляет букву E или N

AnsiString DegToDegMinI(double, bool);

//Получние строки с градусами и минутами из градусов с нецелой частью,

//добавляет букву E или N

AnsiString DegToDegMinSecI(double, bool);

//Получение градусов с нецелой частью из градусов, минут и секунд

double DegMinSecToDouble(double, double, double);

//Установка заголовка окна, виртуальная функция, реализуемая

//в модуле, где расположено окно

void SetTitle(AnsiString msg);

//Функуция для тестирования

void Debag(AnsiString msg);

//Структура "трёхмерная точка"

struct point3D

{

double x,y,z; //координаты

bool ataru(point3D &); //проверка на совпадение с другой

};

//Структура "узел батиметрии", основанная на трёхмерной точке

struct vertex:point3D

{

double nx,ny,nz; //нормали

double b; //буфер для размытия

bool e; //существует ли

};

//Попадает ли трёхмерная точка в треугольник

bool InTriangle(point3D &, point3D &, point3D &, point3D &);

//Существует ли такой треугольник

bool CorrectTria(point3D &, point3D &, point3D &, double);

//Универсальная функция расчёта цвета по глубине

double countColor(double, double, double, unsigned __int8, bool, bool);

//Точка батиметрического трека

struct BathPoint

{

point3D r,m; //Точка в географических и нормализованных к 1 координатах

unsigned int t; //Сколько миллисекунд прошло с начала трека

double tide; //Высота прилива в данной точке

BathPoint(); //Конструктор

};

//Изолиния

struct isoline

{

point3D a,b; //начало и конец

bool zero; //не показывать

isoline(); //конструктор

void put(double &, double &, double &, //задать

double &, double &, double &, bool &);

void view(int &); //показать

};

//цифра-подпись

struct figure:public point3D

{

bool exists; //показывать

double length; //размер

isoline *line; //к какой изолинии привязана

char str[8]; //что отображать

int strl; //длина строки

double angle; //угол разворота

void activate(double, double); //"прилепить" к изолинии

void view(int); //показать

};

//Структура треугольника для триангуляции

struct OneTri

{

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

unsigned int a,b,c;

};

//основной класс батиметрии

class bath:public texture

{

private:

//поля

double f; //уровень для расчёта изолиний

bool zero; //являетмя ли уровень текущей изолинии нулевым

float material_color[4]; //массив цвета материала

dinmas<OneTri> tri; //набор треугольников для триангуляции

//буферная изолиния для работы функции расчёта изолиний

isoline line;

//методы

bool triangulation();

public:

//поля

dinmas<BathPoint> q; //батиметрический трек

dinmas2d<vertex> p; //батиметрическая сетка

dinmas2d<double> blurBuff; //буфферный массив для размытия

TDateTime startDate; //дата начала съёмки

TDateTime endDate; //дата конца съёмки

vector<isoline> iso; //вектор изолиний

dinmas2d<figure> figures; //массив цифр

dinmas<double> *isolist; //список уровней изолиний

double d; //шаг сетки

double sclxy; //коэффициент нормализации долготы и широты

double sclz; //коэффициент нормализации высоты

double cfx; //коэффициент нормализации долготы

double cfy; //коэффициент нормализации широты

//суммарное математическое отклонение данных от исходных в

//результате сглаживания и расчёта равномерной сетки

double dev;

double tmpz; //нормализованная высота для расчёта цвета

double isoHaba; //частота изолиний

double isolineSize; //толщина изолинии

point3D min; //минимум, нормализованный к 1

point3D max; //максимум, нормализованный к 1

point3D rmn; //минимум в географических координатах

point3D rmx; //максимум в географических координатах

//число строк в текстуре для доступа к ячейке одномерной

//текстуры по двум координатам

int k;

int blurCount; //количество проходов размытия

int texNum; //ID текстуры в среде OpenGL

int fighaba; //Расстояние между подписями

int diffBlur; //количество проходов размытия для сравнения батиметрий

int step; //пропуск кратных узлов сетки для ускорения отображения

AnsiString Filename; //имя файла

bool tex; //отображение текстуры средставми OpenGL

bool varIso; //переменный список изолиний

bool lighting; //освещение включено