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

/

Введение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 <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, ' ', 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; //освещение включено

bool rt; //режим отображения без пропусков

bool viewPoints; //отображать треки

bool net; //отображать сетку

bool counted; //сетка уже расчитана

bool isolines; //отображать изолинии

bool viewRelief; //отображать рельеф

bool visible; //отображать сетку

bool hideFar; //скрыть удалённые участки

//скрыть участки, выходящие за границу минимума и максимума

bool hideUpLimit;

bool needRecount; //требуется перерасчёт

bool difference; //является разницей между двумя батиметриями

bool blackAndWhite; //отображать в чёрнобелых тонах

bool slg; //является прочитанным slg-файлом

bool hasTide; //прилив вычтен

//методы

//Конструктор

bath();

//Чтение точек из ASCII-файла

bool LoadPoints(AnsiString, bool, bool);

//Чтение трека из slg-файла

bool LoadSlg(DoubleTable &, AnsiString);

//Очистить батиметрию

bool MakeEmpty(int);

//Расчёт прилива

void CountTide(cubic_spline &);

//Вычисление минимума и максимума

void ReCountMinMax();

//Вычисление только минимума

double ReCountMin();

//Расчёт батиметрической сетки

bool CountNet(int, point3D, point3D, double, double, double, double,

double, int, double, double, int, int, int, dinmas<double> *, bool);

//размытие

void blur(int);

//расчёт отклонения

void deviation();

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

inline __fastcall void CountColor(int &, int &);

//Перерасчёт цвета

void ReCountColor();

//Вычисление нормалей

inline __fastcall void CountNorm(int &, int &);

//Конструктор (в виде вызываемой функции)

void DefConstr();

//Вывод одного узла сетки на экран

void OneVertex(int &, int &);

//Вывод всей батиметрии

void view();

//Вывот треков

void ViewPoints();

//Линейная интерполяция

double cf(double &, double &, double &, bool);

//Создание одной изолинии

void makeLine(int &, int &);

//Отображение цифр-подписей

void ViewFigures(int);

//Расчёт одного слоя изолиний

void countOneIso(double);

//Расчёт всех изолиний

void countIso(double, dinmas<double> *, bool);

//Расчёт цифр-подписей

void CountFigures(int);

//Отображение изолиний

void viewIso();

//Удаление расчитанной батиметрической сетки

void EraseNet();

//Вычисление разницы между двумя батиметриями

bool GetDiffer(bath &, bath &, int, double, int);

//Вычисление

bool GetDifferPoints(bath &, double);

//Наложение текстуры

bool ReBindTexture();

//Сохранение сетки в ASCII-формате

bool SaveNet(AnsiString);

//Сохранение данных в формате.inf и.dat для программы ANI

bool SaveANI(AnsiString, double);

//Сохранение набора точек для отображения в прорамме Google Chrome

bool SavePointsGoogle(AnsiString);

//Сохранение трека для отображения в прорамме Google Chrome

bool SaveTrack(AnsiString);

//Сохранение набора точек в ASCII-формате в географических коордиантах

bool SavePoints(AnsiString);

//Сохранение набора точек в ASCII-формате в координатах меркатора

bool SavePointsMer(AnsiString);

//Сохранение батиметрической карты для отображения в прорамме Google Chrome

bool SaveNetGoogle(AnsiString, int);

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

void setConstantPreset(bath &);

//Полное копирование батиметрии из другой

operator=(bath &);

};

//Точка данных нивелирования

struct LevelPoint

{

double l; //расстояние от берега

double h; //высота над уровнем моря

//Координаты начальной точки

double x;

double y;

double z;

};

//Класс для работы с нивелированием

struct Levelling

{

dinmas<LevelPoint> levelPoint; //массив точек местности

};

#endif

3.4.2 Реализация chizu.cpp

#ifndef CHIZU_CPP

#define CHIZU_CPP

#include 'chizu.h'

using namespace std;

//Константы малентких чисел

#define SM 0.00000001

#define SM2 0.1

//Смещение изолинии вверх

#define UE 0.001

//Коэффициенты для раскрашивания шкалы

#define RC 4.3

#define GC 1.8

#define BC 1.2

#define RD 0.0

#define GD 0.0

#define BD 0.0

//Эпсилон отклонения

#define EPS 0.0001

AnsiString ReplaceComma(AnsiString str)

{

for(int i=1;i<=str.Length();i++)

{

if(str[i]==',')

str[i]='.';

}

return str;

}

AnsiString PointDouble(double x)

{

return AnsiString(x);

}

AnsiString DegToDegMin(double x)

{

int deg=floor(x);

double min=(x-deg)*60;

return AnsiString(deg)+'° '+PointDouble(min)+''';

}

AnsiString DegToCoord(double x)

{

int deg=floor(x);

int min=floor(fabs(x-deg)*60);

nt sec=floor(fabs((fabs(x-deg)*60)-min)*60);

int ms=floor(100*((fabs(fabs(fabs(x-deg)*60)-min)*60)-sec));

if(ms==99)

{

ms=0;

sec++;

if(sec==59 || sec==60)

{

sec=0;

min++;

if(min==59 || min==60)

{

min=0;

deg++;

}

}

}

if(min==0 && sec==0 && ms==0)

{

return AnsiString(deg)+':';

}

if(min!=0 && sec==0 && ms==0)

{

return AnsiString(deg)+':'+AnsiString(min)+''';

}

if(min!=0 && sec!=0 && ms==0)

{

return AnsiString(deg)+':'+

AnsiString(min)+'''+AnsiString(sec)+''';

}

return AnsiString(deg)+':'+AnsiString(min)+

'''+AnsiString(sec)+'''+AnsiString(ms);

}

AnsiString DegToDegMinI(double x, bool E)

{

int deg=floor(x);

int min=round((x-deg)*60);

return AnsiString(deg)+'° '+AnsiString(min)+'' '+((E)?'E':'N');

}

AnsiString DegToDegMinSecI(double x, bool E)

{

int deg=floor(x);

int min=floor((x-deg)*60);

int sec=floor((((x-deg)*60)-min)*60);

AnsiString secs=AnsiString(sec)+'' ';

return AnsiString(deg)+'° '+AnsiString(min)+

'' '+((sec!=0)?(secs):AnsiString(''))+((E)?'E':'N');

}

double DegMinSecToDouble(double deg, double min, double sec)

{

return deg+(min/60.)+(sec/3600.);

}

bool point3D::ataru(point3D &p)

{

return (fabs(p.x-x)<EPS) && (fabs(p.y-y)<EPS) && (fabs(p.z-z)<EPS);

}

bool InTriangle(point3D &a, point3D &b, point3D &c, point3D &p)

{

double pl1, pl2, pl3;

pl1 = (a.x - p.x)*(b.y - a.y)-(b.x - a.x)*(a.y - p.y);

pl2 = (b.x - p.x)*(c.y - b.y)-(c.x - b.x)*(b.y - p.y);

pl3 = (c.x - p.x)*(a.y - c.y)-(a.x - c.x)*(c.y - p.y);

if ((pl1 >= 0 && pl2 >= 0 && pl3 >= 0) ||

(pl1 <= 0 && pl2 <= 0 && pl3 <= 0))

{

return true;

}

return false;

}

bool CorrectTria(point3D &a, point3D &b, point3D &c, double max)

{

if (sqrt(sqr(a.x-b.x)+sqr(a.y-b.y))>max)

{

return 0;

}

else

{

if (sqrt(sqr(a.x-c.x)+sqr(a.y-c.y))>max)

{

return 0;

}

else

{

if (sqrt(sqr(b.x-c.x)+sqr(b.y-c.y))>max)

{

return 0;

}

else

{

return 1;

}

}

}

}

