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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1.1.2 Шифр темы

Шифр темы — код 4217.2 067 988.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.

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 — Этапы выполнения работ

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 — Перечень модулей проекта

Коды перечисленных выше модулей приведены в пункте 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

#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

#include

#include

#define SIZETYPE long

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

export template

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 &);

#endif

};

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

template

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 &);

#endif

};

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

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

template

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;

templatedinmas:dinmas ()

{

siz=0;

}

templatedinmas:dinmas (SIZETYPE Size)

{

Beep (2500,100);

siz=0;

make (Size);

}

templatedinmas:~dinmas ()

{

clear ();

}

template bool dinmas: make (SIZETYPE Size)

{

if (siz>0) clear ();

siz=Size;

data=new type[siz];

return 1;

}

template void dinmas: clear ()

{

if (siz<=0) return;

delete[] data;

siz=0;

}

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

{

return data[i];

}

template int dinmas: bytes ()

{

return siz*sizeof (type);

}

template void dinmas: 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

{

buff1[i]=data[i];

}

buff2=new type[siz-position];

for (int i=0;i

{

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

}

siz++;

make (siz);

for (int i=0;i

{

data[i]=buff1[i];

}

data[position]=variable;

for (int i=0;i

{

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

}

delete[] buff1;

delete[] buff2;

}

template void dinmas: 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

{

buff1[i]=data[i];

}

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

for (int i=0;i

{

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

}

siz—;

make (siz);

for (int i=0;i

{

data[i]=buff1[i];

}

for (int i=0;i

{

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

}

delete[] buff1;

delete[] buff2;

}

template dinmas: push (type &variable)

{

insert (variable, 0);

}

template dinmas: pop ()

{

erase (0);

}

template type& dinmas: top ()

{

return data[0];

}

template bool dinmas: SaveToFile (AnsiString FileName)

{

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

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

for (int i=0;i

{

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

}

file.close ();

return 1;

}

template bool dinmas: LoadFromFile (AnsiString FileName)

{

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

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

make (siz);

for (int i=0;i

{

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

}

file.close ();

return 1;

}

template SIZETYPE& dinmas: size ()

{

return siz;

}

#ifndef NOCOPY

template dinmas: operator=(dinmas &object)

{

if (object.size ()>0)

{

make (object.size ());

for (int i=0;i

{

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

}

}

}

#endif

template dinmas2d: dinmas2d ()

{

exists=0;

n=m=0;

}

template dinmas2d: dinmas2d (SIZETYPE N, SIZETYPE M)

{

exists=0;

n=m=0;

make (N, M);

}

template dinmas2d:~dinmas2d ()

{

clear ();

}

template bool dinmas2d: 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

{

data[i]=new type[m];

}

exists=1;

return 1;

}

template void dinmas2d: clear ()

{

if (!exists) return;

for (int i=0;i

{

delete data[i];

}

delete[] data;

exists=0;

}

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

{

return data[i];

}

template int bytes ()

{

return n*m*sizeof (type);

}

#ifndef NOCOPY

template dinmas2d: operator=(dinmas2d &object)

{

if (object.exists)

{

make (object.n, object. m);

for (int i=0;i

{

for (int j=0;j

{

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

}

}

exists=1;

}

}

#endif

template smartcont: smartcont (int n)

{

_size=selected=0;

make (n);

}

template smartcont: smartcont ()

{

_size=selected=0;

make (0);

}

template smartcont: make (int n)

{

if (_size>0) clear ();

_size=n;

if (_size≠0)

{

graphs = new type*[n];

for (int i=0;i

{

graphs[i] = new type[1];

}

}

}

template int & smartcont: size ()

{

return _size;

}

template void smartcont: clear ()

{

if (_size<=0) return;

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

{

delete[] graphs[i];

}

delete[] graphs;

_size=0;

}

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

{

if (_size>0 && n<_size)

return *graphs[n];

else

MessageBox (NULL," Ошибка массива" ," Ошибка", MB_OK

}

template type& smartcont: operator ()()

{

if (_size>0 && selected<_size)

return *graphs[selected];

else

MessageBox (NULL," Ошибка массива" ," Ошибка", MB_OK

}

template smartcont:~smartcont ()

{

clear ();

}

template smartcont: insert (type &value)

{

insert ();

graphs[selected]=value;

}

template smartcont: 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

{

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 void smartcont: copy ()

{

insert ();

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

select (selected);

}

template void smartcont: erase (int n)

{

int buff=selected;

select (n);

erase ();

select (selected);

}

template void smartcont: 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

{

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 bool smartcont: select (int item)

{

if (_size==0) return 0;

selected=item;

return 1;

}

template int smartcont: SelectedItem ()

{

return selected;

}

template void smartcont: MoveUp ()

{

if (selected<1) return;

type* buff;

buff=graphs[selected-1];

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

graphs[selected]=buff;

selected—;

}

template void smartcont: 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

#include

#include

#include

#include

#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 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

}

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

{

int i=Row*RealWidth+Col;

if (i

}

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

{

int i=Row*RealWidth+Col;

if (i

{

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.*(RealWidthwidth)/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, '', 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

{

for (int col=0;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

{

for (int col=0;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

{

for (int col=0;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

#include

#include

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

#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 9 999 999 999

#define MIN -9 999 999 999

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

#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 tri; //набор треугольников для триангуляции

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

isoline line;

//методы

bool triangulation ();

public:

//поля

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

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

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

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

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

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

dinmas2d