double countColor(double z, double A, double B,

unsigned __int8 color, bool difference, bool blackAndWhite)

{

if(!difference)

{

if(!blackAndWhite)

if(B<=A) return 0;

switch(color)

{

case COLOR_RED:

if(z<0)

return exp(-sqr((z)*(4.3/(-A))));

else

return exp(-sqr((z+B*(-1))*(2/(((1.6)*(B))))));

break;

case COLOR_GREEN:

if(z<0)

return exp(-sqr((z)*(1.8/(-A))));

else

return exp(-sqr((z+B*(-0.42))*(2/(((0.85)*(B))))));

break;

case COLOR_BLUE:

if(z<0)

return exp(-sqr((z)*(1.2/(-A))));

else

return exp(-sqr((z+B*(1.2))*(2/(((1.9)*(B))))));

break;

}

}

else

{

double ret=1-(z-A)/(B-A);

if(ret<0) return 0;

if(ret>1) return 1;

return ret;

}

}

else

{

if(!blackAndWhite)

{

switch(color)

{

case COLOR_RED:

return exp(-pow((z-A-(B-A)*2)*(2./(((3.3)*(B-A)))),10));

break;

case COLOR_GREEN:

return exp(-pow((z-A-(B-A)*0)*(2./(((5)*(B-A)))),4));

break;

case COLOR_BLUE:

return exp(-pow((z-A-(B-A)*(-2))*(2./(((3.5)*(B-A)))),8));

break;

}

}

else

{

double ret=z/((B-A)/8)+B;

if(ret<0) return 0;

if(ret>1) return 1;

return ret;

}

}

}

BathPoint::BathPoint()

{

t=0;

tide=0;

}

isoline::isoline(){};

void isoline::put(double &x1, double &y1, double &z1,

double &x2, double &y2, double &z2, bool &Zero)

{

a.x=x1;

a.y=y1;

a.z=z1;

b.x=x2;

b.y=y2;

b.z=z2;

zero=Zero;

}

void isoline::view(int &isolineSize)

{

if(zero)

{

glLineWidth(2*isolineSize);

glColor4d(0,0,0,1);

}

else

{

glLineWidth(1*isolineSize);

glColor4d(0,0,0,0.5);

}

glBegin(GL_LINES);

glVertex3d(a.x,a.y,a.z+UE);

glVertex3d(b.x,b.y,b.z+UE);

glEnd();

}

void figure::activate(double figh, double h)

{

if(length<figh)

{

x=line->a.x;

y=line->a.y;

z=line->a.z;

double r;

polar(line->b.x-line->a.x, line->b.y-line->a.y, r, angle);

angle=deg(angle);

exists=1;

AnsiString s=FormatFloat('0.00',h);

if(s[s.Length()]=='0')s=s.SubString(1,s.Length()-1);

if(s[s.Length()]=='0')s=s.SubString(1,s.Length()-2);

int i;

for(i=0;i<s.Length()&&i<8;i++)

{

str[i]=s[i+1];

}

strl=i;

}

else

{

exists=0;

}

}

void figure::view(int size)

{

glEnd();

if(!exists) return;

glEnable(GL_TEXTURE_2D);

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

glBindTexture(GL_TEXTURE_2D,0);

PutMaterial(1,1,1,0,0,0,0,0,0,0,120);

glColor3f(1,1,1);

double figsize=size*0.001875;

#define FIGCF 1.0

#define FIGDS 0.5

#define FIGSM 0.0005

double k=0;

glPushMatrix();

glTranslatef(x,y,z);

glRotatef(angle,0,0,1);

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

{

if(str[i]>='0' && str[i]<='9') k=str[i]-'0';

if(str[i]=='.' || str[i]==',') k=10;

if(str[i]=='-') k=11;

glBegin(GL_QUADS);

glTexCoord2f(k/16.0,0);

glVertex3d(-figsize*0.5+figsize*FIGDS*i,-figsize*0.5*FIGCF,i*FIGSM);

glTexCoord2f(k/16.0,1);

glVertex3d(-figsize*0.5+figsize*FIGDS*i,figsize*0.5*FIGCF,i*FIGSM);

glTexCoord2f((k+1)/16.0,1);

glVertex3d(figsize*0.5+figsize*FIGDS*i,figsize*0.5*FIGCF,i*FIGSM);

glTexCoord2f((k+1)/16.0,0);

glVertex3d(figsize*0.5+figsize*FIGDS*i,-figsize*0.5*FIGCF,i*FIGSM);

glEnd();

}

glDisable(GL_TEXTURE_2D);

glDisable(GL_BLEND);

glPopMatrix();

}

bool bath::triangulation()

{

ofstream file('input.txt');

if(!file.is_open()) return 0;

file<<'2 RBOX s 4 W0 c D2n';

file<<q.size()<<'n';

char buffer [50];

SetTitle('СОКО - сохранение точек');

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

{

sprintf(buffer, '%.19f %.19fn', q[i].m.x, q[i].m.y);

file<<buffer;

}

file.close();

SetTitle('СОКО - расчёт триангуляции');

system(AnsiString('qdelaunay TI input.txt s i Qt TO output.txt').c_str());

//ShowMessage('');

SetTitle('СОКО - чтение треугольников');

ifstream file2('output.txt');

//if(!file2.is_open()) return 0;

unsigned int n=0,x;

file2>>n;

tri.make(n);

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

{

file2>>x;

tri[i].a=x;

file2>>x;

tri[i].b=x;

file2>>x;

tri[i].c=x;

}

SetTitle('СОКО - треугольники прочитаны');

file2.close();

remove('input.txt');

remove('output.txt');

SetTitle('СОКО - временные файлы удалены');

return 1;

}

bath::bath()

{

DefConstr();

}

bool bath::LoadPoints(AnsiString FileName, bool merkator, bool minus)

{

DefConstr();

fstream file0(AnsiString(FileName+'.dat').c_str());

file0.close();

ifstream file(FileName.c_str());

char tmp[30];

double val;

int size=0;

if(!file.is_open()) return 0;

char name[32];

_splitpath(FileName.c_str(),NULL,NULL,name,NULL);

Filename=name;

SetTitle('СОКО - Чтение ASCII');

vector<double> buff;

while (!file.eof())

{

file>>val;

buff.push_back(val);

size++;

}

q.make(size/3);

file.close();

int i=0, coord=0;

for (int j=0;j<size-1;j++)

{

switch(coord)

{

case 0:

q[i].r.x=buff[j];

coord=1;

break;

case 1:

q[i].r.y=buff[j];

coord=2;

if(merkator) MerToGeo(q[i].r.x,q[i].r.y);

break;

case 2:

q[i].r.z=(-minus*2+1)*buff[j];

coord=0;

if(q[i].r.x<min.x) min.x=q[i].r.x;

if(q[i].r.x>max.x) max.x=q[i].r.x;

if(q[i].r.y<min.y) min.y=q[i].r.y;

if(q[i].r.y>max.y) max.y=q[i].r.y;

if(q[i].r.z<min.z) min.z=q[i].r.z;

if(q[i].r.z>max.z) max.z=q[i].r.z;

i++;

break;

}

}

SetTitle('СОКО');

return 1;

}

bool bath::LoadSlg(DoubleTable &table, AnsiString name)

{

#define FEET_TO_M 0.3048

int c=0,n=1,num;

double depth=0;

SetTitle('СОКО - Чтение slg');

for(int i=1;i<table.d.m;i++)

{

if(table.d[13][i]!=0) c++;

}

if(c>=table.d.m) return 0;

q.make(c);

c=0;

int i;

for(i=1;i<table.d.m;i++)

{

if(table.d[13][i]!=0)

{

if(c>0)

{

q[c-1].r.z=-(depth/n)*FEET_TO_M;

if(q[c-1].r.x<min.x) min.x=q[c-1].r.x;

if(q[c-1].r.x>max.x) max.x=q[c-1].r.x;

if(q[c-1].r.y<min.y) min.y=q[c-1].r.y;

if(q[c-1].r.y>max.y) max.y=q[c-1].r.y;

if(q[c-1].r.z<min.z) min.z=q[c-1].r.z;

if(q[c-1].r.z>max.z) max.z=q[c-1].r.z;

}

q[c].r.x=table.d[13][i];

q[c].r.y=table.d[14][i];

q[c].t=table.d[21][i];

MerToGeo(q[c].r.x,q[c].r.y);

depth=table.d[3][i];

n=1;

c++;

}

else

{

n++;

depth+=table.d[3][i];

}

}

q[c-1].r.z=-(depth/n)*FEET_TO_M;

if(q[c-1].r.x<min.x) min.x=q[c-1].r.x;

if(q[c-1].r.x>max.x) max.x=q[c-1].r.x;

if(q[c-1].r.y<min.y) min.y=q[c-1].r.y;

if(q[c-1].r.y>max.y) max.y=q[c-1].r.y;

if(q[c-1].r.z<min.z) min.z=q[c-1].r.z;

if(q[c-1].r.z>max.z) max.z=q[c-1].r.z;

Filename=name;

SetTitle('СОКО');

slg=1;

return 1;

}

bool bath::MakeEmpty(int length)

{

q.make(length);

return 1;

}

void bath::CountTide(cubic_spline &spl)

{

if(slg)

{

if((double)startDate==0.0) return;

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

{

if(hasTide)

q[i].tide=spl.f(startDate+q[i].t/86400000.0);

else

q[i].tide=0;

}

}

else

{

if((double)startDate==0.0 || (double)endDate==0.0) return;

TDateTime current;

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

{

if(hasTide)

q[i].tide=spl.f((double)startDate+((double)endDate-

(double)startDate)*(i/(double)q.size()));

else

q[i].tide=0;

}

}

}

void bath::ReCountMinMax()

{

min.x=MAX;

max.x=MIN;

min.y=MAX;

max.y=MIN;

min.z=MAX;

max.z=MIN;

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

{

if(q[i].r.x<min.x) min.x=q[i].r.x;

if(q[i].r.x>max.x) max.x=q[i].r.x;

if(q[i].r.y<min.y) min.y=q[i].r.y;

if(q[i].r.y>max.y) max.y=q[i].r.y;

if(q[i].r.z<min.z) min.z=q[i].r.z;

if(q[i].r.z>max.z) max.z=q[i].r.z;

}

needRecount=0;

}

double bath::ReCountMin()

{

double min=MAX;

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

{

if(q[i].r.z<min) min=q[i].r.z;

}

return min;

}

bool bath::CountNet(int TexNum, point3D Min, point3D Max, double Sclxy,

double Sclz, double Cfx, double Cfy, double D, int N, double rad,

double isoHABA, int maskBlurCount, int FigHaba, int IsolineSize,

dinmas<double> *Isolist, bool VarIso)

{

fighaba=FigHaba;

sclxy=Sclxy;

sclz=Sclz;

min=Min;

max=Max;

d=D;

texNum=TexNum;

isoHaba=isoHABA;

isolineSize=IsolineSize;

isolist=Isolist;

varIso=VarIso;

height=cfy*N;

width=cfx*N;

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

{

q[i].m.x=sclxy*(q[i].r.x-min.x-(max.x-min.x)/2);

q[i].m.y=sclxy*(q[i].r.y-min.y-(max.y-min.y)/2);

q[i].m.z=sclz*(q[i].r.z+q[i].tide*(hasTide)-min.z-(max.z-min.z)/2);

}

rmn.z=sclz*(min.z-min.z-(max.z-min.z)/2);

rmx.z=sclz*(max.z-min.z-(max.z-min.z)/2);

SetTitle('СОКО - триангуляция');

triangulation();

SetTitle('СОКО - триангуляция завершена');

counted=0;

if(!p.make(width,height)) return 0;

SetTitle('СОКО - создана сетка');

if(!blurBuff.make(width,height))

{

SetTitle('СОКО - не создана буферная сетка');

return 0;

}

else

{

SetTitle('СОКО - создана буферная сетка');

}

if(!MakeArray(height,width)) return 0;

SetTitle('СОКО - создана текстура');

double ls,hs,ls2,l,mn,lm;

if(max.y-min.y>max.x-min.x)

lm=SphereLenght(min.x, min.y, min.x, max.y);

else

lm=SphereLenght(min.x, min.y, max.x, min.y);

int km=0;

SetTitle('СОКО - обнуление сетки');

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

{

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

{

p[i][j].x=-cfx/2+d*i;

p[i][j].y=-cfy/2+d*j;

p[i][j].z=0;

p[i][j].b=p[i][j].z;

blurBuff[i][j]=p[i][j].z;

p[i][j].e=0;

}

}

int ia,ib,ja,jb;

double ta=0,tb=0,tc=1,td=0;

SetTitle('СОКО - расчёт треугольников');

for(int k=0;k<tri.size();k++)

{

ia=floor((MinFrom3(q[tri[k].a].m.x,

q[tri[k].b].m.x,q[tri[k].c].m.x)+cfx/2)/d);

ib=ceil((MaxFrom3(q[tri[k].a].m.x,

q[tri[k].b].m.x,q[tri[k].c].m.x)+cfx/2)/d);

ja=floor((MinFrom3(q[tri[k].a].m.y,

q[tri[k].b].m.y,q[tri[k].c].m.y)+cfy/2)/d);

jb=ceil((MaxFrom3(q[tri[k].a].m.y,

q[tri[k].b].m.y,q[tri[k].c].m.y)+cfy/2)/d);

if(ia<0 || ja<0 || ib>height || jb>width) continue;

if(!CorrectTria(q[tri[k].a].m,

q[tri[k].b].m,q[tri[k].c].m,rad/lm)) continue;

planeSet(

q[tri[k].a].m.x,q[tri[k].b].m.x,q[tri[k].c].m.x,

q[tri[k].a].m.y,q[tri[k].b].m.y,q[tri[k].c].m.y,

q[tri[k].a].m.z,q[tri[k].b].m.z,q[tri[k].c].m.z,

ta,tb,tc,td);

for(int j=ja;j<jb;j++)

{

for(int i=ia;i<ib;i++)

{

if(InTriangle(q[tri[k].a].m,

q[tri[k].b].m,q[tri[k].c].m,p[i][j])

&& tri[k].a>=0 && tri[k].a<q.size()

&& tri[k].b>=0 && tri[k].b<q.size()

&& tri[k].b>=0 && tri[k].c<q.size()

)

{

p[i][j].z=(-ta*p[i][j].x-tb*p[i][j].y-td)/tc;

p[i][j].b=p[i][j].z;

blurBuff[i][j]=p[i][j].z;

p[i][j].e=1;

}

}

}

}

if(maskBlurCount==0)

{

SetTitle('СОКО - расчёт цвета и нормалей');

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

{

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

{

if(p[i][j].e)

{

CountColor(i,j);

CountNorm(i,j);

}

}

}

}

else

{

blur(maskBlurCount);

}

exsist=1;

counted=1;

SetTitle('СОКО - наложение текстуры');

BindTexture(texNum,1,0);

if(maskBlurCount==0)

{

countIso(isoHaba,isolist,varIso);

deviation();

}

SetTitle('СОКО');

return 1;

}

void bath::blur(int times)

{

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

{

for(int j=1;j<width-1;j++)

{

for(int i=1;i<height-1;i++)

{

if(

p[i-1][j+1].e && p[i ][j+1].e && p[i+1][j+1].e &&

p[i-1][j ].e && p[i ][j ].e && p[i+1][j ].e &&

p[i-1][j-1].e && p[i ][j-1].e && p[i+1][j-1].e

)

{

blurBuff[i][j]=(

(0.0625)*p[i-1][j+1].z+(0.125)*

p[i ][j+1].z+(0.0625)*p[i+1][j+1].z+

(0.125 )*p[i-1][j ].z+(0.25 )*

p[i ][j ].z+(0.125 )*p[i+1][j ].z+

(0.0625)*p[i-1][j-1].z+(0.125)*

p[i ][j-1].z+(0.0625)*p[i+1][j-1].z

);

}

else

{

blurBuff[i][j]=p[i][j].z;

}

}

}

for(int j=1;j<width-1;j++)

{

for(int i=1;i<height-1;i++)

{

if(

p[i-1][j+1].e && p[i ][j+1].e && p[i+1][j+1].e &&

p[i-1][j ].e && p[i ][j ].e && p[i+1][j ].e &&

p[i-1][j-1].e && p[i ][j-1].e && p[i+1][j-1].e

)

{

p[i][j].z=blurBuff[i][j];

(

(0.0625)*blurBuff[i-1][j+1]+(0.125 )*

blurBuff[i ][j+1]+(0.0625)*blurBuff[i+1][j+1]+

(0.125 )*blurBuff[i-1][j ]+(0.25 )*

blurBuff[i ][j ]+(0.125 )*blurBuff[i+1][j ]+

(0.0625)*blurBuff[i-1][j-1]+(0.125 )*

blurBuff[i ][j-1]+(0.0625)*blurBuff[i+1][j-1]

);

}

else

{

p[i][j].z=blurBuff[i][j];

}

if(k==times-1)

{

CountColor(i,j);

CountNorm(i,j);

}

}

SetTitle('СОКО - размытие '+

AnsiString(FormatFloat(100*(double(k+1)/double(times)),2))+'%');

}

SetTitle('СОКО');

}

exsist=1;

BindTexture(texNum,1,0);

blurCount+=times;

countIso(isoHaba,isolist,varIso);

deviation();

SetTitle('СОКО');

}

void bath::deviation()

{

return;

SetTitle('СОКО - расчёт ошибки');

double sz=0, srz=0, z;

int nx,ny;

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

{

nx=floor((q[i].m.x+cfx/2)/d);

ny=floor((q[i].m.y+cfy/2)/d);

if(nx>=height-2 || ny>=width-2) continue;

if(!p[nx][ny].e || !p[nx][ny+1].e ||

!p[nx+1][ny+1].e || !p[nx+1][ny].e) continue;

z=bilinear(p[nx][ny].z,p[nx][ny+1].z,

p[nx+1][ny].z,p[nx+1][ny+1].z,p[nx][ny].x,

p[nx+1][ny].x,p[nx][ny].y,p[nx][ny+1].y,

q[i].m.x,q[i].m.y);

sz+=fabs(q[i].m.z);

srz+=fabs(z);

}

dev=100*fabs(sz-srz)/srz;

}

inline __fastcall void bath::CountColor(int &i, int &j)

{

tmpz=p[i][j].z/sclz+min.z+(max.z-min.z)/2;

if(difference)

{

imageData[i*RealWidth+j].r=

255*countColor(tmpz,-2,2,0,1,blackAndWhite);

imageData[i*RealWidth+j].g=

255*countColor(tmpz,-2,2,1,1,blackAndWhite);

imageData[i*RealWidth+j].b=

255*countColor(tmpz,-2,2,2,1,blackAndWhite);

}

else

{

imageData[i*RealWidth+j].r=

255*countColor(tmpz,min.z,max.z,0,0,blackAndWhite);

imageData[i*RealWidth+j].g=

255*countColor(tmpz,min.z,max.z,1,0,blackAndWhite);

imageData[i*RealWidth+j].b=

255*countColor(tmpz,min.z,max.z,2,0,blackAndWhite);

}

}

void bath::ReCountColor()

{

SetTitle('СОКО - расчёт цвета');

for(int j=1;j<width-1;j++)

{

for(int i=1;i<height-1;i++)

{

if(p[i][j].e) CountColor(i,j);

}

}

exsist=1;

SetTitle('СОКО - наложение текстуры');

BindTexture(texNum,1,0);

SetTitle('СОКО');

}

inline __fastcall void bath::CountNorm(int &i, int &j)

{

if(i>0 && j>0)

{

VecNormD(

p[i][j].x, p[i][j].y, p[i][j].z,

p[i][j-1].x, p[i][j-1].y, p[i][j-1].z,

p[i-1][j-1].x, p[i-1][j-1].y, p[i-1][j-1].z,

p[i][j].nx, p[i][j].ny, p[i][j].nz, 0) ;

}

}

void bath::DefConstr()

{

//rt=1;

width=1;

height=1;

counted=0;

tex=1;

viewPoints=1;

net=0;

//fb=0;

step=1;

PixelsQnt=0;

isolines=1;

dev=0;

//dif=0;

viewRelief=1;

min.x=MAX; max.x=MIN; min.y=MAX; max.y=MIN; min.z=MAX; max.z=MIN;

visible=1;

hideFar=1;

hideUpLimit=0;

needRecount=0;

difference=0;

blackAndWhite=0;

slg=0;

hasTide=1;

startDate=0;

endDate=0;

lighting=1;

}

void bath::OneVertex(int &i, int &j)

{

//glColor3d(1,1,1);

//material1.view(1,1,1,0,1,1,1,0,0,0,60);

if(tex)

{

glTexCoord2f(((1.*j/width))*wcoeff,((1.*i/height))*hcoeff);

}

else

{

k=i*RealWidth+j;

material_color[0]=imageData[k].r/255.0;

material_color[1]=imageData[k].g/255.0;

material_color[2]=imageData[k].b/255.0;

glColor3fv(material_color);

glMaterialfv(GL_FRONT_AND_BACK,

GL_AMBIENT_AND_DIFFUSE, material_color);

}

glNormal3d(p[i][j].nx,p[i][j].ny,p[i][j].nz);

glVertex3d(p[i][j].x,p[i][j].y,p[i][j].z);

}

void bath::view()

{

if(!counted) return;

if(viewRelief)

{

exsist=0;

if(tex)

{

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D,texNum);

PutMaterial(1,1,1,0,0,0,0,0,0,0,120);

}

int tc=0;

int stepBuff;

if(!rt)

{

stepBuff=step;

step=1;

}

glColor3d(1,1,1);

PutMaterial(1,1,1,0,0.5,0.5,0.5,0,0,0,60);

if(lighting) glEnable(GL_LIGHTING);

if(step<height && step<width)

{

for(int i=1;i<height-step;i+=step)

{

for(int j=1;j<width-step;j+=step)

{

if(

((hideFar && p[i][j].e && p[i][j+step].e &&

p[i+step][j+step].e && p[i+step][j].e) || !hideFar )

&&

((hideUpLimit && p[i][j].z<rmx.z && p[i][j].z>rmn.z) ||

!hideUpLimit || difference )

)

{

if(!net) glBegin(GL_QUADS); else glBegin(GL_LINE_LOOP);

OneVertex(i,j);

OneVertex(i,j+step);

OneVertex(i+step,j+step);

OneVertex(i+step,j);

glEnd();

}

}

}

}

if(lighting) glDisable(GL_LIGHTING);

glColor3d(0,0,0);

if(!rt)

{

step=stepBuff;

}

if(tex)

{

glDisable(GL_TEXTURE_2D);

}

}

if(isolines) viewIso();

}

void bath::ViewPoints()

{

if(viewPoints)

{

glPointSize(1);

glBegin(GL_POINTS);

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

{

glVertex3d(q[i].r.x,q[i].r.y,q[i].r.z+q[i].tide*(hasTide));

}

glEnd();

}

}

double bath::cf(double &s, double &e, double &f, bool revert)

{

return fabs((revert)-((f-s)/(e-s)));

}

void bath::makeLine(int &i, int &j)

{

if(

(p[i][j].z< f && p[i][j+1].z>=f && p[i+1][j+1].z>=f && p[i+1][j].z>=f)||

(p[i][j].z>=f && p[i][j+1].z< f && p[i+1][j+1].z< f && p[i+1][j].z< f))

{

line.put(p[i][j].x,p[i][j].y+d*cf(p[i][j].z,p[i][j+1].z,f,0),f

,p[i][j].x+d*cf(p[i][j].z,p[i+1][j].z,f,0),p[i][j].y,f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z>=f && p[i][j+1].z< f && p[i+1][j+1].z>=f && p[i+1][j].z>=f)||

(p[i][j].z< f && p[i][j+1].z>=f && p[i+1][j+1].z< f && p[i+1][j].z< f))

{

line.put(p[i][j].x,p[i][j].y+d*cf(p[i][j].z,p[i][j+1].z,f,0),f

,p[i][j].x+d*cf(p[i][j+1].z,p[i+1][j+1].z,f,0),p[i][j].y+d,f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z>=f && p[i][j+1].z>=f && p[i+1][j+1].z< f && p[i+1][j].z>=f)||

(p[i][j].z< f && p[i][j+1].z< f && p[i+1][j+1].z>=f && p[i+1][j].z< f))

{

line.put(p[i][j].x+d*cf(p[i+1][j+1].z,p[i][j+1].z,f,1),p[i][j].y+d,f

,p[i][j].x+d,p[i][j].y+d*cf(p[i+1][j+1].z,p[i+1][j].z,f,1),f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z>=f && p[i][j+1].z>=f && p[i+1][j+1].z>=f && p[i+1][j].z< f)||

(p[i][j].z< f && p[i][j+1].z< f && p[i+1][j+1].z< f && p[i+1][j].z>=f))

{

line.put(p[i][j].x+d*cf(p[i][j].z,p[i+1][j].z,f,0),p[i][j].y,f

,p[i][j].x+d,p[i][j].y+d*cf(p[i+1][j].z,p[i+1][j+1].z,f,0),f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z< f && p[i][j+1].z< f && p[i+1][j+1].z>=f && p[i+1][j].z>=f)||

(p[i][j].z>=f && p[i][j+1].z>=f && p[i+1][j+1].z< f && p[i+1][j].z< f))

{

line.put(p[i][j].x+d*cf(p[i][j].z,p[i+1][j].z,f,0),p[i][j].y,f

,p[i][j].x+d*cf(p[i][j+1].z,p[i+1][j+1].z,f,0),p[i][j].y+d,f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z< f && p[i][j+1].z>=f && p[i+1][j+1].z>=f && p[i+1][j].z< f)||

(p[i][j].z>=f && p[i][j+1].z< f && p[i+1][j+1].z< f && p[i+1][j].z>=f))

{

line.put(p[i][j].x,p[i][j].y+d*cf(p[i][j].z,p[i][j+1].z,f,0),f

,p[i][j].x+d,p[i][j].y+d*cf(p[i+1][j].z,p[i+1][j+1].z,f,0),f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

if(

(p[i][j].z>=f && p[i][j+1].z< f && p[i+1][j+1].z>=f && p[i+1][j].z< f)||

(p[i][j].z< f && p[i][j+1].z>=f && p[i+1][j+1].z< f && p[i+1][j].z>=f))

{

line.put(p[i][j].x,p[i][j].y+d*cf(p[i][j].z,p[i][j+1].z,f,0),f

,p[i][j].x+d*cf(p[i][j].z,p[i+1][j].z,f,0),p[i][j].y,f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

line.put(p[i][j].x+d*cf(p[i+1][j+1].z,p[i][j+1].z,f,1),p[i][j].y+d,f

,p[i][j].x+d,p[i][j].y+d*cf(p[i+1][j+1].z,p[i+1][j].z,f,1),f,zero);

iso.push_back(line);

//isom.insert(pair<pair<int,int>,isoline>(pair<int,int>(i,j),line));

return;

}

}

void bath::ViewFigures(int size)

{

//ViewValue('-125.4',0,0,0.05,270);

if(!figures.exists) return;

glBegin(GL_LINES);

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

{

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

{

figures[i][j].view(size);

}

}

glEnd();

}

void bath::countOneIso(double k)

f=sclz*(k-min.z-(max.z-min.z)/2);

for(int i=1;i<height-1;i++)

{

for(int j=1;j<width-1;j++)

{

if(

(p[i][j].e && p[i][j+1].e && p[i+1][j+1].e && p[i+1][j].e)

&&

((hideUpLimit && p[i][j].z<rmx.z && p[i][j].z>rmn.z)

|| !hideUpLimit)

)

makeLine(i,j);

}

}

}

void bath::countIso(double IsoHaba, dinmas<double> *Isolist, bool VarIso)

{

isoHaba=IsoHaba;

varIso=VarIso;

isolist=Isolist;

if(p.n==0) return;

double k;

iso.clear();

SetTitle('СОКО - расчёт изолиний');

zero=1;

if(!difference)

{

double min=ReCountMin();

if(varIso)

{

for(k=0;k>min;k-=isoHaba)

{

countOneIso(k);

zero=0;

}

for(k=isoHaba;k<max.z;k+=isoHaba)

{

countOneIso(k);

}

}

else

{

for(int i=0;i<isolist->size();i++)

{

zero=(isolist->operator [](i)==0);

countOneIso(isolist->operator [](i));

}

}

}

else

{

for(k=0;k>-4;k-=isoHaba)

{

countOneIso(k);

zero=0;

}

for(k=isoHaba;k<4;k+=isoHaba)

{

countOneIso(k);

}

}

CountFigures(fighaba);

}

void bath::CountFigures(int figh)

{

//return;

if(p.n==0 || iso.size()==0) return;

SetTitle('СОКО - расчёт цифр');

fighaba=figh;

figures.make(fighaba,fighaba);

double l;

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

{ //0.86602540378443864676372317075294

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

{

if(cfx<cfy)

{

figures[i][j].x=-cfx/2+(cfx*i/fighaba);

if(i%2!=0)

figures[i][j].y=-cfy/2+(cfy*j/fighaba);

else

figures[i][j].y=-cfy/2+0.5*cfy/fighaba+(cfy*j/fighaba);

}

else

{

figures[i][j].y=-cfy/2+(cfy*j/fighaba);

if(j%2!=0)

figures[i][j].x=-cfx/2+(cfx*i/fighaba);

else

figures[i][j].x=-cfx/2+0.5*cfx/fighaba+(cfx*i/fighaba);

}

figures[i][j].length=MAX;

for(int k=0;k<iso.size();k++)

{

l=sqrt(sqr(iso[k].a.x-figures[i][j].x)+

sqr(iso[k].a.y-figures[i][j].y));

if(l<figures[i][j].length)

{

figures[i][j].length=l;

figures[i][j].line=&iso[k];

}

}

figures[i][j].activate(

((cfx>cfy)?(cfy/fighaba):(cfx/fighaba))/2,-

(figures[i][j].line->a.z/sclz+min.z+

(max.z-min.z)/2)*(difference?-1:1));

}

}

SetTitle('СОКО');

}

void bath::viewIso()

{

//glEnable(GL_BLEND);

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

{

iso[i].view(isolineSize);

}

//glDisable(GL_BLEND);

}

void bath::EraseNet()

{

if(!counted) return;

counted=0;

}

bool bath::GetDiffer(bath &src, bath &dst,

int TexNum, double isoHABA, int DiffBlur)

{

SetTitle('СОКО - расчёт разницы');

//DefConstr();

setConstantPreset(src);

difference=1;

Filename=src.Filename+'-'+dst.Filename;

//dif=1;

sclxy=src.sclxy;

sclz=src.sclz;

cfx=src.cfx;

cfy=src.cfy;

min=src.min;

max=src.max;

rmn=src.rmn;

rmx=src.rmx;

diffBlur=DiffBlur;

d=src.d;

texNum=TexNum;

height=src.width;

width=src.height;

isoHaba=isoHABA;

counted=0;

p.make(width,height);

blurBuff.make(width,height);

MakeArray(height,width);

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

{

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

{

p[i][j].x=src.p[i][j].x;

p[i][j].y=src.p[i][j].y;

p[i][j].z=

sclz*(

((src.p[i][j].z/src.sclz+src.min.z+(src.max.z-src.min.z)/2)-

(dst.p[i][j].z/dst.sclz+dst.min.z+(dst.max.z-dst.min.z)/2))

-src.min.z-(src.max.z-src.min.z)/2);

p[i][j].b=p[i][j].z;

blurBuff[i][j]=p[i][j].z;

//p[i][j].s=(src.p[i][j].s+dst.p[i][j].s)/2.;

p[i][j].e=src.p[i][j].e&&dst.p[i][j].e;

if(diffBlur==0)

{

CountColor(i,j);

CountNorm(i,j);

}

}

}

exsist=1;

counted=1;

blur(diffBlur);

BindTexture(texNum,1,0);

countIso(isoHaba,isolist,varIso);

return 1;

bool bath::GetDifferPoints(bath &dst, double Range)

{

SetTitle('СОКО - расчёт разницы');

double rx=Range*(max.x-min.x)/SphereLenght(min.x, min.y, max.x, min.y);

double ry=Range*(max.y-min.y)/SphereLenght(min.x, min.y, min.x, max.y);

vector<BathPoint> q1;

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

{

for(int j=0;j<dst.q.size();j++)

{

if((fabs(q[i].r.x-dst.q[j].r.x)<=rx) &&

(fabs(q[i].r.y-dst.q[j].r.y)<=ry))

{

q1.push_back(q[i]);

goto kk;

}

}

kk:

if(i%1000==0)

SetTitle('СОКО - расчёт разницы для ''+Filename+'' '+

AnsiString(FormatFloat(100*(double(i+1)/double(q.size())),2))+'%');

}

q.make(q1.size());

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

{

q[i]=q1[i];

}

SetTitle('СОКО');

return 1;

}

bool bath::ReBindTexture()

{

if(counted) exsist=1;

return BindTexture(texNum,1,0);

}

bool bath::SaveNet(AnsiString FileName)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение сетки');

char buffer [10];

int n;

file<<'0 ';

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

{

sprintf(buffer, '%.13f', p[i][0].x/sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<' ';

}

file<<'n';

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

{

sprintf(buffer, '%.13f', p[0][j].y/sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<' ';

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

{

sprintf(buffer, '%.13f', p[i][j].z/sclz+min.z+(max.z-min.z)/2);

file<<buffer<<' ';

}

file<<'n';

}

file.close();

return 1;

}

bool bath::SaveANI(AnsiString FileName, double minutesStep)

{

SetTitle('СОКО - сохранение сетки');

FILE *pFile;

pFile=fopen(AnsiString(FileName.SubString(

1,FileName.Length()-4)+'.dat').c_str(), 'wb');

if(pFile==0) return 0;

float value;

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

{

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

{

if(p[i][j].e)

{

value=-p[i][j].z/sclz+min.z+(max.z-min.z)/2;

}

else

{

value=10001;

}

fwrite(&value, sizeof(float), 1, pFile);

}

}

fclose(pFile);

char buff[256];

char drive[3],direc[256],name[128],ext[8];

_splitpath(FileName.c_str(),drive,direc,name,ext);

ofstream file(FileName.c_str());

CharToOem(Filename.c_str(),buff);

file<<buff<<'n';

file<<'Created by SOKOn';

CharToOem(name,buff);

file<<buff<<'.datn4n2n';

file<<width<<' '<<height<<'n';

file<<'0 0 0 0n';

file<<ReplaceComma(FormatFloat('0.000000',min.z)).c_str()<<

' '<<ReplaceComma(FormatFloat('0.000000',max.z)).c_str()<<' mn';

file<<ReplaceComma(minutesStep).c_str()<<' '<<

ReplaceComma(minutesStep).c_str()<<' ' 0n';

file<<'0 '<<DegToCoord(min.y).c_str()<<' '<<DegToCoord(min.x).c_str();

file<<'n0n';

file.close();

return 1;

}

bool bath::SavePointsGoogle(AnsiString FileName)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение точек');

char buffer [20];

file<< AnsiString(

'<?xml version='1.0' encoding='UTF-8'?><kml xmlns='http://www.opengis.net/kml/2.2' xmlns:gx='http://www.google.com/kml/ext/2.2' xmlns:kml='http://www.opengis.net/kml/2.2' xmlns:atom='http://www.w3.org/2005/Atom'><Document><name>'+

Filename+'.kml</name>n'+

'<StyleMap id='msn_shaded_dot'><Pair><key>normal</key><styleUrl>#sn_shaded_dot</styleUrl></Pair><Pair><key>highlight</key><styleUrl>#sh_shaded_dot</styleUrl></Pair></StyleMap><Style id='sn_shaded_dot'><IconStyle><scale>0.2</scale><Icon><href>http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png</href></Icon></IconStyle><ListStyle></ListStyle></Style><Style id='sh_shaded_dot'><IconStyle><scale>0.236364</scale><Icon><href>http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png</href></Icon></IconStyle><ListStyle></ListStyle></Style>'+

'<Folder><name>'+Filename+'</name><open>1</open>n').c_str();

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

{

file<<'<Placemark><styleUrl>#msn_shaded_dot</styleUrl><Point><altitudeMode>relativeToGround</altitudeMode><coordinates>';

sprintf(buffer, '%.13f', q[i].r.x);

file<<buffer<<',';

sprintf(buffer, '%.13f', q[i].r.y);

file<<buffer<<',';

sprintf(buffer, '%.13f', q[i].r.z+q[i].tide*(hasTide));

file<<buffer<<'n';

file<<'n</coordinates></Point></Placemark>';

}

file<<'</Folder></Document></kml>';

file.close();

return 1;

}

bool bath::SaveTrack(AnsiString FileName)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение трека');

char buffer [20];

file<<'<?xml version='1.0' encoding='UTF-8'?>n<kml xmlns='http://www.opengis.net/kml/2.2' xmlns:gx='http://www.google.com/kml/ext/2.2' xmlns:kml='http://www.opengis.net/kml/2.2' xmlns:atom='http://www.w3.org/2005/Atom'>n<Document>n<name>';

file<<'track';

file<<'</name>n<Style id='sn_ylw-pushpin'>n<IconStyle>n<scale>n1.1</scale>n<Icon>n<href>http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png</href>n</Icon>n<hotSpot x='20' y='2' xunits='pixels' yunits='pixels'/>n</IconStyle>n</Style>n<StyleMap id='msn_ylw-pushpin'>n<Pair>n<key>normal</key>n<styleUrl>#sn_ylw-pushpin</styleUrl>n</Pair>n<Pair>n<key>highlight</key>n<styleUrl>#sh_ylw-pushpin</styleUrl>n</Pair>n</StyleMap>n<Style id='sh_ylw-pushpin'>n<IconStyle>n<scale>n1.3</scale>n<Icon>n<href>http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png</href>n</Icon>n<hotSpot x='20' y='2' xunits='pixels' yunits='pixels'/>n</IconStyle>n</Style>n<Placemark>n<name>';

file<<'track';

file<<'</name>n<styleUrl>#msn_ylw-pushpin</styleUrl>n<LineString>n<tessellate>1</tessellate>n<coordinates>n';

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

{

sprintf(buffer, '%.13f', q[i].r.x);

file<<buffer<<',';

sprintf(buffer, '%.13f', q[i].r.y);

file<<buffer<<',0 ';

}

file<<'</coordinates>n</LineString>n</Placemark>n</Document>n</kml>n';

file.close();

return 1;

}

bool bath::SavePoints(AnsiString FileName)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение точек');

char buffer [20];

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

{

sprintf(buffer, '%.13f', q[i].r.x);

file<<buffer<<' ';

sprintf(buffer, '%.13f', q[i].r.y);

file<<buffer<<' ';

sprintf(buffer, '%.13f', -q[i].r.z-q[i].tide*(hasTide));

file<<buffer<<'n';

}

file.close();

return 1;

}

bool bath::SavePointsMer(AnsiString FileName)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение точек');

char buffer [20];

double x,y;

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

{

x=q[i].r.x;

y=q[i].r.y;

GeoToMer(x,y);

sprintf(buffer, '%i', (int)x);

file<<buffer<<' ';

sprintf(buffer, '%i', (int)y);

file<<buffer<<' ';

sprintf(buffer, '%.13f', -q[i].r.z-q[i].tide*(hasTide));

file<<buffer<<'n';

}

file.close();

return 1;

}

bool bath::SaveNetGoogle(AnsiString FileName, int ScaleZ)

{

ofstream file(FileName.c_str());

if(!file.is_open()) return 0;

SetTitle('СОКО - сохранение сетки');

char buffer [20];

int k;

file<< AnsiString(

<?xml version='1.0' encoding='UTF-8'?><kml xmlns='http://www.opengis.net/kml/2.2'><Document><name>'+

Filename+'</name>n<Style id='line'><LineStyle><color>'+((viewRelief)?'4d000000':'ffffffff')+'</color><width>1</width></LineStyle><PolyStyle><color>'+((viewRelief)?'4d000000':'ffffffff')+'</color></PolyStyle></Style>n').c_str();

if(viewRelief)

{

for(int i=1;i<height-step;i+=step)

{

for(int j=1;j<width-step;j+=step)

{

if(

((hideFar && p[i][j].e && p[i][j+step].e &&

p[i+step][j+step].e && p[i+step][j].e) || !hideFar )

&&

((hideUpLimit && p[i][j].z<rmx.z && p[i][j].z>rmn.z &&

p[i+step][j+step].e && p[i+step][j].e) ||

!hideUpLimit || difference )

)

{

file<<'<Placemark><visibility>1</visibility><Style id='transBluePoly'><LineStyle><width>0</width></LineStyle><PolyStyle><color>n';

k=i*RealWidth+j;;

sprintf(buffer, 'ff%0*x%0*x%0*x',2,imageData[k].b,2,imageData[k].g,2,imageData[k].r);

file<<buffer<<'n';

file<<'</color></PolyStyle></Style><Polygon><altitudeMode>absolute</altitudeMode><outerBoundaryIs><LinearRing><coordinates>n';

sprintf(buffer, '%.13f',p[i][j].x/sclxy+

min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i][j].y/sclxy+

min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i][j].z/sclz+min.z+

(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i+step][j].x/sclxy+min.x+

(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i+step][j].y/sclxy+min.y+

(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i+step][j].z/sclz+min.z+

(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i+step][j+step].x/sclxy+min.x+

(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i+step][j+step].y/sclxy+min.y+

(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*

(p[i+step][j+step].z/sclz+min.z+(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i][j].x/sclxy+min.x+

(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i][j].y/sclxy+min.y+

(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i][j].z/sclz+min.z+

(max.z-min.z)/2-min.z));

file<<buffer<<'n';

file<<'</coordinates></LinearRing></outerBoundaryIs></Polygon></Placemark>n';

file<<'<Placemark><visibility>1</visibility><Style id='transBluePoly'><LineStyle><width>0</width></LineStyle><PolyStyle><color>n';

k=i*RealWidth+j;;

sprintf(buffer, 'ff%0*x%0*x%0*x',2,imageData[k].b,2,

imageData[k].g,2,imageData[k].r);

file<<buffer<<'n';

file<<'</color></PolyStyle></Style><Polygon><altitudeMode>absolute</altitudeMode><outerBoundaryIs><LinearRing><coordinates>n';

sprintf(buffer, '%.13f',p[i+step][j+step].x/

sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i+step][j+step].y/

sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i+step][j+step].z/

sclz+min.z+(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i][j+step].x/

sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i][j+step].y/

sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i][j+step].z/

sclz+min.z+(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i][j].x/

sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i][j].y/

sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i][j].z/

sclz+min.z+(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',p[i+step][j+step].x/

sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',p[i+step][j+step].y/

sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(p[i+step][j+step].z/

sclz+min.z+(max.z-min.z)/2-min.z));

file<<buffer<<'n';

file<<'</coordinates></LinearRing></outerBoundaryIs></Polygon></Placemark>n';

}

}

}

}

if(isolines)

{

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

{

file<<'<Placemark><name>Absolute</name><visibility>1</visibility><styleUrl>#line</styleUrl><LineString><tessellate>1</tessellate><altitudeMode>absolute</altitudeMode><coordinates>n';

sprintf(buffer, '%.13f',iso[i].a.x/sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',iso[i].a.y/sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(iso[i].a.z/sclz+min.z+

(max.z-min.z)/2-min.z));

file<<buffer<<'n';

sprintf(buffer, '%.13f',iso[i].b.x/sclxy+min.x+(max.x-min.x)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',iso[i].b.y/sclxy+min.y+(max.y-min.y)/2);

file<<buffer<<',';

sprintf(buffer, '%.13f',ScaleZ*(iso[i].b.z/sclz+min.z+

(max.z-min.z)/2-min.z));

file<<buffer<<'n';

file<<'</coordinates></LineString></Placemark>n';

}

}

file<<'</Document></kml>';

file.close();

return 1;

}

void bath::setConstantPreset(bath &src)

{

f=src.f;

zero=src.zero;

startDate=src.startDate;

endDate=src.startDate;

d=src.d;

sclxy=src.sclxy;

sclz=src.sclz;

cfx=src.cfx;

cfy=src.cfy;

dev=src.dev;

tmpz=src.tmpz;

isoHaba=src.isoHaba;

min=src.min;

max=src.max;

rmn=src.rmn;

rmx=src.rmx;

k=src.k;

blurCount=src.blurCount;

texNum=src.texNum+1;

Filename=src.Filename;

tex=src.tex;

step=src.step;

rt=src.rt;

viewPoints=src.viewPoints;

net=src.net;

counted=src.counted;

isolines=src.isolines;

viewRelief=src.viewRelief;

visible=src.visible;

hideFar=src.hideFar;

hideUpLimit=src.hideUpLimit;

needRecount=src.needRecount;

difference=src.difference;

blackAndWhite=src.blackAndWhite;

slg=src.slg;

hasTide=src.hasTide;

exsist=src.exsist;

binded=src.binded;

width=src.width;

height=src.height;

RealWidth=src.RealWidth;

RealHeight=src.RealHeight;

PixelsQnt=src.PixelsQnt,

hcoeff=src.hcoeff;

wcoeff=src.wcoeff;

ID=src.ID;

fighaba=src.fighaba;

isolineSize=src.isolineSize;

}

bath::operator=(bath &src)

{

setConstantPreset(src);

if(src.q.size()>0)

{

q.make(src.q.size());

for(int i=0;i<src.q.size();i++)

{

q[i]=src.q[i];

}

}

if(src.iso.size()>0)

{

for(int i=0;i<src.iso.size();i++)

{

iso.push_back(src.iso[i]);

}

}

if(src.imageData.size()>0)

{

imageData.make(src.imageData.size());

for(int i=0;i<src.imageData.size();i++)

{

imageData[i]=src.imageData[i];

}

}

if(src.p.n>0)

{

p.make(src.p.n,src.p.m);

blurBuff.make(src.p.n,src.p.m);

for(int i=0;i<src.p.n;i++)

{

for(int j=0;j<src.p.m;j++)

{

p[i][j]=src.p[i][j];

blurBuff[i][j]=src.blurBuff[i][j];

}

}

exsist=1;

BindTexture(texNum,1,0);

}

}

#endif

4. РУКОВОДСТВО ПРОГРАММИСТА

4.1 Руководство программиста для программы в целом

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

SOKO обеспечивает выполнение следующих основных функций:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Техническое обеспечение:

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

оперативная память 1024 Мб и более;

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

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

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

Программное обеспечение:

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

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

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

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

Microsoft Office Excel 2003 или выше;

распространяемый дистрибутив приложения с пакетом дополнительных консольных программ и исполняемым файлом программы «Soko.exe» (схема зависимостей компонентов приложения показана на рисунке 1.10 в приложении №1).

4.1.2 Характеристика программного обеспечения

Программа включает в себя 74 заголовочных файла языке программирования C++, 10 файлов реализации функций, и один файл формы soko_code.dfm, где дана спецификация графического интерфейса.

Графический интерфейс приложения создан в среде разработки приложений Borland C++ Builder на основе компонентов библиотек классов VCL и библиотеки Raize.

Приложение опирается на стандартную библиотеку классов C++, библиотеку VCL, предоставляемую фирмой Borland, библиотеку OpenGL, а также на несколько консольных приложений, необходимых для преобразования данных.

При разработке программного обеспечения в проекте используются модули стандартной библиотеки C++, библиотек VCL, Raize и OpenGL, перечисленные далее в таблицах 4.1-4.3.

Таблица 4.1 - Использованные в программе заголовочные файлы стандартной библиотеки

Таблица 4.2 - Использованные в программе классы стандартной библиотеки (выборочно)

Таблица 4.3 - Использованные в программе заголовочные файлы VCL

Таблица 4.4 - Использованные в программе классы VCL

Таблица 4.5 - Использованные в программе программе заголовочные файлы Raize

Таблица 4.6 - Использованные в программе программе заголовочные файлы Raize

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

Далее в таблице 4.4 представлены названия основных таких классов, а в таблицах 4.5 и 4.6 дано описание их структуры.

Также следует отметить, что каждый модуль реализован в виде одного или нескольких классов, реализующих функциональность, возложенную на данный модуль.

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

Таблица 4.8 - Структура point2d

Таблица 4.9 - Структура класса coltrol3d, потомок классов camera и cursor

Таблица 4.10 - Структура класса AverageLevel

Таблица 4.11 - Структура класса dinmas

Таблица 4.12 - Структура класса dinmas2d

Таблица 4.13 - Структура класса smartcont

Таблица 4.14 - Структура класса CamItem

Таблица 4.15 - Структура класса CameraSequence

Таблица 4.16 - Структура класса RGBpixel

Таблица 4.17 - Структура класса texture

Таблица 4.18 - Структура класса DoubleTable

Таблица 4.19 - Структура класса lamp

Таблица 4.20 - Структура класса BathPoint

Таблица 4.21 - Структура класса figure, потомок класса point3d

Таблица 4.22 - Структура класса glWindow

4.2 Характеристика и структура интерфейса проекта

Интерфейс приложения состоит из двух окон, не считая стандартных всплывающих диалоговых окон и окон сообщений. Окно настроек (по-умолчанию слева) содержит все средства управления программой, кроме настроек положения, угла поворота и масштаба камеры. Данное окно реализовано средствами VCL в среде C++ Builder при помощи стандартных компонентов VCL и (в большей степени) компонетов библиотеки Raize. Окно отображения выводит результаты работы на экран и представляет собой окно, реализованное средствами Windows API, связанной контекстом воспроизведения с OpenGL. Данное окно позволяет вращать и масштабировать сцену.

Модуль «soko_code.cpp» проекта приложения имеет принципиальное значение и реализует базисный функционал системы. В графическом интерфейсе системы данный модуль реализует главное окно настроек приложения.

4.2.1 Главное окно

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

Таблица 4.23 - Состав основных компонентов главного окна

4.2.2 Главное меню

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

Таблица 4.24 - Состав компонентов главного меню

4.2.3 Группа «границы»

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

Таблица 4.25 - Состав компонентов группы «границы» (выборочно)

С использованием группы «границы» могут быть выполнены следующие основные действия:

Автоматическое задание границ равномерной сетки

Корректировка границ на местности

Установка диапазона глубин

Корректировка масштабирования по высоте

Установка размера и шага батиметрической сетки

Установка названия участка местности для вычисления прилива

Управление внешним видом градусной или киломентровой сетки

4.2.4 Группа «рельеф»

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

Таблица 4.26 - Состав компонентов группы «рельеф» (выборочно)

4.2.5 Группа «свет и цвет»

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

Таблица 4.27 - Состав компонентов группы «свет и цвет» (выборочно)

4.2.6 Группа «изолинии»

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

Таблица 4.28 - Состав компонентов группы «изолинии» (выборочно)

4.2.7 Группа «цифры»

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

Таблица 4.29 - Состав компонентов группы «цифры» (выборочно)

4.2.8 Группа «общие настройки»

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

Таблица 4.30 - Состав компонентов группы «общие настройки» (выборочно)

4.2.9 Группа «правка трека»

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

Таблица 4.31 - Состав компонентов группы «правка трека» (выборочно)

4.2.10 Группа «прилив»

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

Таблица 4.32 - Состав компонентов группы «прилив» (выборочно)

4.2.11 Группа «расчёт»

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

Таблица 4.33 - Состав компонентов группы «расчёт» (выборочно)

4.2.12 Группа «разность»

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

Таблица 4.34 - Состав компонентов группы «разность» (выборочно)