/****** MAPAPI.H *************** Belenkov O.V.    ***** 12/06/17 ***

******* MAPAPI.H *************** Tarakanova I.R.  ***** 08/06/17 ***

******* MAPAPI.H *************** Kruzhkova E.A.   ***** 12/01/16 ***

******* MAPAPI.H *************** Dishlenko S.G.   ***** 21/04/14 ***

******* MAPAPI.H *************** Borzov A.U.      ***** 12/01/17 ***

******* MAPAPI.H *************** Derevyagina Zh.A.***** 21/06/16 ***

******* MAPAPI.H *************** Kruzhkov A.E.    ***** 30/11/16 ***

******* MAPAPI.H *************** Shabakov D.A.    ***** 09/06/17 ***

******* MAPAPI.H *************** Gheleznyakov V.A.***** 13/12/16***

******* MAPAPI.H *************** Shishkova L.A.   ***** 05/05/14 ***

******* MAPAPI.H *************** Osipov    D.A.   ***** 05/06/15 ***

******* MAPAPI.H *************** Letov V.I.       ***** 02/09/16 ***

******* MAPAPI.H *************** Vitsko. D.A.     ***** 08/09/16 ***

******* MAPAPI.H *************** Korjilov A.      ***** 25/11/16 ***

******* MAPAPI.H *************** Savelov A.S.     ***** 06/06/17 ***

*                                                                  *

*              Copyright (c) PANORAMA Group 1991-2017              *

*                      All Rights Reserved                         *

*                                                                  *

********************************************************************

*                                                                  *

*    ОПИСАНИЕ ИНТЕРФЕЙСА ДОСТУПА К ОБЪЕКТУ "ЭЛЕКТРОННАЯ КАРТА"     *

*                                                                  *

********************************************************************

*                                                                  *

*     Импортирование функций в MS Windows :                           *

*                                                                  *

*    // Загрузка библиотеки                                        *

*    HINSTANCE libInst = ::LoadLibrary("gisacces.dll");            *

*                                                                  *

*    // Вызов функции                                              *

*    HMAP (WINAPI * lpfn_OpenData)(const char*, long int);         *

*    (FARPROC)lpfn_OpenMap = GetProcAddress(libInst, "OpenData");  *

*    HMAP hMap = (*lpfn_OpenData)("Noginsk.map",0);                * *                                                                  *

*    // Выгрузка библиотеки                                        *

*    ::FreeLibrary(libInst);                                       *

*                                                                  *

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

 

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

********************  СИСТЕМЫ КООРДИНАТ ***************************

*******************************************************************

                                 

    Xд Xm

  ^

  | (0,0) (Начало изображени "Picture")

  +---------------------------------------------------> Xи

  |                                                 ^

  |        (Координаты окна "Client")               |

  |   (0,0)                      Xо                 |

  |     ----------------------->                    |

  |     |               |                           |

  |     |        x..... x  Окно визуализации        |

  |     |        ....A. |                           |

  |     |        ...+.. |                           |

  |     |        ...... |                         Габариты

  |     ---------x------x                    района ("Region")

  |     |          ^                                |

  |     |          |                                |

  |     |         Область текущего вывода           |

  |     V                  ("Draw")                 |

  |       Yо                                        |

  |                                                 V

  +----------------------------------------------------> Yд Ym

  |

  |  0,0 (Начало района "Map" в дискретах и метрах,

  |       дискрет м.б. равен метру)

  |

  V        координаты т.A в районе Xд,Yд; в изображении Xи,Yи

    Yи

 

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

 

//   Программное обеспечение, применяющее интерфейс "MAPAPI",

// может выполняться в различных операционных системах

// (Windows, Linux, QNX, OC - PB и т.д.).

//   Все строковые параметры API - функций имеют кодировку

// ANSI для Windows и KOИ - 8 для UNIX-подобных систем.

// Параметры типа HWND и HDC в Windows являются идентификаторами

// окна и графического контекста соответственно.

//   Для систем, применяющих графику X-Window,

// параметры HWND и HDC определены как long int (mapsyst.h),

// но содержат указатели на структуру типа XCONTEXT.

//  typedef struct XCONTEXT

//  {

//   Display     xcDisplay;  //  Связь с Х - сервером

//   Window      xcWindow;   //  Идентификатор окна

//   GC          xcContext;  //  Графический контекст окна

//   DRAWPOINT   xcPoint;    //  Расположение области вывода в окне :

//                           //  верхний, левый  угол в пикселах

// }

//   XCONTEXT;

 

 

#ifndef MAPAPI_H

#define MAPAPI_H

 

#if defined(__BORLANDC__)

#ifndef MAPVERSN_H

 #include "mapversn.h"

#endif

#endif

 

#ifndef MAPGDI_H

  #include "mapgdi.h"    // Параметры функций визуализации

#endif

 

#ifndef MAPTYPE_H

  #include "maptype.h"   // Описание структур интерфейса MAPAPI

#endif

 

#ifndef MAPCREAT_H

  #include "mapcreat.h"   // Описание структур данных для создания карты

#endif

 

// Версия библиотеки MapAccess

#define MAPACCESSVERSION  20170601

 

// Версия интерфейса MAPAPI и ядра библиотеки

#define MAPAPIVERSION  0x0120500

 

//enum PPLACE             // ПРИМЕНЯЕМАЯ СИСТЕМА КООРДИНАТ

//    {

//      PP_MAP     = 1,    // КООРДИНАТЫ ТОЧЕК В СИСТЕМЕ КАРТЫ В ДИСКРЕТАХ

//      PP_PICTURE = 2,    // КООРДИНАТЫ ТОЧЕК В СИСТЕМЕ ИЗОБРАЖЕНИЯ В ПИКСЕЛАХ

//      PP_PLANE   = 3,    // КООРДИНАТЫ ТОЧЕК В ПЛОСКОЙ ПРЯМОУГОЛЬНОЙ СИСТЕМЕ

//                         // НА МЕСТНОСТИ В МЕТРАХ

//      PP_GEO     = 4,    // КООРДИНАТЫ ТОЧЕК В ГЕОДЕЗИЧЕСКИХ КООРДИНАТАХ

//                         // В РАДИАНАХ

//    };

 

//enum VTYPE              // ТИП ОТОБРАЖЕНИЯ КАРТЫ

//    {

//      VT_SCREEN        = 1, // ЭКРАННЫЙ (ЧЕРЕЗ DIB)

//      VT_SCREENCONTOUR = 2, // ЭКРАННЫЙ КОНТУРНЫЙ

//      VT_PRINT         = 3, // ПРИНТЕРНЫЙ (ЧЕРЕЗ WIN API)

//      VT_PRINTGLASS    = 4, // ПРИНТЕРНЫЙ БЕЗ ЗАЛИВКИ ПОЛИГОНОВ

//      VT_PRINTCONTOUR  = 5, // ПРИНТЕРНЫЙ КОНТУРНЫЙ, БЕЗ УСЛОВНЫХ ЗНАКОВ

//      VT_PRINTRST      = 6, // ПРИНТЕРНЫЙ РАСТРИЗОВАННЫЙ (ЧЕРЕЗ WIN API) //    };

 

 

#ifndef SEEKAPI_H

  #include "seekapi.h"     // Описание методов поиска и отбора объектов карты

#endif

 

#ifndef SITAPI_H

  #include "sitapi.h"      // Описание методов доступа к обстановке

#endif

 

#ifndef MTRAPI_H

  #include "mtrapi.h"      // Описание методов доступа к матрицам

#endif

 

#ifndef RSTAPI_H

  #include "rstapi.h"      // Описание методов доступа к растрам

#endif

 

#ifndef RSCAPI_H

  #include "rscapi.h"      // Описание методов доступа к классификатору

#endif

 

 

 

 

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

// +++++ ОПИСАНИЕ ФУНКЦИЙ ДОСТУПА К ЭЛЕКТРОННОЙ КАРТЕ ++++++

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

 

#ifdef __cplusplus

extern "C"

{

#endif 

 

 

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

  *                                                        *

  *          ОТКРЫТЬ/ЗАКРЫТЬ ДОСТУП К ДАННЫМ КАРТЫ         *

  *                                                        *

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

 

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

  // (векторные,растровые,матричные...)

  // name - имя открываемого файла (MAP, SIT, MTW, RSW, MPT) в кодировке UNICODE

  // mode - режим чтения/записи (GENERIC_READ, GENERIC_WRITE или 0)

  // GENERIC_READ - все данные только на чтение, при этом не открываются

  // файлы \Log\name.log и \Log\name.tac - протокол работы и журнал транзакций

  // error - после выполнения функции переменная содержит код ошибки

  //        (когда HMAP равен 0) или 0; коды ошибок приведены в maperr.rh 

  // password - пароль доступа к данным из которого формируется 256-битный код

  //            для шифрования данных (при утрате пароля данные не восстанавливаются)

  // size     - длина пароля в байтах !!!

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

  // Если пароль не передан, а он был указан при создании,

  // то автоматически вызывается диалог scnGetMapPassword из mapscena.dll (gisdlgs.dll)

  // Если выдача сообщений запрещена (mapIsMessageEnable()), то диалог

  // не вызывается, а при отсутствии пароля происходит отказ открытия данных

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapOpenAnyDataPro(const WCHAR *name, long int mode, 

                                       long int *error,

                                       const WCHAR *password, long int size);

 

_MAPIMP HMAP _MAPAPI mapOpenAnyData(const WCHAR *name, long int mode = 0,

                                    long int *error = 0);

 

_MAPIMP HMAP _MAPAPI mapOpenDataUn(const WCHAR *name, long int mode = 0);

 

  // Открыть векторные данные (аналогично mapOpenData)

  // Возвращает идентификатор открытой векторной карты

  // mapname - имя файла карты MAP(многолистовая), SIT (пользовательская),

  // SITX (хранилище данных с поддержкой шифрования данных)

  // mode - режим чтения/записи (GENERIC_READ, GENERIC_WRITE, или 0)

  // GENERIC_READ - все данные только на чтение, при этом не открываются

  // файлы \Log\name.log и \Log\name.tac - протокол работы и журнал транзакций

  // password - пароль доступа к данным из которого формируется 256-битный код

  //            для шифрования данных (при утрате данные не восстанавливаются)

  // size     - длина пароля в байтах !!!

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

  // Если пароль не передан, а он был указан при создании,

  // то автоматически вызывается диалог scnGetMapPassword из mapscena.dll (gisdlgs.dll)

  // Если выдача сообщений запрещена (mapIsMessageEnable()), то диалог

  // не вызывается, а при отсутствии пароля происходит отказ открытия данных

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapOpenMapPro(const WCHAR *name,long int mode,    

                                   const WCHAR *password, long int size);

_MAPIMP HMAP _MAPAPI mapOpenMapUn(const WCHAR *mapname, long int mode = 0);

 

  // Запросить является ли идентификатор данных корректным           // 28/02/14

  // hMap -  идентификатор открытых данных

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsMapHandleCorrect(HMAP hMap);

 

  // Запрос/установка разрешения выполнять структурный контроль карты

  // после сбоев программы

  // flag - нулевое значение запрещает выполнение контроля структуры

  //        при открытии карты, ненулевое - разрешает

  // Возвращает старое значение флага

 

  long int _MAPAPI mapSetStructureControlFlag(long int flag);

 

  // Установка запрета/разрешения использовать потоки внутри данной библиотеки

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

  // работающей в многопоточных приложениях, внутренние потоки понижают

  // общую производительность (Например, внутренняя реализация функции

  // отображения растра запускает до 8 потоков. Если функция отображения

  // вызвана параллельно 10 потоками, одномоментно будет работать 90 потоков).

  // Внутреннее число потоков не превышает число ядер процессора, включая

  // виртуальные ядра.

  // Возвращает старое значение состояния разрешения внутренних потоков

 

 _MAPIMP long int _MAPAPI mapUseInsideThread(long int state);         // 25/01/17

 

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

  // hMap -  идентификатор открытых данных

  // mode - режим добавления данных (1 - ускоренный, 0 - стандартный)

  // При ускоренном режиме не пересчитываются габариты документа по

  // всем открытым данным и не обновляется палитра, что существенно

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

  // По окончанию добавления данных рекомендуется вернуть режим добавления

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

  // Габариты обновляются автоматически и при масштабировании документа,

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

  // цветов

  // После вызова mapOpenProject или mapAppendProject автоматически устанавливает

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

  // Возвращает текущее значение режима

 

_MAPIMP long int _MAPAPI mapSetAppendDataMode(HMAP hMap, long int mode);

 

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

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

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

  // hMap  -  идентификатор открытых данных

  // hSite -  идентификатор открытой пользовательской карты

  // state -  режим потоковой загрузки данных (1 - включен, 0 - выключен)

  // В режиме потоковой загрузки данных отключается журналирование операций

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetLoadState(HMAP hMap, HSITE hSite, long int state);

_MAPIMP long int _MAPAPI mapGetLoadState(HMAP hMap, HSITE hSite);

 

  // Добавить данные к открытой карте (карту, растр, матрицу)

  // hMap -  идентификатор открытых данных 

  // name - имя открываемого файла (SIT, MTW, MTQ, RSW, MPT)

  // mode - режим чтения/записи (GENERIC_READ, GENERIC_WRITE или 0)

  // Возвращает идентификатор типа данных (FILE_MAP - для пользовательской

  // карты, FILE_RSW - для растра, FILE_MTW - для матрицы, FILE_MTL - для

  // матрицы слоев, FILE_MTQ - для матрицы качеств), данные добавляются в

  // список последними, если данные уже были открыты, число открытых данных

  // (карт, растров, матриц) не меняется

  // transform - признак трансформирования пользовательской карты

  //             к ранее открытым данным (если проекции разные):

  //             0 - не трансформировать данные (преобразовывать "на лету"),

  //             1 - трансформировать данные при открытии и сохранить карту

  //                 в новой проекции,

  //            -1 - задать вопрос пользователю.

  // В серверной версии (-1) обрабатывается, как 0.

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapAppendData(HMAP hMap, const char * name,

                                       long int mode = 0);

 

_MAPIMP long int _MAPAPI mapAppendDataEx(HMAP hMap, const char * name,

                                         long int mode = 0,

                                         long int transform = -1);       

 

  // Добавить данные к открытой карте (карту, растр, матрицу)

  // hMap -  идентификатор открытых данных 

  // name - имя открываемого файла (SITX, SIT, MTW, MTQ, RSW, MPT) в кодировке UNICODE

  // mode - режим чтения/записи (GENERIC_READ, GENERIC_WRITE или 0)

  // transform - признак трансформирования пользовательской карты

  //             к ранее открытым данным (если проекции разные):

  //             0 - не трансформировать данные (преобразовывать "на лету"),

  //             1 - трансформировать данные при открытии и сохранить карту

  //                 в новой проекции,

  //            -1 - задать вопрос пользователю.

  // В серверной версии (-1) обрабатывается, как 0.

  // password - пароль доступа к данным из которого формируется 256-битный код

  //            для шифрования данных (при утрате данные не восстанавливаются)

  // size     - длина пароля в байтах !!!

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

  // Если пароль не передан, а он был указан при создании,

  // то автоматически вызывается диалог scnGetMapPassword из mapscena.dll (gisdlgs.dll)

  // Если выдача сообщений запрещена (mapIsMessageEnable()), то диалог

  // не вызывается, а при отсутствии пароля происходит отказ открытия данных

  // Возвращает идентификатор типа данных (FILE_MAP - для пользовательской

  // карты, FILE_RSW - для растра, FILE_MTW - для матрицы, FILE_MTL - для

  // матрицы слоев, FILE_MTQ - для матрицы качеств), данные добавляются в

  // список последними, если данные уже были открыты, число открытых данных

  // (карт, растров, матриц) не меняется

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapAppendAnyData(HMAP hMap, const WCHAR * name,

                                          long int mode = 0, long int transform = -1);

 

_MAPIMP long int _MAPAPI mapAppendDataUn(HMAP hMap, const WCHAR * name,

                                         long int mode = 0);

 

_MAPIMP long int _MAPAPI mapAppendAnyDataPro(HMAP hMap, const WCHAR * name,

                                             long int mode = 0, long int             transform = -1,

                                             const WCHAR * password = 0, long int size = 0);

 

  // Запросить размер данных по имени файла

  // При ошибке возвращает ноль

 

_MAPIMP double _MAPAPI mapGetDataSize(const char *name); 

_MAPIMP double _MAPAPI mapGetDataSizeUn(const WCHAR *name);

 

  // Запросить имя главной карты в документе или имя проекта,

  // если открыт проект

  // hMap -  идентификатор открытых данных

  // При ошибке возвращает пустую строку

 

_MAPIMP const char * _MAPAPI mapGetMainName(HMAP hMap);

_MAPIMP const WCHAR * _MAPAPI mapGetMainNameEx(HMAP hMap);             // 17/02/14 

 

  // Запросить/Установить в кодировке UNICODE имя главной карты в документе

  // или имя проекта, если открыт проект

  // hMap -  идентификатор открытых данных

  // name - адрес буфера для записи результата

  // size - длина строки в байтах

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetMainNameUn(HMAP hMap, WCHAR *name,

                                          long int size);

_MAPIMP long int _MAPAPI mapSetMainNameUn(HMAP hMap, const WCHAR * name);         // 04/02/17

 

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

  //или в проекте (MPT)      

  // hMap -  идентификатор открытых данных

  // При ошибке возвращает пустую строку

 

_MAPIMP const char * _MAPAPI mapGetMainMapName(HMAP hMap);

 

  // Запросить имя (полный путь к файлу) главной карты в документе

  // или в проекте (MPT)

  // hMap     -  идентификатор открытых данных

  // name     - буфер для возвращаемой строки

  // namesize - размер буфера в БАЙТАХ

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetMainMapNameUn(HMAP hMap, WCHAR *name, int namesize);

 

 

  // Проверка корректности паспортных данных и, если надо, то заполнение

  // координат по признаку приоритета 0 - расчет прямоугольных координат

  //                                  1 - геодезических

  // Структуры MAPREGISTEREX, LISTREGISTER описаны в mapcreat.h

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapCheckAndUpdate(MAPREGISTEREX *mapreg, LISTREGISTER *listreg,

                                           long int priority);

 

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

  // Структуры MAPREGISTEREX, LISTREGISTER описаны в mapcreat.h

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRegisterFromMapType(int maptype, MAPREGISTEREX * mapreg);

 

  // Запросить допустимые параметры для проекции

  // code - номер проекции из MAPPROJECTION (mapcreat.h)

  // Возвращает комбинацию флагов PROJECTIONPARAMETERS (mapcreat.h)

  // Например: значение 49 = EPP_AXISMERIDIAN|EPP_FALSEEASTING|EPP_FALSENORTHING

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetProjectionParameters(long int code);

 

  // Создать новый район (новую векторную карту)

  // mapname - полное имя файла карты (MAP, SIT, SITX)

  // rscname - полное имя файла ресурсов (RSC)

  // Возвращает идентификатор открытой векторной карты

  // Структуры MAPREGISTEREX и LISTREGISTER описаны в mapcreat.h

  // sheetnames - название (UTF-16) листа карты, номенклатуры и файлов даных (для многолистовой карты),

  // для пользовательской карты (не ограниченной рамкой) название листа и номенклатуры совпадает,

  // а название файлов данных совпадает с названием паспорта карты

  // mainname - главное название (UTF-16) многолистовой карты (MAP),

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

  // (Запросить главное название карты можно функцией mapGetSiteNameUn)

  // password  - пароль доступа к данным из которого формируется 256-    битный код

  //             для шифрования данных (при утрате данные не восстанавливаются)

  //             (поддерживается для карт с расширением SITX - хранилище в

  //              одном файле) или 0

  // size      - длина пароля в байтах (!) или 0

  // Возвращает идентификатор открытой векторной карты

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapCreateMapPro(const WCHAR * mapname,        // 14/10/14

                                     const WCHAR * rscname,

                                     MAPREGISTEREX * mapreg,

                                     LISTREGISTER * listreg,

                                     SHEETNAMES  * sheetnames,

                                     const WCHAR * mainname,

                                     const WCHAR * password, long int size);

 

_MAPIMP HMAP _MAPAPI mapCreateMapUn(const WCHAR * mapname,         

                                    const WCHAR * rscname,

                                    MAPREGISTEREX * mapreg,

                                    LISTREGISTER * listreg,

                                    const WCHAR * mainname,

                                    const WCHAR * password, long int size);

 

_MAPIMP HMAP _MAPAPI mapCreateMapEx(const char * mapname,

                                    const char * rscname,

                                    MAPREGISTEREX * mapreg,

                                    LISTREGISTER * listreg);

 

  // Создать план

  // (карта в местной системе координат)

  // mapname - полное имя файла карты

  // rscname - полное имя файла ресурсов

  // Струтктуры MAPREGISTEREX, LISTREGISTER описаны в mapcreate.h

  // Возвращает идентификатор открытой векторной карты

  // Структура CREATEPLAN описана в maptype.h

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapCreatePlane(const char * mapname,

                                    const char * rscname,

                                    CREATEPLANE * createplane);

 

_MAPIMP HMAP _MAPAPI mapCreatePlaneUn(const WCHAR * mapname,                    // 05/05/14

                                      const WCHAR * rscname,

                                      CREATEPLANE * createplane);

 

  // Создать пользовательскую карту

  // mapname - полное имя файла карты в кодировке UNICODE

  // rscname - полное имя файла ресурсов в кодировке UNICODE

  // Возвращает идентификатор открытой векторной карты

  // Структура CREATESITEUN описана в maptype.h

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapCreateSiteUn(const WCHAR * mapname, 

                                     const WCHAR * rscname,

                                     CREATESITEUN * createsite);

 

  // Создать пользовательскую карту по открытой карте

  // hmap -  идентификатор открытых данных

  // mapname - полное имя файла карты в кодировке UNICODE

  // rscname - полное имя файла ресурсов в кодировке UNICODE

  // Структура CREATESITEUN описана в maptype.h

  // Возвращает идентификатор открытой пользовательской карты

  // При ошибке возвращает ноль

 

_MAPIMP HSITE _MAPAPI mapCreateAndAppendSiteUn(HMAP hmap,               // 11/05/07

                                               const WCHAR *  mapname,

                                               const WCHAR * rscname,

                                               CREATESITEUN * createsite);

 

  // Создать временную пользовательскую карту

  // rscname - полное имя файла ресурсов

  // Файлы карты размещаются в рабочей директории системы

  // и имеют уникальные имена, генерируемые автоматически

  // При закрытии карты все файлы данных удаляются

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapCreateTempSite(const char * rscname);

_MAPIMP HMAP _MAPAPI mapCreateTempSiteUn(const WCHAR * rscname);       

 

     // Создать временную пользовательскую карту

  // rscname - полное имя файла ресурсов

  // mapreg  - параметры проекции создаваемой временной карты

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapCreateTempSiteEx(const char *rscname,      

                                               MAPREGISTEREX *mapreg);

_MAPIMP HMAP _MAPAPI mapCreateTempSiteExUn(const WCHAR *rscname,

                                           MAPREGISTEREX *mapreg,

                                           DATUMPARAM *datum,    

                                           ELLIPSOIDPARAM *ellipsoid);

 

  // Создать временную пользовательскую карту по открытой карте  

  // hmap    -  идентификатор открытых данных

  // rscname - полное имя файла ресурсов, если равно 0 - выбирается

  // из открытой карты

  // Файлы карты размещаются в рабочей директории системы

  // и имеют уникальные имена, генерируемые автоматически

  // При закрытии пользовательской карты все файлы данных автоматически удаляются

  // Возвращает идентификатор открытой пользовательской карты

  // При ошибке возвращает ноль

 

_MAPIMP HSITE _MAPAPI mapCreateAndAppendTempSite(HMAP hmap, const char * rscname);

_MAPIMP HSITE _MAPAPI mapCreateAndAppendTempSiteUn(HMAP hMap, const WCHAR *rscname);

                                                     

  // Переоткрыть главную карту          

  // Для специальных случаев. HMAP остается прежний, а

  // карта открывается новая

  // name     - имя открываемой карты

  // password - пароль доступа к данным из которого формируется 256-битный код

  // для шифрования данных (при утрате данные не восстанавливаются)

  // size     - длина пароля в байтах !!!

  // При ошибке возвращает ноль (в этом случае может остаться

  // открытой прежняя карта или никакой)

 

_MAPIMP long int _MAPAPI mapReOpenMapPro(HMAP hMap, const WCHAR * name, const WCHAR * password, long int size);

_MAPIMP long int _MAPAPI mapReOpenMap(HMAP hMap, const char * name);

 

  // Закрыть все данные электронной карты

  // hmap -  идентификатор открытых данных

  // Идентификатор HMAP становится недействительным !

 

_MAPIMP void _MAPAPI mapCloseData(HMAP hMap);

 

  // Закрыть все данные электронной карты

  // hmap -  идентификатор открытых данных

  // Идентификатор HMAP становится недействительным !

 

_MAPIMP void _MAPAPI mapCloseMap(HMAP hMap);

 

 // Копирование (перемещение) векторной карты

  // oldname - старое имя района

  // newname - новое имя района

  // ismove  - признак необходимости удаления старой копии карты (перемещения)

  // error   - код ошибки при выполнении команды (см. maperr.rh)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapCopyMapPro(const WCHAR *oldname, const WCHAR *newname, long int ismove, long int * error);

 

_MAPIMP long int _MAPAPI mapCopyMap(const char *oldname, const char *newname);

_MAPIMP long int _MAPAPI mapCopyMapUn(const WCHAR *oldname, const WCHAR *newname);

 

  // Закрыть и Удалить векторную карту (все файлы данных)

  // hmap - идентификатор открытых данных

  // После удаления идентификатор hMap не должен использоваться,

  // как после mapCloseData()

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDeleteMap(HMAP hMap);

 

  // Удаление района работ           

  // name      - имя удаляемой карты

  // rscdelete - признак удаления файла классификатора вместе с картой

  // Классификатор необходимо удалить отдельно

  // При ошибке возвращает ноль

 

_MAPIMP  long int _MAPAPI mapDeleteMapByName(const char *name);

_MAPIMP  long int _MAPAPI mapDeleteMapByNameUn(const WCHAR * name);

_MAPIMP long int _MAPAPI mapDeleteMapByNameEx(const WCHAR *name, long int rscdelete);  // 11/05/15

 

  // Открыть проект данных (карта, обстановки, растры, матрицы...)

  // name - имя файла проекта (MPT : структура, как в INI)

  // При ошибке возвращает ноль

 

_MAPIMP HMAP _MAPAPI mapOpenProject(const char *name);

_MAPIMP HMAP _MAPAPI mapOpenProjectUn(const WCHAR *name);

 

  // Добавить проект данных (карта, обстановки, растры, матрицы...)

  // name - имя файла проекта (MPT : структура, как в INI)

  // При ошибке возвращает ноль

 

_MAPIMP int _MAPAPI mapAppendProject(HMAP hMap, const char *name); 

_MAPIMP int _MAPAPI mapAppendProjectUn(HMAP hMap, const WCHAR *name);

 

  // Запросить имя открытого проекта

  // При ошибке возвращает пустую строку

 

_MAPIMP const char * _MAPAPI mapGetProjectName(HMAP hMap);

  // Запросить имя открытого проекта

  // hmap     -  идентификатор открытых данных

  // name     - буфер для размещения возвращаемой строки

  // namesize - размер буфера в БАЙТАХ

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetProjectNameUn(HMAP hMap, WCHAR *name, long int namesize);

 

  // Сохранить текущее описание данных в проекте данных

  // hmap -  идентификатор открытых данных

  // name - имя файла проекта (MPT : структура, как в INI)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSaveProjectUn(HMAP hMap, const WCHAR * name); 

_MAPIMP long int _MAPAPI mapSaveProject(HMAP hMap, const char * name);

 

     // Запросить - является ли документ проектом (MPT)          // 29/07/15

  // hmap -  идентификатор открытых данных

  // Если это проект - возвращает ненулевое значение

 

_MAPIMP long int _MAPAPI mapIsDocProject(HMAP hMap);

 

  // Сохранить текущие параметры окна карты в INI-файл карты,  

  // имя файла можно запросить через mapGetMapIniName()

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

  // Сохраняет описание открытых данных, масштаб, палитру, признаки видимости,

  // редактируемости, состав отображаемых объектов...

  // hmap  -  идентификатор открытых данных

  // point -  координаты центра окна в метрах (может быть 0)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSaveMapState(HMAP hMap, DOUBLEPOINT * point);

 

  // Восстановить параметры окна карты из INI-файла карты,     

  // имя файла можно запросить через mapGetMapIniName()

  // Вызывается после открытия карты

  // Восстанавливает описание списка данных, масштаб, палитру, признаки видимости,

  // редактируемости, состав отображаемых объектов...

  // hmap  -  идентификатор открытых данных

  // point -  координаты центра окна в метрах (может быть 0)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRestoreMapState(HMAP hMap, DOUBLEPOINT * point);

 

  // Запросить - есть ли какие-либо открытые данные

  // Данные - векторные, растровые, матричные...

  // hmap -  идентификатор открытых данных

  // Если открытых данных нет или ошибка - возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsActive(HMAP hMap);

 

  // Запросить - есть ли какие-либо открытые векторные карты       

  // Если открытых векторных карт нет или ошибка - возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsVectorMapActive(HMAP hMap);

_MAPIMP long int _MAPAPI mapIsVectorActive(HMAP hMap);

 

  // Запросить - есть ли какие-либо открытые векторные карты,       

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

  // Если доступных для редактирования векторных карт нет

  // или ошибка - возвращает ноль

 

  long int _MAPAPI mapIsVectorMapEdit(HMAP hMap);

 

  // Выполнить согласование данных электронной карты

  // в памяти и на диске (при многопользовательском доступе

  // к данным)

  // hmap -  идентификатор открытых данных

  // Если состояние данных в памяти изменилось (по данным

  // с диска) - возвращает ненулевое значение (1), иначе 0

  // Если карта должна быть закрыта - возвращает 2

  // (доступ на ГИС Сервер прекращен!)

  // Если состояние изменилось - необходимо перерисовать

  // изображение карты

  // Опрос состояния целесообразно выполнять периодически

  // в процессе работы приложения

 

_MAPIMP long int _MAPAPI mapAdjustData(HMAP hMap);

 

  // Установить доступность для выполнения команды Adjust

  // mode - признак доступности обработки команды Adjust,

  //        если равен 0 - команда не обрабатывается.

  // При выполнении длительных процедур (отмена длинных

  // транзакций, трансформирование данных и т.п.) целесообразно

  // отключать команду Adjust, если она может быть вызвана из

  // других потоков приложения. Команда Adjust может вызывать

  // переоткрытие карт и перераспределение памяти.

  // Возвращает прежнее значение

 

_MAPIMP long int _MAPAPI mapSetAdjustMode(HMAP hMap, long int mode);      

 

  // Сохранить данные на диск                             

  // при работе на Sparc-платформе также сохраняет данные в файлы Intel-платформы

  // hMap - идентификатор базовой карты

  // hSite - идентификатор пользовательской карты

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapFlushData(HMAP hMap, HSITE hSite);

 

  // Создать(добавить) новый лист в районе

  // hmap -  идентификатор открытых данных

  // Структура LISTREGISTER описана в mapcreat.h

  // При ошибке возвращает ноль, иначе - номер созданного листа

 

_MAPIMP long int _MAPAPI mapCreateList(HMAP hMap,LISTREGISTER *sheet);

_MAPIMP long int _MAPAPI mapCreateListPro(HMAP hMap, LISTREGISTER *sheet,

                                          SHEETNAMES * sheetnames);      // 07/11/14

 

  // Удалить указанный лист карты

  // list - номер листа (с 1)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDeleteList(HMAP hmap, long int list);

 

  // Добавить листы из другого района работ в данный

  // hmap -  идентификатор открытых данных

  // mapname - добавляемый район,

  // handle - идентификатор окна,которое будет извещаться

  // о ходе процесса (0x585 - 0x588)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapAppendMapToMap(HMAP hMap, const char *mapname, HWND handle);

_MAPIMP long int _MAPAPI mapAppendMapToMapUn(HMAP hMap, const WCHAR *name, HWND handle);

 

  // Cоздать пустой объект векторной карты

  // (создание подобъекта - см. редактирование метрики)

  // По умолчанию метрика FLOAT 2-ух мерная

  // hmap - идентификатор открытых данных

  // sheetnumber - номер листа в котором будет расположен

  // kind - тип создаваемой метрики, описан в maptype.h

  // создаваемый объект

  // text - признак метрики с текстом (объекты типа "подпись")

  // (устанавливается автоматически при вызове mapPutText(...))

  // После вызова функций типа What...() и Seek...() все параметры

  // полученного объекта могут измениться (text,kind,list и т.п.)

  // При ошибке возвращает ноль

 

#ifndef HIDEFORMAT

_MAPIMP HOBJ _MAPAPI mapCreateObject(HMAP hMap,long int sheetnumber = 1,

                                     long int kind = IDDOUBLE2,

                                     long int text = 0);

#endif

 

  // Очистить содержимое объекта

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

  // hmap - идентификатор открытых данных

  // sheetnumber - номер листа в котором будет расположен

  // kind - тип создаваемой метрики, описан в maptype.h

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapClearObject(HOBJ info,

                                  long int sheetnumber = 1,

                                  long int kind = IDDOUBLE2);

 

  // Cоздать копию объекта векторной карты

  // hmap - идентификатор открытых данных

  // info - идентификатор объекта карты в памяти

  // Для каждого полученного и больше не используемого

  // идентификатора HOBJ необходим вызов функции mapFreeObject()

  // При ошибке возвращает ноль

 

_MAPIMP HOBJ _MAPAPI mapCreateCopyObject(HMAP hMap,HOBJ info);

 

  // Считать копию объекта векторной (src) карты в другой объект (dest)

  // Для каждого полученного и больше не используемого

  // идентификатора HOBJ необходим вызов функции mapFreeObject()

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapReadCopyObject(HOBJ dest, HOBJ src);

 

  // Cоздать копию объекта векторной карты, как нового объекта (!)

  // hmap - идентификатор открытых данных

  // info - идентификатор объекта карты в памяти

  // Для каждого полученного и больше не используемого

  // идентификатора HOBJ необходим вызов функции FreeObject()

  // При ошибке возвращает ноль

 

_MAPIMP HOBJ _MAPAPI mapCreateCopyObjectAsNew(HMAP hMap,HOBJ info);

 

  // Cоздать копию объекта векторной карты, как нового объекта

  // Для каждого полученного и больше не используемого

  // идентификатора HOBJ необходим вызов функции FreeObject()

  // src  - исходный объект,

  // dest - копия объекта (при сохранении - будет создан новый)

  // Предполагается, что до сохранения в копии что-то поменяют.

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapCopyObjectAsNew(HOBJ dest, HOBJ src);

 

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

  // info - идентификатор объекта карты в памяти

  // Для сохранения объекта на карте необходимо

  // до вызова mapFreeObject(...) выполнить функцию

  // mapCommitObject(...)

  // При ошибке возвращает ноль

 

_MAPIMP void _MAPAPI mapFreeObject(HOBJ info);

 

  // Запросить код ошибки последней операции доступа к данным

  // Коды ошибок - см. maperr.rh

 

_MAPIMP long int _MAPAPI mapGetAccessError();

 

 // Считать объект, который отображался последним перед возникновением

 // сбоя отображения карт

 // Применяется при попадании в секцию catch(..) при вызове отображения

 // карты для вывода диагностической информации

 // hmap - идентификатор открытых данных;

 // info - идентификатор существующего объекта,

 // в котором будет размещен результат поиска.

 // Если такой объект не установлен - возвращает ноль

 

_MAPIMP long int _MAPAPI mapReadLastViewObject(HMAP hMap, HOBJ info);   

 

  // Запросить, растягивается ли объект по метрике                              

  // Данный признак может быть установлен у подписей

  // и векторных объектов

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsObjectStretch(HOBJ info);              

 

   // Установить/Запросить признак записи в создаваемые и обновляемые объекты      // 19/08/16

  // служебных семантик 32850-32855 (дата, время, автор операции)

  // Признак устанавливается для всех открытых карт документа (HMAP)

  // Запись семантик выполняется внешними задачами (Редактор карты, Выбор объекта и другими)

  // hmap - идентификатор открытых данных

  // flag - признак записи служебных семантик (если значение не равно 0 - записывать)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetObjectsDataAndUserFlag(HMAP hMap, long int flag);

_MAPIMP long int _MAPAPI mapGetObjectsDataAndUserFlag(HMAP hMap);

 

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

  *                                                        *

  *    ФУНКЦИИ ОТОБРАЖЕНИЯ И ПЕЧАТИ ЭЛЕКТРОННОЙ КАРТЫ      *

  *  ПАРАМЕТРЫ КОНТЕКСТА ПОДГОТОВЛЕНЫ (HDC) И УСТАНОВЛЕНО  *

  *  СМЕЩЕНИЕ НА ОБЛАСТЬ ВЫВОДА В ОКНЕ ::SetViewportOrgEx()*

  *                                                        *

  *  Размер картинки, рисуемой за один вызов на экран или  *

  *  в память, не более текущих размеров экрана!           *

  *  Произвольный размер - см. PaintToDib,PaintToImage,    *

  *                            PaintToXImage               *

  *                                                        *

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

 

 // Установить общие параметры проекции документа для отображения,      

 // печати и расчета координат

 // hmap  - идентификатор открытых данных (документа)

 // Структуры MAPREGISTER, DATUMPARAM и ELLIPSOIDPARAM описаны в mapcreat.h

 // type  - тип локального преобразования координат (см. TRANSFORMTYPE в mapcreat.h) или 0

 // parm - параметры локального преобразования координат (см. mapcreat.h)

 // Устанавливать общие параметры проекции можно для документа

 // поддерживающего пересчет геодезических координат (mapIsGeoSupported() != 0)

 // После установки общих параметров проекции изображение карты формируется

 // в заданной проекции. Векторные карты, имеющие другие параметры

 // проекции, трансформируются в процессе отображения.

 // Матрицы и растры не трансформируются при отображении и должны иметь

 // те же параметры проекции, что и общие параметры документа

 // Все операции с координатами (mapPlaneToGeo, mapGeoToPlane,

 // mapPlaneToGeoWGS84, mapAppendPointPlane, mapInsertPointPlane,

 // mapUpdatePointPlane, mapAppendPointGeo и другие) выполняются

 // в системе координат документа, определяемой общими параметрами проекции

 // При чтении\записи координат в конкретной карте выполняется пересчет

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

 // Например, при записи координат из WGS84 на карту в СК-42 можно

 // установить общие параметры документа, как "Широта/Долгота на WGS-84"

 // и выполнить запись координат функцией mapAppendPointGeo, не заботясь

 // о дополнительном пересчете координат, или считать координаты функцией

 // mapGetGeoPoint (или функцией mapGetGeoPointWGS84, игнорирующей параметры

 // документа).

 // Чтобы установить текущие параметры проекции и системы координат, как у первой

 // карты в документе можно передать в качестве параметров (кроме hMap) нули,

 // или вызвать mapClearDocProjection.

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetDocProjectionPro(HMAP hMap,                 // 10/09/16

                                                MAPREGISTEREX * mapreg,

                                                DATUMPARAM * datum,

                                                ELLIPSOIDPARAM * ellparm,

                                                long int ttype,

                                                LOCALTRANSFORM * tparm);

 

_MAPIMP long int _MAPAPI mapSetDocProjection(HMAP hMap,

                                             MAPREGISTEREX * map,

                                             DATUMPARAM * datum,

                                             ELLIPSOIDPARAM * ellparm);

 

_MAPIMP long int _MAPAPI mapClearDocProjection(HMAP hMap);

                                           

 // Запросить общие параметры проекции документа для отображения,      

 // печати и расчета координат

 // hmap  - идентификатор открытых данных (документа)

 // Структуры MAPREGISTER, DATUMPARAM и ELLIPSOIDPARAM описаны в mapcreat.h

 // type  - тип локального преобразования координат (см. TRANSFORMTYPE в mapcreat.h) или 0

 // parm - параметры локального преобразования координат (см. mapcreat.h)

 // Если параметры не устанавливались функцией mapSetMapInfoEx,

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

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetDocProjectionPro(HMAP hMap,                // 10/09/16

                                                MAPREGISTEREX * map,

                                                DATUMPARAM * datum,

                                                ELLIPSOIDPARAM * ellparm,

                                                long int * ttype,

                                                LOCALTRANSFORM * tparm);

 

_MAPIMP long int _MAPAPI mapGetDocProjection(HMAP hMap,

                                             MAPREGISTEREX * map,

                                             DATUMPARAM * datum,

                                             ELLIPSOIDPARAM * ellparm);

 

 // Запросить - устанавливались ли общие параметры проекции документа

 // для отображения, печати и расчета координат

 // hmap  - идентификатор открытых данных (документа)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsDocProjection(HMAP hMap);

                                      

 // Запросить размеры общего изображения карты в пикселах

 // для текущего масштаба

 // hmap - идентификатор открытых данных

 // В переменную width заносится ширина изображения (dx),

 // в переменную height - высота (dy)

 

_MAPIMP void _MAPAPI mapGetPictureSize(HMAP hmap, long int * width,

                                       long int * height);

_MAPIMP void _MAPAPI mapGetPictureSizePro(HMAP hmap, double * width,

                                          double * height);

                                          

_MAPIMP long int _MAPAPI mapGetPictureHeight(HMAP hMap);

_MAPIMP long int _MAPAPI mapGetPictureWidth(HMAP hMap);

 

 // Запросить ширину пиксела изображения карты в метрах на местности

 // для текущего масштаба изображения                 

 // При ошибке возвращает ноль

 

_MAPIMP double _MAPAPI mapGetPixelWidth(HMAP hMap);

 

 // Запросить высоту пиксела изображения карты в метрах на местности

 // для текущего масштаба изображения

 // При ошибке возвращает ноль

 

_MAPIMP double _MAPAPI mapGetPixelHeight(HMAP hMap);

 

 // Запросить идентификатор логической палитры карты

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP HPALETTE _MAPAPI mapGetMapPalette(HMAP hmap);

 

 // Запросить описание цвета палитры по индексу (index)

 // hmap - идентификатор открытых данных

 // Номер первого индекса равен нулю

 

_MAPIMP COLORREF _MAPAPI mapGetMapColor(HMAP hmap,long int index);

 

 // Запросить число цветов логической палитры

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetColorCount(HMAP hmap);

 

// Создать/Удалить контекст отображения для многопоточного вызова   // 26/10/15

 // функций mapPaintByFramePro или mapPaintByFrameToXImagePro

 // hmap - идентификатор открытых данных

 // Для каждого потока создается свой контекст и передается в качестве параметра функции

 // В каждом контексте создается свой буфер отображения и выделяется память под служебные области

 // Размер резервируемой памяти помимо буфера отображения может занимать 1-2 Мбайта,

 // внутренний буфер отображения для размера 1920x1080 занимает 8 Мбайт

 // Размер может устанавливаться программно - mapSetMaxScreenImageSize

 // При ошибке возвращает ноль

 

_MAPIMP HPAINT _MAPAPI mapCreatePaintControl(HMAP hmap);

_MAPIMP void _MAPAPI mapFreePaintControl(HPAINT hPaint);

 

 // Сменить идентификатор открытых данных в контексте отображения     // 26/10/15

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

 // в буфер изображения одного контекста из нескольких HMAP

 // для наложения слоев

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

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetPaintControlMapHandle(HPAINT hPaint, HMAP hmap);

 

 // Установить параметры системы координат документа в контексте отображения      // 05/11/15

 // Применяется для установки системы координат формируемого изображения

 // по коду EPSG

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

 // epsgcode - код EPSG для требуемой системы координат (например, 3395, 3857, 4326)

 // Для геодезических систем координат возвращает 2,

 // для плоских прямоугольных возвращает 1.

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetPaintControlProjection(HPAINT hPaint, long int epsgcode);

 

 // Запросить идентификатор открытых данных, для которых создан контекст отображения

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

 // При ошибке возвращает ноль

 

 _MAPIMP HMAP _MAPAPI mapGetPaintControlMapHandle(HPAINT hPaint);

 

#ifdef WIN32API

 // Запросить контекст устройства отображения для внутреннего буфера  // 26/10/15

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

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

 // поверх которого будет отрисована карта (растр, матрица) и

 // для считывания готового изображения

 // При ошибке возвращает ноль

 

 _MAPIMP HDC _MAPAPI mapGetPaintControlDC(HPAINT hPaint);

#endif

 

 // Скопировать содержимое внутреннего буфера в заданную область      // 26/10/15

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

 // imagedesc - описание выходного буфера изображения

 // При ошибке возвращает ноль

 

 _MAPIMP long int _MAPAPI mapCopyPaintControlToXImage(HPAINT hPaint, XIMAGEDESC * imagedesc);

 

 // Отобразить фрагмент карты, смасштабировав до заданной ширины и высоты  // 31/03/11

 // в текущем составе объектов (применяется для обработки OGC WMS-запросов)

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 //         если контекст устройства вывода равен 0, то отрисовка выполняется

 //         во внутренний буфер контекста отображения (hPaint)

 // erase - признак стирания фона перед выводом,

 //        (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

 //         для экранного способа вывода (VT_SCREEN) всегда стирает

 //         цветом фона, кроме значения -2 (минус 2))

 //         При последовательном отображении нескольких HMAP в один контекст

 //         отображения, для второго HMAP и далее значение erase = -2 при hdc = 0

 // frame  - координаты фрагмента карты в системе координат документа в метрах

 // (см. mapSetDocProjection)

 // width  - ширина изображения в пикселах

 // height - высота изображения в пикселах

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 // filename  - полное имя создаваемого файла формата png

 // viewselect - условия отбора отображаемых объектов, если равно 0, то применяются

 //           условия обобщенного поиска\выделения (внутренние)

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

 // Данная функция может изменять текущий масштаб отображения документа (если hPaint равен 0),

 // для сохранения текущего масштаба можно применить функции mapGetRealShowScale/mapSetRealShowScale

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintByFramePro(HMAP hMap,HDC hDC,          // 26/10/15

                                            long int erase, DFRAME * frame,

                                            long int width, long int height, long int alpha,

                                            HSELECT viewselect, HPAINT hPaint);

 

_MAPIMP long int _MAPAPI mapPaintByFrame(HMAP hMap,HDC hDC,

                                         long int erase, DFRAME * frame,

                                         long int width, long int height);

 

_MAPIMP long int _MAPAPI mapPaintByFrameEx(HMAP hMap,HDC hDC,                                              long int erase, DFRAME * frame,

                                      long int width, long int height, long int alpha);

 

_MAPIMP long int _MAPAPI mapPaintByFrameSelectEx(HMAP hMap,HDC hDC,

                                           long int erase, DFRAME *frame,

                                           long int width, long int height, long int alpha,

HSELECT viewselect);

 

_MAPIMP long int _MAPAPI mapPaintByFrameToFile(HMAP hMap,  const char *filename,

                                         long int erase, DFRAME * frame,

                                         long int width, long int height);

_MAPIMP long int _MAPAPI mapPaintByFrameToFileUn(HMAP hMap, const WCHAR *filename,

                                                 long int erase, DFRAME *frame,

                                                 long int width, long int height);

 

 

 // Отобразить фрагмент карты на заданном устройстве

 // в текущих масштабе и составе объектов

 // Функция mapPaintDoc печатает карту и список врезок без необходимости

 // дополнительного вызова mapPaintInset                                  // 01/06/17

 // hmap  - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // erase - признак стирания фона перед выводом,

 //        (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

 //        для экранного способа вывода (VT_SCREEN) всегда стирает

 //        цветом фона, кроме значения -2 (минус 2))

 // rect - координаты фрагмента карты (Draw) в изображении (Picture)

 // Корректно работает с большими изображениями под Windows95 и NT,

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

 //              ::SetViewportOrgEx(hDC, dx , dy, 0),

 // где dx,dy - положение отображаемого фрагмента в клиентной

 // области !

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 // filename  - полное имя создаваемого файла формата png

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 // Если image != 0 и object != 0 дополнительно вызвается фукция

 // mapPaintMapObject95Ex  (Отобразить произвольный объект в пределах фрагмента

 // в условных знаках пользователя)

 // image - описание вида объекта (см. MAPGDI.H),

 // object - идентификатор объекта

 

_MAPIMP long int _MAPAPI mapPaintDoc(HMAP hmap, HDC hdc, long int erase, RECT *rect, long int alpha);  // 01/06/17

 

_MAPIMP long int _MAPAPI mapPaint95(HMAP hmap, HDC hdc, long int erase, RECT *rect);

 

_MAPIMP long int _MAPAPI mapPaint95Ex(HMAP hmap, HDC hdc, long int erase,

                                  RECT *rect, long int alpha);

 

_MAPIMP long int _MAPAPI mapPaint95ToFile(HMAP hMap, const char *filename,

                                          long int erase, RECT *rect, long int alpha,

                                          PAINTPARM *image, HOBJ object);

 

_MAPIMP long int _MAPAPI mapPaint95ToFileUn(HMAP hMap, const WCHAR *filename,

                                            long int erase, RECT *rect, long int alpha,

                                            PAINTPARM *image, HOBJ object);

 

 // Отобразить фрагмент карты на заданном устройстве

 // в текущих масштабе и составе объектов и

 // выделить на карте объекты, удовлетворющие заданным условим

 // hMap   - идентификатор открытых данных

 // hdc    - контекст устройства

 // erase  - признак стирания фона перед выводом,

 //          (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

 //          для экранного способа вывода (VT_SCREEN) всегда стирает

 //          цветом фона, кроме значения -2 (минус 2))

 // rect   - координаты фрагмента карты (Draw) в изображении (Picture)

 // select - условия отбора объектов, если равны 0, то применяются

 //          условия обобщенного поиска\выделения (см. mapTotalPaintSelect95).

 // color  - цвет, которым будут выделяться объекты на карте

 // Корректно работает с большими изображениями под Windows95 и NT,

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

 //              ::SetViewportOrgEx(hDC, dx , dy, 0),

 // где dx,dy - положение отображаемого фрагмента в клиентной области !

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана!

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 // filename  - полное имя создаваемого файла формата png

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 // Если image != 0 и object != 0 дополнительно вызвается фукция

 // mapPaintMapObject95Ex  (Отобразить произвольный объект в пределах фрагмента

 // в условных знаках пользователя)

 // image - описание вида объекта (см. MAPGDI.H),

 // object - идентификатор объекта

 

_MAPIMP void _MAPAPI mapPaint95AndSelect(HMAP hMap, HDC hDC, long int erase,

                                         RECT *rect, HSELECT select, COLORREF color);

 

_MAPIMP void _MAPAPI mapPaint95AndSelectEx(HMAP hMap, HDC hDC, long int erase,

                                           RECT *rect, HSELECT select,

                                          COLORREF color, long int alpha);

 

_MAPIMP long int _MAPAPI mapPaint95AndSelectToFile(HMAP hMap, const char *filename,

                                              long int erase, RECT *rect,

                                          HSELECT select, COLORREF color,

                                         ong int alpha, PAINTPARM *image,

                                                   HOBJ object);

 

_MAPIMP long int _MAPAPI mapPaint95AndSelectToFileUn(HMAP hMap, const WCHAR *filename,

                                               long int erase, RECT *rect,

                                               HSELECT select, COLORREF color, long int alpha,

                                           PAINTPARM *image, HOBJ object);

 

 // Отобразить фрагмент карты на заданном устройстве

 // в текущих масштабе и составе объектов

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // erase - признак стирания фона перед выводом,

 // (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

 //  для экранного способа вывода (VT_SCREEN) всегда стирает

 //  цветом фона, кроме значения -2 (минус 2))

 // rect  - координаты фрагмента карты (Draw)

 // в изображении (Picture).

 // С изображениями больше 32000х32000 работает только

 // под Windows NT (Windows 95 имеет 16-битовую графику)

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 

_MAPIMP void _MAPAPI mapPaint(HMAP hmap, HDC hdc, long int erase, RECT *rect);

 

 // Установить толщину линии для отрисовки выделенных на карте

 // объектов (при вызове mapPaint95AndSelect и т.п.)                  

 // thick - толщина линии в mkm (из пикселов - PIX2MKM(pixel))

 // Возвращает установленное ранее значение

 

_MAPIMP long int _MAPAPI mapSetSelectLineThick(HMAP hmap, long int thick);

 

 // Отобразить отдельный объект карты в пределах фрагмента

 // в условных знаках карты

 // Может использоваться для вывода шаблонов объектов

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // rect  - координаты фрагмента карты (Draw)

 // info - идентификатор объекта карты в памяти

 // При ошибке в параметрах возвращает ноль

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 

_MAPIMP long int _MAPAPI mapPaintObject(HMAP hmap, HDC hdc, RECT *rect,

                                        HOBJ info);

 

 // Отобразить отдельный объект карты в пределах фрагмента

 // в условных знаках карты

 // Может использоваться для вывода шаблонов объектов

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // rect  - координаты фрагмента карты (Draw)

 // info - идентификатор объекта карты в памяти

 // erase -  признак стирания фона перед выводом,

 // (0 - фон не стирать, !=0 - очистить фрагмент цветом фона),

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

 // (1 - не обрезать, 0 - выполнить обрезку)           

 // При ошибке в параметрах возвращает ноль

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 

_MAPIMP long int _MAPAPI mapPaintObjectEx(HMAP hmap, HDC hdc, RECT *rect,

                                          HOBJ info, long int erase,

                                          long int dontclip);

 

 // Отобразить отдельный объект карты в пределах фрагмента

 // в условных знаках карты

 // Может использоваться для вывода шаблонов объектов

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // rect  - координаты фрагмента карты (Draw)

 // info - идентификатор объекта карты в памяти

 // Корректно работает с большими изображениями под Windows95 и NT,

 // При ошибке в параметрах возвращает ноль

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 

_MAPIMP long int _MAPAPI mapPaintObject95(HMAP hmap, HDC hdc, RECT * rect,

                                          HOBJ info);

 

_MAPIMP long int _MAPAPI mapPaintObject95Ex(HMAP hmap, HDC hdc, RECT * rect,

                                          HOBJ info, long int alpha);    

 

 // Отобразить произвольный объект в пределах фрагмента окна (карты)

 // в условных знаках пользователя

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // rect  - координаты фрагмента карты (Draw)

 // image - описание вида объекта (см. MAPGDI.H), если объект

 // должен рисоваться своим условным знаком - значение параметра

 // можно установить в ноль

 // info - идентификатор объекта карты в памяти

 // При ошибке в параметрах возвращает ноль

 // Размер картинки, рисуемой за один вызов, не более

 // текущих размеров экрана! Иначе - см. PaintToDib,PaintToImage...

 // filename  - полное имя создаваемого файла формата png

 // alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

 

_MAPIMP long int _MAPAPI mapPaintMapObject95(HMAP hmap, HDC hdc,RECT rect,

                                             PAINTPARM *image, HOBJ info);

 

_MAPIMP long int _MAPAPI mapPaintMapObject95Ex(HMAP hMap,HDC hdc,RECT rect,

                                            PAINTPARM *image, HOBJ object,

                                                          long int alpha);

 

_MAPIMP long int _MAPAPI mapPaintMapObject95ToFile(HMAP hMap, const char *filename,

                                             RECT *rect, PAINTPARM *image,

                                             HOBJ object, long int alpha);

 

_MAPIMP long int _MAPAPI mapPaintMapObject95ToFileUn(HMAP hMap, const WCHAR *filename,

                                             RECT *rect, PAINTPARM *image,

                                             HOBJ object, long int alpha);

 

 // Отобразить произвольный объект в пределах фрагмента

 // в условных знаках пользователя

 // hmap - идентификатор открытых данных

 // hdc   - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw) в изображении (Picture)

 // image - описание вида объекта (см. MAPGDI.H), если объект

 // должен рисоваться своим условным знаком - значение параметра

 // можно установить в ноль,

 // info - идентификатор объекта карты в памяти

 // offset - смещение координат объекта (в соответствии с place)

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintOffsetMapObject95(HMAP hmap, HDC hdc, RECT *rect,

                                              PAINTPARM *image, HOBJ info,

                                                      DOUBLEPOINT *offset,

                                                 long int place = PP_MAP);

 

 // Отобразить образец вида объекта по номеру записи     

 // в классификаторе объектов (incode)

 // hmap - идентификатор открытой карты

 // hrsc - идентификатор классификатора открытой карты

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты клиентской области окна вывода (размер окна)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleRscObject(HMAP hmap, HRSC hrsc,

                                                  HDC hdc, RECT* rect,

                                                  long int incode);

 

 // Отобразить образец вида объекта

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExample(HMAP hMap, PAINTEXAMPLE* parm);

 

#ifdef WIN32API

 

 // Вывести изображение карты в DIB

 // Данная функция реализована только для платформы Windows !

 // Выводится фрагмент карты, заданный параметром rect.

 // Заполнется палитра,расположенная за BITMAINFOHEADER

 // Изображение строится в текущем масштабе и составе объектов

 // Размер точки 1,2,3 или 4 байт.

 // Если размеры заданного DIB меньше размеров фрагмента -

 // изображение строится в пределах размеров DIB.

 //  hmap      - идентификатор открытых данных

 //  dibinfo   - описатель создаваемого DIB в памяти

 //  lpDibBits - адрес первого байта битовой области.

 //  rect      - координаты фрагмента карты (Draw)

 //              в изображении (Picture).

 // Размер области DIB, задаваемый параметром dibinfo->biSizeImage,

 // должен учитывать то, что каждая строка DIB должна быть

 // кратна 4 байтам (32 битам):

 //  dibinfo->biSizeImage = dibinfo->biHeight *

 //    ((dibinfo->biWidth * dibinfo->biBitCount + 31) / 32) * 4;

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintToDib(HMAP hmap, BITMAPINFOHEADER * dibinfo,

                                       char * lpDibBits, RECT * rect);

 

#ifndef WINCE

 

 // Вывести изображение карты в Image (массив)

 // Данная функция реализована только для платформы Windows !

 // Выводится фрагмент карты, заданный параметром rect.

 // Заполняется палитра в поле palette.

 // Изображение строится в текущем масштабе и составе объектов

 // Палитра Image только 256 цветов, размер точки 1 байт !

 // Если размеры заданного Image меньше размеров фрагмента -

 // изображение строится в пределах размеров Image.

 //  hmap          - идентификатор открытых данных

 //  palette       - адрес палитры (256 RGBQUAD-цветов)

 //  lpImage       - адрес первого байта области изображения.

 //  width, height - ширина и высота Image.

 //  rect          - координаты фрагмента карты (Draw)

 //                  в изображении (Picture).

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintToImage(HMAP hmap, RGBQUAD *palette,

                                         char *lpImage, long int width,

                                         long int height, RECT *rect);

#endif  // !WINCE

#endif  // WIN32API

 

 // Вывести изображение объекта в DIB                

 //  hmap      - идентификатор открытых данных

 //  lpDibBits - адрес первого байта буфера изображения (32 бита)

 //  width     - ширина изображения (кратно 32),

 //  height    - высота изображения,

 //  rect      - координаты фрагмента карты (Draw)

 //              в изображении (Picture).

 //  image     - описание вида объекта (см. MAPGDI.H), если объект

 //              должен рисоваться своим условным знаком - значение параметра

 //              можно установить в ноль,

 //  info      - идентификатор объекта карты в памяти

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintMapObjectToDib(HMAP hmap, char * lpImage,

                                                int width, int heigth, RECT * rect,

                                                PAINTPARM * image, HOBJ object);

 

// Отобразить фрагмент карты, смасштабировав до заданной ширины и высоты

// в текущем составе объектов

// hmap  - идентификатор открытых данных

// imagedesc - описание выходного буфера изображения

// erase - признак стирания фона перед выводом,

// (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

//  для экранного способа вывода (VT_SCREEN) всегда стирает

//  цветом фона, кроме значения -2 (минус 2))

// frame  - координаты фрагмента карты в системе координат документа в метрах

// (см. mapSetDocProjection)

// width  - ширина изображения в пикселах

// height - высота изображения в пикселах

// Описание структуры XIMAGEDESC в maptype.h

// alpha - флаг использования альфа канала 0 - не использовать 1 - использовать

// viewselect - условия отбора объектов, если равны 0, то применяются

// условия обобщенного поиска\выделения

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

// При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintByFrameToXImagePro(HMAP hMap, XIMAGEDESC * imagedesc,  // 26/10/15

                                                    long int erase,

                                                    DFRAME *frame, long int width,

                                                    long int height, long int alpha,

                                                    HSELECT viewselect, HPAINT hPaint);

 

_MAPIMP long int _MAPAPI mapPaintByFrameToXImage(HMAP hMap, XIMAGEDESC * imagedesc,

                                                   DFRAME *frame, long int width,

                                                   long int height, long int alpha);

 

_MAPIMP long int _MAPAPI  mapPaintByFrameSelectToXImage(HMAP hMap, XIMAGEDESC * imagedesc,

                                                   DFRAME *frame, long int width,

                                                   long int height, long int alpha, HSELECT viewselect);

 

 // Вывести изображение карты в XImage (массив)

 // Описание структуры XIMAGEDESC в maptype.h

 // hmap - идентификатор открытых данных

 // x,y - координаты левого верхнего угла внутри

 // битовой области XImage для размещения изображения

 // rect - выводимый фрагмент карты

 // При ошибке в параметрах возвращает ноль

 

  long int _MAPAPI mapPaintToXImage(HMAP hmap,

                                     XIMAGEDESC * imagedesc,

                                     long int x, long int y,

                                     RECT * rect);

 

 // Отобразить произвольный объект в пределах фрагмента

 // в условных знаках пользователя в структуру XImage

 // imagedesc - структура XIMAGEDESC (см. maptype.h)

 // x,y   - координаты левого верхнего угла внутри

 // rect  - выводимый фрагмент карты

 // image - описание вида объекта (см. mapgdi.h),

 // data  - координаты объекта,

 // place - система координат

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI  mapPaintUserObjectToXImage(HMAP hMap,

                                                     XIMAGEDESC * imagedesc,

                                                     long int x, long int y,

                                                     RECT * rect, PAINTPARM * image,

                                                     PLACEDATA * data, long int place);

 

  // Вывести изображение карты в XImage (массив) и выделить

  // на карте отобранные объекты                                  

  // Описание структуры XIMAGEDESC в maptype.h

  // x,y - координаты левого верхнего угла внутри

  // битовой области XImage для размещения изображения

  // rect - выводимый фрагмент карты

  // select - условия отбора объектов, если равны 0, то применяются

  //          условия обобщенного поиска\выделения (см. mapTotalPaintSelect95).

  // color  - цвет, которым будут выделяться объекты на карте

  // При ошибке в параметрах возвращает ноль

 

 _MAPIMP long int _MAPAPI mapPaintAndSelectToXImage(HMAP hMap, XIMAGEDESC *imagedesc,

                                       long int x, long int y, RECT *rect,

                                       HSELECT select, COLORREF color);

 

  // Вывести изображение карты и объекта в XImage (массив)        

  // Описание структуры XIMAGEDESC в maptype.h

  // x,y - координаты левого верхнего угла внутри

  // битовой области XImage для размещения изображения

  // rect - выводимый фрагмент карты

  // При ошибке в параметрах возвращает ноль

 

  long int _MAPAPI mapPaintMapAndObjectToXImage(HMAP hMap, HOBJ hObj,

                                                 XIMAGEDESC * imagedesc,

                                                 long int x, long int y,

                                                 RECT * rect);

 

 // Вывести изображение карты в XImage (массив)               

 // hmap  - идентификатор открытых данных

 // imagedesc - параметры области для размещения изображения

 // Описание структуры XIMAGEDESC в maptype.h

 // erase - признак очистки области изображения (если равен -2, то изображение рисуется

  //         поверх имеющегося рисунка без очистки)

 // x,y - координаты левого верхнего угла внутри

 // битовой области XImage для размещения изображения

 // rect - фрагмент для вывода отображения

 // func - функция отображения объекта

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

 // data - метрика для отображения

 // colors - количество цветов

 // palette - палитра

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectByFuncDataToXImage(HMAP hMap, XIMAGEDESC *imagedesc,

                                                long int x, long int y,

                                                RECT *rect, long int func,

                                            const char *parm, POLYDATAEX* data,

                                      long int colors, COLORREF *palette);

 

_MAPIMP long int _MAPAPI  mapPaintExampleObjectByFuncDataToXImageEx(HMAP hMap, XIMAGEDESC * imagedesc,

                                                                    long int erase, long int x, long int y,RECT * rect,

                                                                    long int func, const char* parm, POLYDATAEX* data);

 

 

  // Вывести изображение карты в XImage (массив)                // 18/02/03

  // Данная функция реализована для XWindow !

  // Описание структуры XIMAGEDESC в maptype.h

  // rect - фрагмент для вывода отображения

  // func - функция отображения объекта

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

  // colors - количество цветов

  // palette - палитра

  // text - необходимый текст

  // local - локализация

  // При ошибке в параметрах возвращает ноль

  

_MAPIMP long int _MAPAPI mapPaintExampleObjectByFuncToXImage(HMAP hMap, XIMAGEDESC *imagedesc,

                                    RECT *rect, long int func, const char *parm,

                                    long int colors, COLORREF *palette,

                                    const char *text, long int local);

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectByFuncToXImageUn(HMAP hMap, XIMAGEDESC *imagedesc,

                                    RECT *rect, long int func, const char *parm,

                                       long int colors, COLORREF *palette,

                                      const WCHAR *text, long int local);

 

 

#ifdef WIN32API

 

 // Вывести изображение карты в метафайл

 // Данные функции реализованы только для платформы Windows !

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintToEmf(HMAP hMap, const char * name,

                                       METAFILEBUILDPARM * parm);

_MAPIMP long int _MAPAPI mapPaintToEmfUn(HMAP hMap, const WCHAR *name,

                                         METAFILEBUILDPARM *parm);

_MAPIMP long int _MAPAPI mapPaintToEmfEx(HMAP hMap, const char * name,

                                         METAFILEBUILDPARMEX * parm);

_MAPIMP long int _MAPAPI mapPaintToEmfExUn(HMAP hMap, const WCHAR *name,

                                           METAFILEBUILDPARMEX *parm);

 

#endif  // WIN32API

 

// Отобразить произвольный объект в пределах фрагмента

 // в условных знаках пользователя

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture).

 // image - описание вида объекта (см. MAPGDI.H),

 // data  - координаты объекта.

 // Координаты объекта заданы в соответствии с параметром place

 // С изображениями больше 32000х32000 работает только

 // под Windows NT (Windows 95 имеет 16-битовую графику)

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintUserObject(HMAP hmap,HDC hdc, RECT * rect,

                                            PAINTPARM * image, PLACEDATA * data,

                                            long int place/* = PP_MAP*/);

 

 // Отобразить произвольный объект в пределах фрагмента

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture).

 // image - описание вида объекта (см. MAPGDI.H),

 // data  - координаты объекта.

 // offset - смещение координат объекта (в соответствии с place)

 // Координаты объекта заданы в соответствии с параметром place

 // Корректно работает с большими изображениями под Windows95 и NT,

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP  long int _MAPAPI mapPaintOffsetUserObject95(HMAP hmap, HDC hdc,

                                                     RECT *rect, PAINTPARM *image,

                                                     PLACEDATA *data,

                                                     DOUBLEPOINT *offset,

                                                     long int place);

 

 // Отобразить произвольный объект в пределах фрагмента

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture),

 // image - описание вида объекта (см. MAPGDI.H),

 // data  - координаты объекта.

 // Координаты объекта заданы в соответствии с параметром place

 // Корректно работает с большими изображениями под Windows95 и NT,

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintUserObject95(HMAP hmap, HDC hdc,

                                              RECT *rect, PAINTPARM *image,

                                              PLACEDATA *data, long int place);

 

 // Отобразить образец вида объекта по номеру записи

 // в классификаторе объектов (incode)

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture),

 // Используется в диалогах выбора вида объекта

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObject(HMAP hmap, HDC hdc,

                                               RECT *rect, long int incode);

 

 // Отобразить образец вида объекта c учетом типа визуализации по

 // номеру записи в классификаторе объектов (incode)

 // Используется в диалогах выбора вида объекта

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture),

 // visualtype - тип визуализации

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectEx(HMAP hmap, HDC hdc, RECT *rect,

                                                 long int incode, long int visualtype);

 

// Отобразить образец вида объекта c учетом типа визуализации по      // 23/02/14

 // номеру записи в классификаторе объектов (incode)

 // Используется в диалогах выбора вида объекта

 // hmap - идентификатор открытых данных

 // hdc  - идентификатор контекста устройства вывода,

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture),

 // visualtype - тип визуализации (VT_SCREEN, VT_PRINT)

 // text - текст для отображения знака типа подпись

 // factor - процент изменения размера знака для отображения больших знаков

 //          в маленьких окошках (50 - сжать в 2 раза, 150 - увеличить в 1,5 раза)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectUn(HMAP hMap, HDC hdc,RECT* rect,

                                                 long int incode, long int visualtype,

                                                 const WCHAR * text, long int factor);

 

 // Отобразить образец вида объекта по номеру функции

 // hmap       - идентификатор открытых данных

 // hdc        - контекст устройства

 // rect       - область отображения

 // func       - номер функции

 // parm       - указатель на параметры функции

 // colors     - число цветов палитры

 // palette    - указатель на палитру

 // visualtype - тип визуализации

 // text       - текст всегда в кодировке WINDOWS, кроме функции IMG_TEXT

 //              (кодировка задана в параметрах структуры IMGTEXT)

 // Параметры colors, palette, visualtype, text - могут быть нулевыми :

 //  colors,palette - если в параметрах функции индексы палитры не используются;

 //  visualtype     - если отображение выполняется в текущем режиме визуализации;

 //  text           - при отображении стандартного текста ("AaBbCc").

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectFunc(HMAP hmap, HDC hdc, RECT rect, // 27/04/01

                                        long int func, char* parm,

                                        long int colors, COLORREF* palette,

                                        long int visualtype, char* text);

_MAPIMP long int _MAPAPI mapPaintExampleObjectFuncUn(HMAP hMap, HDC hdc, RECT rect,

                                                long int func, char* parm,

                                                long int colors, COLORREF* palette,

                                                     long int visualtype, const WCHAR *text);

 

// Отобразить образец вида объекта по номеру функции     // 09/02/16

 //  hdc        - контекст устройства

 //  rect       - область отображения

 //  func       - номер функции

 //  local      - локализация для задания вида метрики

 //  parm       - указатель на параметры функции

 //  colors     - число цветов палитры

 //  palette    - указатель на палитру

 //  visualtype - тип визуализации

 //  erase      - 0 - не стирать, 1 - стирать изображение

 //  factor - коэффициент увеличения образца ( по умолчанию 0.0)

 //  text       - текст всегда в кодировке WINDOWS, кроме функции IMG_TEXT

 //               (кодировка задана в параметрах структуры IMGTEXT)

 // Параметры colors, palette, visualtype, text - могут быть нулевыми :

 //  colors,palette - если в параметрах функции индексы палитры не используются;

 //  visualtype     - если отображение выполняется в текущем режиме визуализации;

 //  text           - при отображении стандартного текста ("AaBbCc").

 // При ошибке возвращает ноль

_MAPIMP long int _MAPAPI mapPaintExampleFunc(HMAP hMap, HDC hdc, RECT rect,

                                      long int func, const char * parm,

                                      long int colors, COLORREF* palette,

                                      long int visualtype, const WCHAR * text,

                                      long int local,HRSC hRsc, long int erase);

 

 // Отобразить образец вида объекта по заданной метрике

 // в реальных цветах (с интенсивностью заливки - 100%)

 // hmap       - идентификатор открытых данных,

 // hdc        - контекст устройства

 // rect       - область отображения

 // func       - номер функции

 // parm       - указатель на параметры функции

 // data       - метрика изображения в точках устройства вывода

 // colors     - число цветов палитры

 // palette    - указатель на палитру

 // visualtype - тип визуализации

 // text - текст всегда в кодировке WINDOWS

 //        (если data != 0, то text игнорируется)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPaintExampleObjectRealByFuncData(HMAP hmap, HDC hdc, RECT* rect,

                                        long int func, char* parm, POLYDATA* data,

                                        long int colors, COLORREF* palette,

                                        long int visualtype, char* text);

_MAPIMP long int _MAPAPI mapPaintExampleObjectRealByFuncDataUn(HMAP hMap, HDC hdc, RECT* rect,

                                                               long int func, const char* parm, POLYDATA* data,

                                                               long int colors, COLORREF* palette,

                                                               long int visualtype, const WCHAR *text);

 

 // Выделить на карте объекты, удовлетворяющие заданным условиям

 // hmap   - идентификатор открытых данных

 // hdc    - контекст устройства

 // rect   - область отображения

 // select - условия отбора объектов

 // color  - цвет, которым будут выделяться объекты на карте

 // Максимальный размер картинки, равен разрешению экрана (рабочего стола)

 

_MAPIMP void _MAPAPI mapPaintSelect95(HMAP hmap, HDC hdc, RECT* rect,

                                      HSELECT select, COLORREF color);

 

 // Установить/Запросить способ выделения площадных и линейных

 // объектов на карте

 // type - способ выделения (STF_CONTOUR - контур объекта,

 // STF_OBJECT - весь объект)

 // Возвращает значение, которое было ранее установлено

 

_MAPIMP long int _MAPAPI mapSetSelectType(long int type);

_MAPIMP long int _MAPAPI mapGetSelectType();

 

#ifndef LINUXAPI

 

#ifdef WIN32API          // 06/06/17 Савелов

 // Отобразить фрагмент карты на заданном устройстве с учетом калибровки

 // в текущих масштабе и составе объектов

 // hmap   - идентификатор открытых данных

 // rect - координаты фрагмента карты (Draw) в изображении (Picture)

 // parm - параметры печати, указатель на PRINTPARM (см. prnapi.h)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPrint(HMAP hmap, HDC hDC, RECT *rect, const char *parm);

#endif

 

 // Установить пошаговый вывод DIB в окно            

 // flag - признак вывода промежуточных изображений в контекст вывода (0 или 1),

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

 //        иначе - картинка выдается три раза в секунду пока формируется изображение

 // Возвращает предыдущее значение

 

_MAPIMP long int _MAPAPI mapSetPaintStepEx(HMAP hmap, long int millisec);

 

 // Запросить значение пошагового вывода DIB в окно

 // Возвращает признак вывода промежуточных изображений в контекст вывода

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

 // Если hmap равно нулю, то возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetPaintStepEx(HMAP hmap);

 

 

 // Установить режим качественного отображения подписей      

 // для строгого соблюдения размеров подписи при печати

 // flag - ненулевое значение устанавливает режим качественного вывода

 //        (при этом время отображения отдельной подписи увеличивается

 //         примерно в 2 раза)

 // Возвращает предыдущее значение

 

_MAPIMP long int _MAPAPI mapSetTextQuality(long int flag);

 

 // Запросить режим качественного отображения подписей      

 // для строгого соблюдения размеров подписи при печати

 

_MAPIMP long int _MAPAPI mapGetTextQuality();

 

 

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

  *                                                        *

  *      ФУНКЦИИ ОТОБРАЖЕНИЯ И ПЕЧАТИ ЭЛЕКТРОННОЙ КАРТЫ    *

  *   ЗАДАН ИДЕНТИФИКАТОР ОКНА, И ПОЗИЦИЯ ФРАГМЕНТА ВЫВОДА *

  *                ЭЛЕКТРОННОЙ КАРТЫ В ОКНЕ                *

  *                                                        *

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

 

 // Выделить на карте объекты, удовлетворющие заданным условим

 // hmap   - идентификатор открытых данных

 // hwnd   - идентификатор окна вывода

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // select - условия отбора объектов,

 // color  - цвет, которым будут выделяться объекты на карте

 

_MAPIMP void _MAPAPI mapViewSelect(HMAP hmap, HWND hwnd, DOUBLEPOINT *point,

                                   HSELECT select, COLORREF color,

                                   long int place);

 

// Установить/Запросить выделение объектов на карте с разрядкой     // 29/07/14

 // hmap - идентификатор открытых данных

 // flag - признак отображения выделенных объектов с разрядкой,

 // позволяет отображать выделенные объекты выборочно, когда

 // выделяются тысячи объектов

 // Возвращает установленное значение

 

_MAPIMP long int _MAPAPI mapSetLiteSelect(HMAP hmap, long int flag);

_MAPIMP long int _MAPAPI mapGetLiteSelect(HMAP hmap);

 

 // Отобразить фрагмент карты в клиентной области окна

 // в текущих масштабе и составе объектов

 // erase - признак стирания фона перед выводом,

 // (0 - фон не стирать, !=0 - очистить фрагмент цветом фона),

 // point - координаты верхнего левого угла фрагмента

 // в соответсвующей параметру place системе координат

 

_MAPIMP void _MAPAPI mapView(HMAP hmap, HWND hwnd, long int erase,

                             DOUBLEPOINT *point, long int place);

 

#ifdef WIN32API                                              

 

 // Отобразить фрагмент карты в клиентной области окна       

 // в текущих масштабе и составе объектов

 // hMap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // erase - признак стирания фона перед выводом,

 // (0 - фон не стирать, !=0 - очистить фрагмент цветом фона),

 // rect - координаты фрагмента карты (Draw)

 // в изображении (Picture),

 // point - смещение фрагмента в отображаемом окне

 

_MAPIMP void _MAPAPI mapViewEx(HMAP hmap, HWND hwnd, long int erase,

                               RECT * rect, POINT * point);

 #endif  // WIN32API

 

 // Отобразить произвольный объект в пределах

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

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // info - идентификатор объекта карты в памяти

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewObject(HMAP hmap, HWND hwnd,

                                       DOUBLEPOINT *point,

                                       HOBJ info, long int place);

 

 // Отобразить существующий объект карты в пределах фрагмента окна (карты)    

 // в условных знаках пользователя

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // image - описание вида объекта (см. MAPGDI.H), если объект

 // должен рисоваться своим условным знаком - значение параметра

 // можно установить в ноль,

 // info - идентификатор объекта карты в памяти

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewMapObject(HMAP hmap, HWND hwnd,

                                          DOUBLEPOINT *point,

                                          PAINTPARM *image,

                                          HOBJ info, long int place);

 

 // Отобразить существующий объект карты в пределах фрагмента окна (карты)    

 // в условных знаках пользователя

 // hmap   - идентификатор открытых данных

 // image - описание вида объекта (см. MAPGDI.H), если объект

 // должен рисоваться своим условным знаком - значение параметра

 // можно установить в ноль,

 // info - идентификатор объекта карты в памяти

 // offset - смещение координат объекта (в соответствии с place)

 // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewOffsetMapObject(HMAP hmap, HWND hwnd,

                                                DOUBLEPOINT *point,

                                                PAINTPARM *image,

                                                HOBJ info, DOUBLEPOINT *offset,

                                                long int place);

 

  // Отобразить произвольный объект в пределах фрагмента окна (карты)

  // hmap   - идентификатор открытых данных

  // hwnd  - идентификатор окна,

  // point - координаты верхнего левого угла окна на карте

  // в соответсвующей параметру place системе координат

  // image - описание вида объекта (см. MAPGDI.H),

  // data  - координаты объекта.

  // offset - смещение координат объекта (в соответствии с place)

  // Координаты объекта заданы в соответствии с параметром place

 

_MAPIMP long int _MAPAPI mapViewOffsetUserObject(HMAP hmap, HWND hwnd,

                                                 DOUBLEPOINT *point,

                                                 PAINTPARM *image,

                                                 PLACEDATA *data,

                                                 DOUBLEPOINT *offset,

                                                 long int place);

 

 // Отобразить произвольный объект в пределах фрагмента окна (карты)

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // image - описание вида объекта (см. MAPGDI.H),

 // data  - координаты объекта.

 // Координаты объекта заданы в соответствии с параметром place

 

_MAPIMP long int _MAPAPI mapViewUserObject(HMAP hmap,HWND hwnd,

                                     DOUBLEPOINT * point,

                                     PAINTPARM * image,

                                     PLACEDATA * data,

                                     long int place);

 

 // Отобразить курсор в виде перекрестья в заданной точке    

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте в пикселах

 // linethick - толщина линии курсора в пикселах (рекомендуется 1 - 2)

 // size  - размер курсора (обычно 16 или 32 - в зависимости от экрана)

 // x,y   - координаты центра курсора (соответсвуют place)

 

_MAPIMP void _MAPAPI mapViewMarkerEx(HMAP hMap, HWND hwnd, POINT * point,

                                     long int linethick, long int size,

                                     long int x, long int  y);

 

 // Отобразить курсор в виде перекрестья в заданной точке

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // linethick - толщина линии курсора в пикселах (рекомендуется 1 - 2)

 // x,y   - координаты центра курсора (соответсвуют place)

 

_MAPIMP  void _MAPAPI mapViewMarker(HMAP hMap, HWND hwnd, DOUBLEPOINT *point,

                                   long int linethick, double x, double y,

                                   long int place);

 

 // Отобразить линию в виде заданного примитива            // 21/04/09

 // hmap   - идентификатор открытых данных

 // hwnd  - идентификатор окна,

 // point - координаты верхнего левого угла окна на карте

 // в соответсвующей параметру place системе координат

 // image - описание вида объекта (см. MAPGDI.H),

 // first - координаты первой точки,

 // second - координаты второй точки.

 

_MAPIMP  void _MAPAPI mapViewUserLine(HMAP hMap, HWND hwnd, DOUBLEPOINT *point,

                                      PAINTPARM *image, DOUBLEPOINT *first,

                                      DOUBLEPOINT *second, long int place);

 

 

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

  *                                                        *

  *        ФУНКЦИИ УПРАВЛЕНИЯ ПРОЦЕССОМ ОТОБРАЖЕНИЯ        *

  *                                                        *

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

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

  // вызываться при построении изображения карты и выводе

  // его в заданный контекст отображения

  // Устанавливать адрес рекомендуется перед каждым вызовом Paint,

  // а по окончании отрисовки карты - отключать

  // (устанавливать нулевой адрес).

  // Вызываемая функция не должна сама вызывать Paint !

  // call - адрес вызываемой функции (см. maptype.h),

  // parm - параметр, который будет передан вызываемой функции.

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

  // перерисовки карты (0/1) для ее пошагового обновления на экране

  // Если вызываемая функция вернет ненулевое значение, то

  // процесс отображения будет прерван (например, при анализе

  // очереди сообщений вызванной функцией найден ввод с

  // клавиатуры команды Esc, функция возвращает 1, отображение

  // прерывается).

 

_MAPIMP void _MAPAPI mapSetBreakCallAndParmEx(HMAP hMap, BREAKCALLEX call,

                                              void * parm);

 

  // Установить адрес функции, которая будет вызываться

  // перед формированием изображения карты в области

  // памяти или перед началом отображения карты на экран.

  // Вызываемая функция не должна сама вызывать Paint !

  // hmap   - идентификатор открытых данных

  // call - адрес вызываемой функции (см. maptype.h),

  // parm - параметр, который будет передан вызываемой функции.

  // В вызываемой функции можно рисовать "под картой"

  // с применением графических функций системы или функций

  // типа PaintUserObject.

 

_MAPIMP void _MAPAPI mapSetBeforePaintCallAndParm(HMAP hmap, BEFOREPAINT call,

                                                  void *parm);   

 

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

  // вызываться при построении изображения карты и выводе

  // его на экран.

  // Устаревшая функция. Обратный вызов выполняется только после

  // отрисовки некоторого числа объектов, заданного функцией

  // mapSetPaintStep, или других данных (матриц, растров).

  // Позволяет прервать изображение карты,

  // сменить параметры отображения (масштаб, позиция карты...)

  // и запустить новый процесс отображения. Устанавливать

  // адрес рекомендуется перед каждым вызовом Paint,

  // а по окончании отрисовки карты - отключать

  // (устанавливать нулевой адрес).

  // Вызываемая функция не должна сама вызывать Paint !

  // hmap   - идентификатор открытых данных

  // call - адрес вызываемой функции (см. maptype.h),

  // parm - параметр, который будет передан вызываемой функции.

  // Если вызываемая функция вернет ненулевое значение, то

  // процесс отображения будет прерван (например, при анализе

  // очереди сообщений вызванной функцией найден ввод с

  // клавиатуры команды Esc, функция возвращает 1, отображение

  // прерывается).

 

_MAPIMP void _MAPAPI mapSetBreakCallAndParm(HMAP hmap, BREAKCALL call,

                                            void * parm);        

 

 

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

  *                                                        *

  *     ФУНКЦИИ НАСТРОЙКИ ОТОБРАЖЕНИЯ ЭЛЕКТРОННОЙ КАРТЫ    *

  *                     С ПОВОРОТОМ                        *

  *                                                        *

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

 

 // Функция настройки отображения карты с поворотом

 //  hmap     - идентификатор открытых данных

 //  angle    - угол поворота карты в плане с вершиной в

 //             юго-западном углу карты (от -Pi до Pi)

 //  fixation - угол сектора фиксации поворота отображения карты

 //             относительно предыдущего положения (от 0 до Pi/6).

 //             По умолчанию = Pi/18 (10 градусов)

 // Угол fixation используется для минимизации дрожания изображения

 // при движении по повернутой карте по прямой (или почти по прямой),

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

 // значения угла поворота (angle). В случае, если разность между

 // текущим углом поворота и требуемым будет меньше fixation,

 // то новый угол поворота не устанавливается.

 // Возвращает значение установленного угла поворота.

 // При ошибке возвращает 0

 

_MAPIMP double _MAPAPI mapSetupTurn(HMAP hmap, double angle, double fixation);

 

 // Активен ли поворот ?

 // hmap - идентификатор открытых данных

 // Возвращает (1 - активен, 0 - нет)

 

_MAPIMP long int _MAPAPI mapTurnIsActive(HMAP hmap);

 

 // Запросить угол поворота

 // hmap - идентификатор открытых данных

 // Возвращает значения от -Pi до Pi

 

_MAPIMP double _MAPAPI mapGetTurnAngle(HMAP hmap);

 

 

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

  *                                                        *

  *    ФУНКЦИИ УПРАВЛЕНИЯ ОТОБРАЖЕНИЕМ ЭЛЕКТРОННОЙ КАРТЫ   *

  *                                                        *

  *    ПРИ ИЗМЕНЕНИИ МАСШТАБА ОТОБРАЖЕНИЯ АВТОМАТИЧЕСКИ    *

  *       ИЗМЕНЯЮТСЯ ГАБАРИТЫ ИЗОБРАЖЕНИЯ В ПИКСЕЛАХ !     *

  *                                                        *

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

 

  // Установить масштаб отображения (знаменатель масштаба)

  //  Параметры:

  //          hmap - идентификатор открытых данных

  //          x, y - координаты предполагаемого "центра изображения"

  //                 (любой точки привязки) в окне в текущем масштабе

  //         scale - реальный масштаб отображения, который желают получить

  //  Возвращает:   0 - масштаб не изменился,  1 - масштаб изменился

  //          x, y - координаты предполагаемого "центра изображения"

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

  //                 в новом масштабе отображения

 

_MAPIMP long int _MAPAPI mapSetViewScale(HMAP hmap, long int *x,

                                         long int *y, float scale);

 

  // Изменить масштаб отображения относительно текущего

  //  Параметры:

  //          hmap - идентификатор открытых данных

  //          x, y - координаты предполагаемого "центра изображения"

  //                 (любой точки привязки) в окне в текущем масштабе

  //        change - коэффициент изменения текущего масштаба изображения

  //                 0 < change < 1 , для сжатия

  //                 1 < change < N , для увеличения

  //  Возвращает:   0 - масштаб не изменился,  1 - масштаб изменился

  //          x, y - координаты предполагаемого "центра изображения"

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

  //                 в новом масштабе отображения

 

_MAPIMP long int _MAPAPI mapChangeViewScale(HMAP hmap,long int * x,

                                            long int * y,float change);

 

  // Запросить округленный масштаб отображения карты

  // hmap - идентификатор открытых данных

  // Возвращает значение знаменателя масштаба

 

_MAPIMP long int _MAPAPI mapGetShowScale(HMAP hmap);

 

  // Запросить точный масштаб отображения карты

  // hmap - идентификатор открытых данных

  // Возвращает значение знаменателя масштаба

 

_MAPIMP double _MAPAPI mapGetRealShowScale(HMAP hmap);

 

  // Установить точный масштаб отображения карты         

  // Возвращает значение знаменателя масштаба

 

_MAPIMP double _MAPAPI mapSetRealShowScale(HMAP hMap, double scale);

 

  // Запросить текущий коэффициент масштабирования карты

  // Например: 5 - растянута в 5 раз относительно базового масштаба,

  //         0.1 - сжата в 10 раз.

 

_MAPIMP double _MAPAPI mapGetDrawScale(HMAP hmap);

 

// Подобрать "стандартный" масштаб, ближайший к заданному (scale)

 

_MAPIMP long int _MAPAPI mapScaleToRoundScale(double scale);

 

// Подобрать "стандартный" масштаб, ближайший к заданному (scale)

// С учетом состава карты (для открытых данных WMST могут быть

// другие стандартные масштабы)

// hmap - идентификатор открытых данных

// Возвращает новое значение знаменателя масштаба

 

_MAPIMP long int _MAPAPI mapScaleToRoundScaleEx(HMAP hmap, double scale);  

 

  // Подобрать "стандартный" реальный масштаб, ближайший к заданному (scale)

 // с учетом состава карты (для открытых данных WMTS могут быть

 // другие стандартные масштабы)

 // hmap - идентификатор открытых данных

 // Возвращает новое реальное (неокругленное) значение знаменателя масштаба

 

_MAPIMP double _MAPAPI mapScaleToRoundScaleReal(HMAP hmap, double scale);   // 12/11/15

 

// Запросить количество "стандартных" масштабов          

 

_MAPIMP long int _MAPAPI mapScaleTableCount();

 

 // Запросить элемент таблицы "стандартных" масштабов по порядковому

 // номеру в таблице(с 1)

 

_MAPIMP long int _MAPAPI mapScaleTableItem(long int number);

 

  // Установить способ масштабирования объектов карты при отображении

  // method - способ масштабирования

  // (0 - картографический "с запаздыванием увеличения",

  //  1 - чертежный)

  // Возвращает ранее установленное значение

 

_MAPIMP long int _MAPAPI mapSetScaleMethod(long int method);

_MAPIMP long int _MAPAPI mapGetScaleMethod();

 

  // Пересчитать общие габариты района работ         

  // hmap - идентификатор открытых данных

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetRegion(HMAP hMap);

 

  // Запросить состав отображаемых объектов

  // hmap - идентификатор открытых данных

  // select - идентификатор контекста поиска/отображения

  // в который будут помещены текущие условия отображения

  // см. mapCreateMapSelectContext(...)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetViewSelect(HMAP hmap,HSELECT select);

 

  // Установить состав отображаемых объектов

  // hmap - идентификатор открытых данных

  // select - идентификатор устанавливаемого контекста поиска/отображения

 

_MAPIMP void _MAPAPI mapSetViewSelect(HMAP hmap,HSELECT select);

 

  // Запросить/Установить цвет фона отображаемой карты

  // hmap - идентификатор открытых данных

  // color - цвет фона

  // При изменении цвета фона необходимо перерисовать весь экран

  // При ошибке возвращает 0x0FFFFFF (белый)

 

_MAPIMP COLORREF _MAPAPI mapGetBackColor(HMAP hmap);

 

_MAPIMP COLORREF _MAPAPI mapSetBackColor(HMAP hmap,COLORREF color);

 

  // Запросить/Установить цвет фона отображаемой карты          

  // при выводе в принтерном режиме на экран

  // При изменении цвета фона необходимо перерисовать весь экран

  // При ошибке возвращает 0x0FFFFFF (белый)

 

_MAPIMP COLORREF _MAPAPI mapGetBackPrintColor(HMAP hmap);

 

_MAPIMP COLORREF _MAPAPI mapSetBackPrintColor(HMAP hmap, COLORREF color);

 

  // Запросить/Установить способ отображения карты

  // hmap - идентификатор открытых данных

  // При установке нового способа отображения возвращается

  // предыдущее значение

  // (см. Maptype.h : VT_SCREEN(1), VT_PRINT(3), VT_PRINTRST(6),...)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetViewType(HMAP hmap);

_MAPIMP long int _MAPAPI mapSetViewType(HMAP hmap, long int type);

 

  // Запросить яркость карты (от -16 до +16)

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapGetBright(HMAP hmap);

 

  // Установить яркость карты (от -16 до +16)

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapSetBright(HMAP hmap, long int bright);

 

  // Запросить контрастность (от -16 до +16)

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapGetContrast(HMAP hmap);

 

  // Установить контрастность (от -16 до +16)

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapSetContrast(HMAP hmap, long int contrast);

 

  // Запросить интенсивность заливки площадей полигонов для      

  // принтерного отображения (от 0 до 100)

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapGetIntensity(HMAP hmap);

 

  // Установить интенсивность заливки площадей полигонов для

  // принтерного отображения (от 0 до 100)

  // Если mapGetTransparentSquare возвращает 0, то значения интенсивности

  // соответствуют расслаблению цветов (кроме черного):

  //   0 - заливок нет, 50 - полурасслабленные цвета, 100 - нормальные цвета

  // Если mapGetTransparentSquare возвращает 1, то значения интенсивности

  // соответствуют степени непрозрачности цветов:

  //   0 - заливок нет, 50 - полупрозрачные заливки, 100 - нормальные цвета

  // hmap - идентификатор открытых данных

 

_MAPIMP long int _MAPAPI mapSetIntensity(HMAP hmap, long int intensity);

 

  // Запросить флаг прозрачности заливки площадей полигонов

  // hMap  - идентификатор открытой карты

  // Возвращает значение флага

 

_MAPIMP long int _MAPAPI mapGetTransparentSquare(HMAP hMap);   // 21/06/16

 

  // Установить флаг прозрачности заливки площадей полигонов

  // Степень прозрачности устанавливается функцией mapSetIntensity

  // hMap  - идентификатор открытой карты

  // flag  - признак прозрачности:

  //         0 - прозрачность отключена (заливки сплошным цветом),

  //             использовать при обычном отображении или печати карты;

  //             в принтерных режимах (VT_PRINT, VT_PRINTRST)

  //         1 - прозрачность включена (заливки в виде цветного стекла),

  //             использовать при отображении или печати карты поверх растров

  //             в принтерном растровом режиме (VT_PRINTRST)

 

_MAPIMP long int _MAPAPI mapSetTransparentSquare(HMAP hMap, long int flag);

 

  // Выдать вид отображения карты         

  // 1 - с узлами, 0 - без узлов

 

_MAPIMP long int _MAPAPI mapGetNodeView(HMAP hMap);

 

  // Установить отображение узлов на карте

  // 0 - не отображать, 1 - отображать

 

_MAPIMP void _MAPAPI mapSetNodeView(HMAP hMap, long int mode);

 

 

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

  *                                                        *

  *          ФОРМИРОВАНИЕ БУФЕРА ОКНА КАРТЫ                *

  *                                                        *

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

 

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

  // перемещаемых по карте объектов

  // width  - ширина клиентской части окна карты в точках,

  // height - высота клиентской части окна карты в точках.

  // Создается первый буфер экрана, второй создается при первом вызове

  // функции отображения объекта в буфер (Draw) -  для оптимального

  // применения функций при отображении карты и без перемещаемых объектов

  // Размер буфера =  (width * height * 4)

  // Всего может быть параллельно открыто до 256 образов экранов одновременно

  // Может применяться в паре с функцией mapChangeImageSizeEx

  // При успешном выполнении возвращает идентификатор образа экрана

  // При ошибке возвращает ноль

 

_MAPIMP HIMAGE _MAPAPI mapCreateImageEx(long int width, long int height);

 

  // Создание буфера окна

  // hwnd - идентификатор окна, для определения размеров клиентской области

  // Может применяться в паре с функцией mapChangeImageSize

  // При ошибке возвращает ноль

 

_MAPIMP HIMAGE _MAPAPI mapCreateImage(HWND hwnd);

 

  // Удалить буфер окна

  // himage - идентификатор буфера окна

 

_MAPIMP void _MAPAPI mapCloseImage(HIMAGE image);

 

  // Запросить контекст буфера окна

  // himage - идентификатор буфера окна

  // При ошибке возвращает ноль

 

_MAPIMP HDC _MAPAPI mapGetImageDC(HIMAGE image);

 

  // Запросить контекст буфера окна для отображения объектов

  // himage - идентификатор буфера окна

  // При ошибке возвращает ноль

 

_MAPIMP HDC _MAPAPI mapGetImageObjectDC(HIMAGE image);

 

  // Запросить размеры буфера экрана

  // При ошибке во входные параметрах возвращает ноль

 

_MAPIMP int _MAPAPI mapGetImageWidth(HIMAGE image);          // 06/06/17 Савелов

_MAPIMP int _MAPAPI mapGetImageHeight(HIMAGE image);

 

  // Получить указатель на выделенную память буфера экрана

  // При ошибке во входных параметрах возвращает ноль

 

_MAPIMP char* _MAPAPI mapGetImageMapScreenMemory(HIMAGE image);

 

  // Отобразить выделение в буфере карты и образе экрана

  // hScreen  - идентификатор образа экрана,

  // hMap     - идентификатор карты,

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

  //            системе координат полного изображения карты (PICTURE),

  // position - положение верхнего левого угла фрагмента в клиентской

  //            области окна карты (и образа экрана),

  // select   - идентификатор контекста выделения,

  // onlymap  - 1 - обновить только буфер карты, 0 - обновить оба буфера

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageSelect(HIMAGE image, HMAP hMap, RECT * rect,

                                 POINT * position, HSELECT select, COLORREF color,

                                 int onlymap);

 

  // Отобразить содержимое буфера окна в заданный контекст

  // himage - идентификатор буфера окна

  // hdc - контекст области отображения (окна),

  // rect - координаты область отображения в буфере и контексте

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewImage(HIMAGE image, HDC hdc, RECT * rect);

 

  // Отобразить содержимое буфера окна в заданный контекст      

  // himage - идентификатор буфера окна

  // hwnd - идентификатор окна, в которое выводится изображение,

  // rect - координаты область отображения в буфере и контексте

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewImageEx(HIMAGE image, HWND hwnd, RECT * rect);

 

  // Отобразить содержимое буфера окна в заданный контекст со смещением   

  // himage - идентификатор буфера окна

  // hwnd - идентификатор окна, в которое выводится изображение,

  // rect - координаты область отображения в буфере и контексте

  // offset - смещение изображения в окне

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewImageExOffset(HIMAGE himage, HWND hwnd,

                                              RECT *rect, POINT *offset);

 

  // Сместить изображение карты во вспомогательном буфере

  // himage - идентификатор буфера окна

  // offset - смещение изображения в окне

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapViewImageOffset(HIMAGE himage, POINT * offset);

 

  // Обновить размеры буфера окна

  // himage - идентификатор буфера окна

  // erase  - признак очистки окна, если равен 0 - содержимое сохраняется

  // width  - новая ширина буфера

  // height - новая высота буфера

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapChangeImageSizeEx(HIMAGE image, long int erase,

                                              long int width, long int height);

 

  // Обновить размеры буфера окна

  // himage - идентификатор буфера окна

  // Срабатывает правильно только, если буфер создан через mapCreateImage(HWND hwnd);

  // Содержимое буфера теряется !

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapChangeImageSize(HIMAGE image);

 

  // Скроллинг буфера окна                        

  // himage - идентификатор буфера окна

  // dx     - величина смещения окна по горизонтали (> 0 - слева направо,

  //                                                 < 0 - справа налево)

  // dy     - величина смещения окна по вертикали   (> 0 - сверху вниз,

  //                                                 < 0 - снизу вверх)

  // onlymap - признак обновления только буфера карты (оптимизация скорости отрисовки

  //           при дальнейшем вызове mapClearImageObjects)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapScrollImageEx(HIMAGE himage, long int dx, long int dy, long int onlymap);

 

_MAPIMP long int _MAPAPI mapScrollImage(HIMAGE himage, long int dx, long int dy);

 

  // Обновить изображение заданного фрагмента карты в образе экрана

  // После обновления карты изображение перемещаемых объектов стирается

  // в пределах заданного фрагмента (но для стирания объектов текущим

  // видом карты достаточно вызвать mapClearImageObjects).

  // himage  - идентификатор буфера окна

  // hMap     - идентификатор открытых данных

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

  //            системе координат полного изображения карты (PICTURE)

  // position - положение верхнего левого угла фрагмента в клиентской

  //            области окна карты (и образа экрана)

  // onlymap - признак обновления только буфера карты (оптимизация скорости отрисовки

  //           при дальнейшем вызове mapClearImageObjects)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageMapEx(HIMAGE himage, HMAP hMap, RECT * rect,

                                           POINT * position, long int onlymap);

 

_MAPIMP long int _MAPAPI mapDrawImageMap(HIMAGE image, HMAP hMap, RECT * rect,

                                         POINT * position);

 

  // Обновить изображение заданного фрагмента карты в образе экрана     

  // После обновления карты изображение перемещаемых объектов стирается

  // в пределах фрагмента, заданного габаритами объекта

  // himage  - идентификатор буфера окна

  // object  - идентификатор объекта, в пределах габаритов которого будет обновлена карта

  // onlymap - признак обновления только буфера карты (оптимизация скорости отрисовки

  //           при дальнейшем вызове mapClearImageObjects)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapReDrawImageMapExUnderObject(HIMAGE himage, HMAP hMap,

                                                        HOBJ object, long int onlymap);

 

  // Отобразить объект поверх карты местности в образе экрана

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageMapObject(HIMAGE image, HMAP hMap,

                                               PAINTPARM * parm, HOBJ object);

 

  // Отобразить объект поверх карты местности в образе экрана c учетом

  // заданного сдвига метрики

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageOffsetMapObject(HIMAGE image, HMAP hMap,

                                                     DOUBLEPOINT * offset,

                                                     PAINTPARM * parm, HOBJ object);

 

  // Отобразить объект поверх карты местности в образе экрана

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageUserObject(HIMAGE image, HMAP hMap,

                                                PAINTPARM * parm,

                                                PLACEDATA * data,

                                                long int place);

 

  // Отобразить объект поверх карты местности в образе экрана c учетом

  // заданного сдвига метрики

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageOffsetUserObject(HIMAGE image, HMAP hMap,

                                                      DOUBLEPOINT * offset,

                                                      PAINTPARM * parm,

                                                      PLACEDATA * data,

                                                      long int place);

 

  // Отобразить графические данные                   

  // hScreen  - идентификатор образа экрана,

  // points   - координаты в пикселах

  // count    - число координат

  // image    - тип графического примитива (см. mapgdi.h)

  // parm     - параметры графического примитива

 

_MAPIMP long int _MAPAPI mapDrawImageGraphics(HIMAGE image, HMAP hMap,

                                              DRAWPOINT * points, long int count,

                                              long int type, const char * parm);

 

  // Отобразить текстовую строку (Arial)

  // image    - идентификатор образа экрана,

  // points   - координаты в пикселах

  // count    - число координат

  // text     - текст подписи

  // height   - высота подписи в мкм

  // color    - цвет подписи RGB

  // align    - флажки выравнивания текста (для -1 - FA_BASELINE|FA_LEFT)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageText(HIMAGE image, HMAP hMap,

                                          DRAWPOINT * points, long int count,

                                         const char * text, long int height,

                                          long int color, long int align);

_MAPIMP long int _MAPAPI mapDrawImageTextUn(HIMAGE image, HMAP hMap,

                                            DRAWPOINT *points, long int count,

                                            const WCHAR *text, long int height,

                                            long int color, long int align);

 

  // Отобразить BMP в образ экрана             

  // image     - идентификатор образа экрана,

  // point     - координаты в пикселах,

  // bmpmemory - адрес массива байт, содержащего образ BMP-файла

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDrawImageBitMap(HIMAGE image, HMAP hMap,

                                            DRAWPOINT * point,

                                            const char * bmpmemory,

                                            long int transparent);

 

  // Стереть изображение объектов на заданном фрагменте образа

  // экрана (используется копия фона карты в отдельном буфере)

  // При ошибке возвращает ноль

 

_MAPIMP void _MAPAPI mapClearImageObjects(HIMAGE image, RECT * rect);

 

  // Очистить буфер окна

 // При ошибке во входных параметрах возвращает ноль

 

_MAPIMP int _MAPAPI mapClearMapScreen(HIMAGE image);          // 06/06/17 Савелов

 

#ifdef WIN32API

 

  // Создать BITMAP с помощью функции CreateDIBSection

  // Размер элемента - 4 байта

  // hdc    - произвольный контекст

  // width  - ширина изображения

  // height - высота изображения

  // memory - адрес изображения в памяти

  // При ошибке возвращает ноль

 

_MAPIMP HBITMAP _MAPAPI mapCreateBitmap(HDC hdc, long int width, long int height,

                                        void ** memory);

 

_MAPIMP HBITMAP _MAPAPI mapCreateBitmapEx(long int width, long int height);

 

  // Удалить BITMAP, созданный mapCreateBitmap

 

_MAPIMP void _MAPAPI mapCloseBitmap(HBITMAP hbitmap);

 

  // Отрисовать карту в Bitmap

  // Размер изображения не больше размеров экрана

  // Для увеличения размеров отрисовываемого изображения

  // (до разумных размеров) можно вызвать mapSetMaxScreenImageSize ()

  // erase - признак стирания фона перед выводом,

  //        (0 - фон не стирать, !=0 - очистить фрагмент цветом фона,

  //        для экранного способа вывода (VT_SCREEN) всегда стирает

  //        цветом фона, кроме значения -2 (минус 2))

  // rect - координаты фрагмента карты (Draw) в изображении (Picture)

  // При ошибке в параметрах возвращает 0

 

_MAPIMP long int _MAPAPI mapPaintToBitmap(HMAP hmap, HBITMAP hbitmap, int erase,

                                          RECT *rect);

  // Сохранить изображение с заданного контекста в файл BMP

  // Данная функция реализована только для платформы Windows !

  // hdc     - контекст устройства

  // rect    - размер сохраняемой области

  // bmpname - имя создаваемого файла BMP, 32 бита на пиксел

  // При ошибке в параметрах возвращает ноль

 

_MAPIMP long int _MAPAPI mapSaveImageToBMP(HDC hdc, RECT *rect, const char *bmpname);

_MAPIMP long int _MAPAPI mapSaveImageToBMPUn(HDC hdc, RECT *rect, const WCHAR *bmpname);

 

  // Считать изображение из файла BMP

  // rect    - размер считанной области

  // bmpname - имя считываемого файла BMP, 32 бита на пиксел

  // При ошибке в параметрах возвращает ноль

 

_MAPIMP HBITMAP _MAPAPI mapLoadFromBMP(RECT * rect, const char *bmpname);

_MAPIMP HBITMAP _MAPAPI mapLoadFromBMPUn(RECT *rect, const WCHAR *bmpname);

 

#endif

 

 

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

  *                                                        *

  *          ОТОБРАЖЕНИЕ СЕТКИ НА ИЗОБРАЖЕНИИ КАРТЫ        *

  *                                                        *

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

 

  // Запросить признак отображения сетки

  // hmap - идентификатор открытых данных

  // Если отображение сетки включено - возвращает ненулевое значение

  // 1 - отображение над картой, -1 - отображение под картой

  // Если сетка не отображается - возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsGridActive(HMAP hmap);

 

  // Установить признак отображения сетки

  // hmap - идентификатор открытых данных

  // 1 - отображение над картой, -1 - отображение под картой

  // Если сетка не отображается - возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetGridActive(HMAP hmap, long int active);

 

  // Запросить текущий шаг сетки

  // hmap - идентификатор открытых данных

  // Текущее значение может изменяться с учетом масштаба

  // предыдущего отображения документа

  // (маленькие ячейки меньше 8 пикселов, кратно увеличиваются)

 

_MAPIMP double _MAPAPI mapGetGridStep(HMAP hmap);

 

  // Запросить параметры сетки

  // hmap - идентификатор открытых данных

  // parm - указатель на область размещения результата

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetGridParm(HMAP hmap, GRIDPARM * parm);

_MAPIMP long int _MAPAPI mapGetGridParmEx(HMAP hmap, GRIDPARMEX *parm);

 

  // Установить параметры сетки

  // hmap - идентификатор открытых данных

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

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetGridParm(HMAP hmap, GRIDPARM * parm);

_MAPIMP long int _MAPAPI mapSetGridParmEx(HMAP hmap, GRIDPARMEX *parm);

 

 

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

  *                                                        *

  *       ФУНКЦИИ ЗАПРОСА ИНФОРМАЦИИ О ВЕКТОРНОЙ КАРТЕ     *

  *                                                        *

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

 

  // Запросить базовый масштаб карты

  // hmap - идентификатор открытых данных

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetMapScale(HMAP hmap);

 

  // Запросить название карты

  // hmap - идентификатор открытых данных

  // name - адрес буфера для результата запроса

  // size - размер буфера

  // При ошибке возвращает пустую строку

 

_MAPIMP const char * _MAPAPI mapGetMapName(HMAP hmap);

_MAPIMP long int _MAPAPI mapGetMapNameEx(HMAP hmap, char * name, long int size);

 

  // Запросить название карты в формате UNICODE             

  // name - строка в кодировке UNICODE (2 байта на символ)

  // size - размер строки в байтах

  // При ошибке возвращает пустую строку

 

_MAPIMP long int _MAPAPI mapGetMapNameUn(HMAP hMap, WCHAR * name, long int size);

 

  // Запросить путь к паспорту карты

  // hmap - идентификатор открытых данных

  // При ошибке возвращает пустую строку

 

_MAPIMP const char * _MAPAPI mapGetMapPath(HMAP hmap);

 

  // Запросить полный путь к паспорту главной карты в формате UNICODE

  // (функция вызывает mapGetMainMapName)

  // hmap - идентификатор открытых данных

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetMapPathUn(HMAP hmap, WCHAR *name, long int size);       // 24/10/14

 

  // Запросить тип карты

  // hmap - идентификатор открытых данных

  // Типы карт - см. mapcreat.h, MAPTYPE

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetMapType(HMAP hmap);

 

  // Запросить - является ли карта пользовательской

  // Пользовательская карта состоит из одного листа переменных

  // размеров без рамки

  // В структуре MAPREGISTEREX пользовательская карта в поле

  // FlagRealPlace имеет ненулевое значение

  // Если карта пользовательская - возвращается ненулевое значение

 

_MAPIMP long int _MAPAPI mapIsMapSite(HMAP hmap);

 

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

  // в метрах (система координат PLANE)

  // X - снизу вверх, Y - слева направо

  // т.1 - нижний левый угол,

  // т.2 - верхний правый

  // hmap - идентификатор открытых данных

  // При ошибке возвращает ноль (например, если первым открыт растр)

 

_MAPIMP double _MAPAPI mapGetMapX1(HMAP hmap);

_MAPIMP double _MAPAPI mapGetMapY1(HMAP hmap);

_MAPIMP double _MAPAPI mapGetMapX2(HMAP hmap);

_MAPIMP double _MAPAPI mapGetMapY2(HMAP hmap);

 

  // Запросить паспортные данные векторной карты

  // Структуры MAPREGISTER и LISTREGISTER описаны в mapcreat.h

  // hmap - идентификатор открытых данных

  // sheetnumber - номер листа карты для

  // которого запрашиваются паспортные данные

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetMapInfo(HMAP hmap, long int sheetnumber,

                                       MAPREGISTER *map, LISTREGISTER *sheet);

_MAPIMP long int _MAPAPI mapGetMapInfoEx(HMAP hmap, long int sheetnumber,

                                         MAPREGISTEREX *map, LISTREGISTER *sheet);

_MAPIMP long int _MAPAPI mapGetMapInfoPro(HMAP hmap, long int sheetnumber,

                                          MAPREGISTEREX *map, LISTREGISTER *sheet,

                                          SHEETNAMES * sheetnames);         // 07/11/14

 

  // Запросить паспортные данные векторной карты

  // по имени файла - паспорта карты (MAP,SIT) (name)

  // Структуры MAPREGISTER и LISTREGISTER описаны в mapcreat.h

  // sheetnumber - номер листа карты для

  // которого запрашиваются паспортные данные

  // При ошибке возвращает ноль,

  // иначе - число объектов на карте (если на карте нет объектов, возвращает -1) 

 

_MAPIMP long int _MAPAPI mapGetMapInfoByName(const char * name,

                                       long int sheetnumber,

                                       MAPREGISTER * map,

                                       LISTREGISTER * sheet);

 

_MAPIMP long int _MAPAPI mapGetMapInfoByNameUn(const WCHAR *name,

                                               long int sheetnumber,

                                               MAPREGISTER *mapreg,

                                               LISTREGISTER *sheet);

 

_MAPIMP long int _MAPAPI mapGetMapInfoByNameEx(const char * name,

                                       long int sheetnumber,

                                       MAPREGISTEREX * map,

                                       LISTREGISTER * sheet);

 

_MAPIMP long int _MAPAPI mapGetMapInfoByNameExUn(const WCHAR *name,

                                                 long int sheetnumber,

                                                 MAPREGISTEREX *mapreg,

                                                 LISTREGISTER *sheet);

 

  // Запросить имя классификатор карты по имени карты  

  // name    - имя файла паспорта карты (MAP,SIT)

  // rscname - имя файла RSC

  // size    - размер буфера для размещения имени RSC

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetRscByName(const char *name, char *rscname, long int size);

_MAPIMP long int _MAPAPI mapGetRscByNameUn(const WCHAR *name, WCHAR *rscname, long int size);

 

  // Контроль номенклатуры карты

  // nomenclature - строка с номенклатурой

  // length - длина строки

  // type - тип карты (из MAPTYPE)

  // scale - масштаб  (1000000,500000,200000 и т.д.

  //                   соответствующий типу карты)

 

_MAPIMP long int _MAPAPI mapCheckNomenclature(const char *nomenclature,

                                        long int length,

                                        long int type, long int scale);

_MAPIMP long int _MAPAPI mapCheckNomenclatureUn(const WCHAR *nomenclature,

                                                long int type, long int scale);

 

  //  Преобразование номенклатур для системы VN_2000 (5949-I-DN в 5949-1-DN)

 //  для масштабов 10000, 25000, 50000

 

_MAPIMP long int _MAPAPI mapReformNomenclatureVN2000(WCHAR *string, long int size);

 

  // Формирование имени файла по номенклатуре (удаляет точки, пробелы, -)

  // filename - место под имя файла

  // filelength - длина строки под имя файла

  // nomenclature - номенклатура листа

  // при ошибке возвращает 0

   

_MAPIMP long int _MAPAPI mapSetFileNameFromNomenclature(char *filename, int filelength,

                                                        const char *nomenclature);

 

  // Формирование имени файла по номенклатуре (удаляет точки, пробелы, -)

  // filename - буфер для имени файла

  // namesize - размер буфера в БАЙТАХ

  // nomenclature - номенклатура листа

  // при ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapSetFileNameFromNomenclatureUn(WCHAR *filename, int namesize,

                                                          const WCHAR *nomenclature);

 

  // Расчет данных на лист топографической карты

  // Равноугольная проекция Гаусса-Крюгера

  // hmap - идентификатор открытых данных

  // Структуры MAPREGISTER и LISTREGISTER описаны в mapcreat.h

  // входные данные   заполнены  поля в mapreg:

  //                - тип карты

  //                - масштаб

  //                - проекции исходного материала

  //                  заполнены  поля в sheet:

  //                - номенклатура

  // выходные данные  заполнены  поля в mapreg:

  //                 - осевой меридиан (при создании карты( hMap = 0))

  //                  заполнены  поля в sheet:

  //                 - геодезические координаты,

  //                 - прямоугольные координаты,

  //                 - сближение меридианов

  // Если mapreg и sheet заполняются для создания карты (самый первый лист)

  //  - hmap = 0

  // Если mapreg заполняется для добавления листа в карту

  //  - hmap != 0

 

_MAPIMP long int _MAPAPI mapCalcTopographicSheet(HMAP hmap,

                                           MAPREGISTER *mapreg,

                                           LISTREGISTER *sheet);

 

_MAPIMP long int _MAPAPI mapCalcTopographicSheetEx(HMAP hmap,      

                                           MAPREGISTEREX *mapreg,

                                           LISTREGISTER *sheet);

 

  // Установить признак повышенной точности хранения координат

  // Вызывается после создания карты (Map) или плана (Plane)

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

  // hmap -  идентификатор открытых данных

  // Объем метрики вдвое больше, точность хранения - максимальная

  // Нормальная точность хранения зависит от масштаба - для 100 000 - не

  // хуже 0,5 метра, для 10 000 - не хуже 0,05 метра

  // Все пользовательские карты, карты и планы местности

  // масштабов 5 000 и крупнее - всегда повышенной точности

  // Степень точности устанавливается при создании карты в поле DeviceCapability

  // структуры MAPREGISTEREX отрицательным значением (см. mapcreat.h),

  // в этом случае вызов mapSetMapPrecision не нужен

 

_MAPIMP void _MAPAPI mapSetMapPrecision(HMAP hmap);              

 

  // Запросить признак повышенной точности хранения координат

  // hmap -  идентификатор открытых данных

  // Возвращает значения:

  // 1 - максимальная точность хранения,

  // 2 - с точностью 2 знака (сантиметры),

  // 3 - с точностью 3 знака (миллиметры)

  // При ошибке или нормальной точности хранения координат возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetMapPrecision(HMAP hmap);             

 

 

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

  *                                                        *

  *     ФУНКЦИИ ЗАПРОСА ХАРАКТЕРИСТИК МЕТАДАННЫХ КАРТЫ     *        

  *                                                        *

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

 

  // Запросить количество эллипсоидов в списке

 

_MAPIMP long int _MAPAPI mapGetEllipsoidCount();

 

  // Запросить название эллипсоида по коду

  // Параметры  code  - код эллипсоида

  //            name  - адрес строки для размещения названия эллипсоида

  //            size  - длина выделенной области под строку в БАЙТАХ

  // При ошибке возвращает 0

  // name содержит значение "Не установлено"

 

_MAPIMP long int _MAPAPI mapGetEllipsoidNameByCode(long int code,char* name,

                                                   long int size);

 

_MAPIMP long int _MAPAPI mapGetEllipsoidNameByCodeUn(long int code,WCHAR* name,

                                                     long int size);

 

  // Запрос кода и названия эллипсоида по номеру в таблице

  // Параметры  number  - номер строки таблицы эллипсоидов (номер начинается с 1)

  //            code    - код эллипсоида

  //            name    - адрес строки для размещения названия эллипсоида

  //            size    - длина выделенной области под строку  в БАЙТАХ

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEllipsoidByNumber(long int number,long int &code,

                                                 char* name,long int size);

 

_MAPIMP long int _MAPAPI mapGetEllipsoidByNumberUn(long int number, long int *code,

                                                   WCHAR *name, long int size);

 

 // Запросить по коду EPSG номер эллипсоида (см. MAPCREAT.H)    

 // для заполнения структуры MAPREGISTEREX

 // code - код EPSG

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetEllipsoidByEPSGCode(long int code);

 

 // Запросить код EPSG эллипсоида по его коду (см. MAPCREAT.H)     

 // ellipsoid - номер эллипсоида (см. MAPCREAT.H, ELLIPSOIDKIND)

 // При ошибке возвращает ноль

 

_MAPIMP  long int _MAPAPI mapGetEllipsoidEPSGCode(long int code);

 

  // Запрос количества типов карт в списке

 

_MAPIMP long int _MAPAPI mapGetMapTypeCount();

 

  // Запрос названия типа карты по коду

  // Параметры  code  - код типа карты

  //            name  - адрес строки для размещения названия типа карты

  //            size  - длина выделенной области под строку в БАЙТАХ

  // При ошибке возвращает 0

  // name содержит значение "Не установлено"

 

_MAPIMP long int _MAPAPI mapGetMapTypeByCode(long int code,char* name,

                                             long int size);

 

_MAPIMP long int _MAPAPI mapGetMapTypeByCodeUn(long int code,WCHAR* name,

                                               long int size);

 

  // Запрос кода и названия типа карты по номеру в таблице

  // Параметры  number  - номер строки таблицы типа карты (номер начинается с 1)

  //            code    - код типа карты

  //            name    - адрес строки для размещения названия типа карты

  //            size    - длина выделенной области под строку в БАЙТАХ

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetMapTypeByNumber(long int number,long int &code,

                                               char* name,long int size);

 

_MAPIMP long int _MAPAPI mapGetMapTypeByNumberUn(long int number, long int *code,

                                                 WCHAR *name, long int size);

 

  // Запрос количества проекций в списке

 

_MAPIMP long int _MAPAPI mapGetProjectionCount();

 

  // Запрос названия проекции по коду

  // Параметры  code  - код проекции

  //            name  - адрес строки для размещения названия проекции

  //            size  - длина выделенной области под строку   в байтах

  // При ошибке возвращает 0

  // name содержит значение "Не установлено"                      

 

_MAPIMP long int _MAPAPI mapGetProjectionNameByCode(long int code,char* name,

                                                    long int size);

 

_MAPIMP long int _MAPAPI mapGetProjectionNameByCodeUn(long int code,WCHAR* name,

                                                      long int size);

 

  // Запрос кода и названия проекции по номеру в таблице

  // Параметры  number  - номер строки таблицы проекций (номер начинается с 1)

  //            code    - код проекции

  //            name    - адрес строки для размещения названия проекции

  //            size    - длина выделенной области под строку в БАЙТАХ

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetProjectionByNumber(long int number,long int &code,

                                                  char* name,long int size);

 

_MAPIMP long int _MAPAPI mapGetProjectionByNumberUn(long int number, long int *code,

                                                    WCHAR *name, long int size);

 

 // Запрос количества систем высот в списке

 

_MAPIMP long int _MAPAPI mapGetHeightSystemCount();                                   // 30/09/16

 

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

 // Параметры  code  - код системы высот

 //            name  - адрес строки для размещения названия системы высот

 //            size  - длина выделенной области под строку в байтах

 // При ошибке возвращает 0

 // name содержит значение "Не установлено"

 

_MAPIMP long int _MAPAPI mapGetHeightSystemNameByCode(long int code, char *name,

                                                    long int size);

 

_MAPIMP long int _MAPAPI mapGetHeightSystemNameByCodeUn(long int code, WCHAR *name,

                                                      long int size);

 

 // Запрос кода и названия системы высот по номеру в таблице

 // Параметры  number  - номер строки таблицы систем высот (номер начинается с 1)

 //            code    - код системы высот

 //            name    - адрес строки для размещения названия проекции

 //            size    - длина выделенной области под строку в БАЙТАХ

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetHeightSystemByNumber(long int number, long int &code,

                                                  char *name, long int size);

 

_MAPIMP long int _MAPAPI mapGetHeightSystemByNumberUn(long int number, long int *code,

                                                    WCHAR *name, long int size);

 

 

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

  *                                                        *

  *       ФУНКЦИИ ЗАПРОСА ИНФОРМАЦИИ О СЛОЯХ КАРТЫ         *

  *                                                        *

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

 

 // Запросить число слоев на карте

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetLayerCount(HMAP hmap);

 

 // Запросить название слоя по его номеру (number)

 // hmap - идентификатор открытых данных

 // name - адрес буфера для результата запроса

 // size - размер буфера

 // Номер первого слоя 0

 // При ошибке возвращает ноль

 

_MAPIMP const char * _MAPAPI mapGetLayerName(HMAP hmap,long int number);

_MAPIMP long int _MAPAPI mapGetLayerNameEx(HMAP hmap,long int number,

                                           char * name,long int size);

 

 // Запросить название слоя в кодировке UNICODE по его номеру (number)

 // hmap - идентификатор открытых данных

 // name - адрес буфера для результата запроса

 // size - размер буфера

 // Номер первого слоя 0

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetLayerNameUn(HMAP hmap,long int number,

                                           WCHAR * name,long int size);

 

 

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

  *                                                        *

  *       ФУНКЦИИ ЗАПРОСА ИНФОРМАЦИИ О ЛИСТАХ КАРТЫ        *

  *                                                        *

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

 

 // Определить собственный номер листа по заданным координатам (x,y).

 // Система координат задана переменной place.

 // Если лист не найден - возвращает ноль.

 // Если в одной точке несколько листов :

 // hmap - идентификатор открытых данных

 // number - порядковый номер листа в перекрытии (начина с 1).

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

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapWhatListNumber(HMAP hmap, double  x,double y,

                                           long int number, long int place);

 

 // Запросить номенклатуру листа по заданным координатам (x,y).

 // hmap - идентификатор открытых данных

 // name - адрес буфера для результата запроса

 // size - размер буфера

 // Система координат задана переменной place.

 // Если лист не найден - возвращает ноль

 

_MAPIMP const char* _MAPAPI mapWhatListName(HMAP hmap, double x, double y,

                                            long int number, long int place);

 

_MAPIMP long int _MAPAPI mapWhatListNameEx(HMAP hmap,double x, double y,

                                    long int number,long int place,

                                    char * name,long int size);

 

_MAPIMP long int _MAPAPI mapWhatListNameUn(HMAP hmap, double x, double y,

                                           long int number, long int place,

                                           WCHAR *name, long int size);

 

 // Запросить имя листа по его номеру (number)

 // hmap - идентификатор открытых данных

 // name - адрес буфера для результата запроса

 // size - размер буфера в байтах

 // При ошибке возвращает ноль

 

_MAPIMP const char* _MAPAPI mapGetSheetName(HMAP hmap, long int number);

 

_MAPIMP long int _MAPAPI mapGetSheetNameEx(HMAP hmap, long int number,

                                           char *name, long int size);

 

_MAPIMP long int _MAPAPI mapGetSheetNameUn(HMAP hmap, long int number,

                                           WCHAR *name, long int namesize);

 

 // Запросить номенклатуру листа по его номеру (number)

 // hmap - идентификатор открытых данных

 // name - адрес буфера для результата запроса

 // size - размер буфера

 // При ошибке возвращает ноль

 

_MAPIMP const char * _MAPAPI mapGetListName(HMAP hmap,long int number);

 

_MAPIMP long int _MAPAPI mapGetListNameEx(HMAP hmap,long int number,

                                          char * name,long int size);

 

_MAPIMP long int _MAPAPI mapGetListNameUn(HMAP hmap, long int number,

                                          WCHAR * name, long int size);

 

 // Запросить общее число листов в районе

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetListCount(HMAP hmap);

 

 // Запросить общее число объектов в листе

 // hmap - идентификатор открытых данных

 // list - номер листа

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetObjectCount(HMAP hmap, long int list);

 

 // Запросить общее число объектов в листе, исключая удаленные

 // number - номер листа

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetRealObjectCount(HMAP hMap, long int number);  

 

 // Запросить номер листа по его номенклатуре                

 // hmap - идентификатор открытых данных

 // name - имя листа

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetListNumberByName(HMAP hmap, const char * name);

 

_MAPIMP long int _MAPAPI mapGetListNumberByNameUn(HMAP hMap, const WCHAR *name);

 

 // Определить по номенклатуре листа его принадлежность карте

 // hmap - идентификатор открытых данных

 // listname - имя листа (номенклатура)

 // Возвращает номер карты в цепочке карт,которой принадлежит

 // лист по имени listname

 // (0-фоновая карта, 1-первая пользовательская карта и т.д.)

 // При ошибке возвращает "-1"

 

_MAPIMP long int _MAPAPI mapWhatListLayoutIs(HMAP hmap, const char *listname);

 

_MAPIMP long int _MAPAPI mapWhatListLayoutIsUn(HMAP hMap, const WCHAR *listname);

 

 // Запросить объект "Рамка листа"

 // hmap - идентификатор открытых данных

 // list - номер листа (c 1)

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetListFrameObject(HMAP hmap,long int list,

                                               HOBJ info);

 

 // Запросить габариты объекта "Рамка листа" (если рамки нет -

 // заполняются по габаритам из паспорта)

 // hmap  - идентификатор открытых данных

 // list  - номер листа

 // frame - указатель на габариты листа в метрах

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetListFrame(HMAP hmap, long int list, DFRAME * frame);

 

 // Создать объект "Рамка листа"

 // hmap - идентификатор открытых данных

 // list - последовательный номер листа карты (c 1)

 // info - идентификатор объекта карты в памяти

 // HOBJ должен быть создан вызовом mapCreateObject

 // при успешном выполнении HOBJ будет содержать созданную

 // или существующую рамку листа

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

 // Для карты местности созданная рамка сохраняется на карте

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapCreateListFrameObject(HMAP hmap, long int list,

                                                  HOBJ info);

 

 // Установить ограничение на число листов, открытых одновременно

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

 // ограниченной области памяти

 // hmap - идентификатор открытых данных

 // islimited - признак установки ограничения числа открытых листов,

 // обычно от 8 до 32, но не менее числа потоков, обрабатывающих листы параллельно

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetActiveListCountLimit(HMAP hmap, long int islimited = 32);

 

 // Установить ограничение на размер используемой памяти

 // Применяется при работе с большими многолистовыми картами

 // hmap - идентификатор открытых данных

 // limit - размер разрешенной к использованию памяти

 // Если лимит больше доступной приложению памяти,

 // устанавливается доступный объем физической памяти

 // Если лимит меньше 200 Мб, то устанавливается 200 Мб

 // При ошибке возвращает 0

 

_MAPIMP unsigned long int _MAPAPI mapSetMemoryLimit(HMAP hmap, unsigned long int limit);  // 25/11/16

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

  *                                                        *

  * ФУНКЦИИ ЗАПРОСА ИНФОРМАЦИИ ИЗ КЛАССИФИКАТОРА ОБ'ЕКТОВ  *

  *                                                        *

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

 

 // Запросить число объектов описанных в классификаторе

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscObjectCount(HMAP hmap);

 

 // Запросить число объектов описанных в классификаторе

 // в заданном слое

 // hmap - идентификатор открытых данных

 // layer - номер слоя в классификаторе

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscObjectCountInLayer(HMAP hmap,long int layer);

 

 // Запросить название объекта по порядковому номеру (number)

 // в заданном слое

 // hmap - идентификатор открытых данных

 // layer - номер слоя в классификаторе

 // size - размер строки в БАЙТАХ

 // При ошибке возвращает ноль или пустую строку

 

_MAPIMP const char* _MAPAPI mapRscObjectNameInLayer(HMAP hmap, long int layer,

                                                    long int number);

 

_MAPIMP long int _MAPAPI mapRscObjectNameInLayerEx(HMAP hMap, long int layer,

                                                   long int number,

                                                   char *name, long int size);

 

_MAPIMP long int _MAPAPI mapRscObjectNameInLayerUn(HMAP hMap, long int layer,

                                                   long int number, WCHAR *name,

                                                   long int size);

 

 // Запросить классификационный код объекта

 // по порядковому номеру в заданном слое (number)

 // hmap - идентификатор открытых данных

 // layer - номер слоя в классификаторе

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscObjectExcodeInLayer(HMAP hmap, long int layer,

                                                   long int number);

 

 // Запросить код локализации объекта

 // по порядковому номеру в заданном слое (number)

 // hmap - идентификатор открытых данных

 // layer - номер слоя в классификаторе

 // При ошибке возвращает ноль (ноль допустим)

 

_MAPIMP long int _MAPAPI mapRscObjectLocalInLayer(HMAP hmap, long int layer,

                                                  long int number);

 

 // Запросить внутренний код (индекс) объекта

 // по порядковому номеру в заданном слое (number)

 // hmap - идентификатор открытых данных

 // layer - номер слоя в классификаторе

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscObjectCodeInLayer(HMAP hmap, long int layer,

                                                 long int number);

 

 // Запросить внутренний код (индекс) объекта

 // по внешнему коду (excode) и локализации (local)

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscObjectCode(HMAP hMap, long int excode, long int local);

 

 // Запросить число семантических характеристик в классификаторе

 // hmap - идентификатор открытых данных

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscSemanticCount(HMAP hmap);

 

 // Запросить код семантической характеристики объекта

 // hmap - идентификатор открытых данных

 // number - последовательный номер характеристики в классификаторе (c 1)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscSemanticCode(HMAP hmap,long int number);

 

 // Запросить код семантической характеристики объекта

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

 // hmap - идентификатор открытых данных

 // key  - короткое имя семантики (ключ) в классификаторе

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRscSemanticCodeByKey(HMAP hmap, const char * key);

_MAPIMP long int _MAPAPI mapRscSemanticCodeByKeyUn(HMAP hMap, const WCHAR *key);

 

 // Запросить название семантической характеристики объекта

 // hmap - идентификатор открытых данных

 // code    - код характеристики

 // При ошибке возвращает ноль или пустую строку

 

_MAPIMP const char* _MAPAPI mapRscSemanticName(HMAP hmap, long int code);

 

_MAPIMP long int _MAPAPI mapRscSemanticNameUn(HMAP hmap, long int code,

                                              WCHAR *semname, long int size);

 

 

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

  *                                                        *

  *           ПРЕОБРАЗОВАНИЕ КООРДИНАТ ТОЧКИ               *

  *                                                        *

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

 

 // Запросить габариты района (всех видов карт)

 // hmap - идентификатор открытых данных

 // dframe - указатель на заполняемую структуру

 // Устанавливаются координаты углов района в метрах или радианах на местности

 // в картографической системе или в пикселах относительно верхнего левого угла

 // района

 // place  - запрашиваемая система координат (PP_PICTURE, PP_PLANE, PP_GEO)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetTotalBorder(HMAP hmap, DFRAME * dframe,

                                           long int place);

 

 // Запросить габариты района (всех видов карт) в системе координат,

 // заданной кодом EPSG, в метрах и радианах на местности

 // hmap - идентификатор открытых данных

 // dframeplane - указатель на заполняемую структуру в метрах

 // dframegeo   - указатель на заполняемую структуру в радианах

 // epsgcode    - код системы координат (3395, 3857, 4326 и т.д.)

 // Для геодезических систем координат возвращает 2,

 // для плоских прямоугольных возвращает 1.

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetTotalBorderByEPSG(HMAP hmap, DFRAME *dframeplane,

                                                 DFRAME *dframegeo, long int epsgcode);

 

 // Преобразование из дискретов на карте (районе работ)

 // в пикселы на изображении

 // hmap - идентификатор открытых данных

 // x,y  - преобразуемые координаты

 // на входе дискреты, на выходе - пикселы.

 // Применение :

 // xpix = xdis; ypix = ydis;

 // mapMapToPicture(xpix,ypix);

 

_MAPIMP void _MAPAPI mapMapToPicture(HMAP hmap,double * x, double * y);

 

 // Преобразование из дискретов на карте (районе работ)

 // в метры на местности

 // на входе дискреты, на выходе - метры.

 

_MAPIMP void _MAPAPI mapMapToPlane(HMAP hmap,double * x, double * y);

 

 // Преобразование из пикселов в изображении в координаты

 // карты (района работ) в дискретах

 // hmap - идентификатор открытых данных

 // x,y  - преобразуемые координаты

 

_MAPIMP void _MAPAPI mapPictureToMap(HMAP hmap,double * x, double * y);

 

 // Преобразование из пикселов в изображении в координаты

 // на местности в метрах

 // Применение :

 // xmet = xdis; ymet = ydis;

 // mapPictureToPlane(xmet,ymet);

 // hmap - идентификатор открытых данных

 // x,y  - преобразуемые координаты

 

_MAPIMP void _MAPAPI mapPictureToPlane(HMAP hmap,double * x, double * y);

 

 // Преобразование из метров на местности в дискреты

 // на карте (районе работ)

 // hmap - идентификатор открытых данных

 // x,y  - преобразуемые координаты

 

_MAPIMP void _MAPAPI mapPlaneToMap(HMAP hmap,double * x, double * y);

 

 // Преобразование из метров на местности в пикселы на

 // изображении

 // hmap - идентификатор открытых данных

 // x,y  - преобразуемые координаты

 

_MAPIMP void _MAPAPI mapPlaneToPicture(HMAP hmap,double * x, double * y);

 

 // Преобразование из метров на местности в геодезические

 // координаты в радианах в соответствии с проекцией карты

 // (поддерживаетс не для всех карт !)

 // Применение :

 // if (mapIsGeoSupported())   |  или :

 //   {                        |  if (mapIsGeoSupported())

 //     B = Xmet; L = Ymet;    |    {

 //     mapPlan2Geo(B,L);      |      mapPlan2Geo(B=Xmet,L=Ymet);

 //   }                        |    }

 // hmap - идентификатор открытых данных

 // Bx,Ly  - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneToGeo(HMAP hmap,double *Bx, double *Ly);

 

 // Преобразование из геодезических координат в радианах

 // в метры на местности в соответствии с проекцией карты

 // (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGeoToPlane(HMAP hmap,double *Bx, double *Ly);

 

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

 // source - номер исходной зоны системы 1942г

 // target - нужной зоны

 // x,y  - преобразуемые координаты

 // на входе метры в одной зоне 42г.,на выходе - другой.

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneToPlaneByZone(long int source, long int target,

                                         double * x, double * y);

 

 // Преобразование координат в метрах на местности из заданной зоны

 // в геодезические координаты в системе 42г.

 // zone - номер исходной зоны системы 1942г

 // x,y  - преобразуемые координаты

 // на входе метры в одной зоне 42г.,на выходе - радианы.

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlane42ToGeo42ByZone(long int zone, double * x, double * y);

_MAPIMP long int _MAPAPI mapPlaneToGeo42ByZone(long int zone, double * x, double * y);

 

 // Преобразование координат в метрах на местности из заданной зоны UTM

 // в геодезические координаты в системе WGS-84.        

 // zone - номер исходной зоны системы UTM

 // x,y  - преобразуемые координаты

 // на входе метры в одной зоне UTM, на выходе - радианы WGS-84.

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneUTMToGeoWGS84ByZone(long int zone, double * x, double * y);

 

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

 // source - номер исходной зоны системы UTM

 // target - нужной зоны системы UTM

 // x,y  - преобразуемые координаты

 // на входе метры в одной зоне UTM, на выходе - метры в другой зоне UTM.

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneUTMToPlaneUTMByZone(long int source, long int target,

                                         double * x, double * y);

 

 // Запрос - поддерживается ли пересчет к геодезическим

 // координатам из плоских прямоугольных и обратно

 // hmap - идентификатор открытых данных

 // Если нет - возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsGeoSupported(HMAP hmap);

 

 // Преобразование из метров на местности (проекция карты)

 // в геодезические координаты в радианах (общеземной эллипсоид WGS84)

 // (поддерживается не для всех карт !)

 // Наличие высоты повышает точность расчетов,

 // функция mapPlaneToGeoWGS84() пытается

 // определить высоту из матрицы

 // Применение :

 // if (mapIsGeoSupported())

 //   {

 //     B = Xmet; L = Ymet;

 //     mapPlaneToGeoWGS84(hMap,B,L);

 //   }

 // hmap  - идентификатор открытых данных

 // Bx,Ly - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // H     - высота в точке (метры)

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneToGeoWGS84(HMAP hmap,double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapPlaneToGeoWGS843D(HMAP hmap,double *Bx, double *Ly,

                                              double *H);

 

 // Преобразование из метров на местности (проекция карты)

 // в геодезические координаты в радианах (эллипсоид Красовского, СК-42)

 // (поддерживается не для всех карт !)

 // hmap  - идентификатор открытых данных

 // Bx,Ly - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // H     - высота в точке (метры)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPlaneToGeo42(HMAP hmap,double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapPlaneToGeo423D(HMAP hmap,double *Bx, double *Ly,

                                           double *H);

 

 // Преобразование из метров на местности (проекция карты)

 // в геодезические координаты в радианах (эллипсоид Красовского, СК-95)

 // (поддерживается не для всех карт !)

 // Если исходная карта в СК-42, то геодезические координаты выдаются в СК-42

 // без преобразования

 // hmap  - идентификатор открытых данных

 // Bx,Ly - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // H     - высота в точке (метры)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPlaneToGeo953D(HMAP hmap,double *Bx, double *Ly,

                                           double *H);

 

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

 // геоцентрической системе координат

 // (поддерживается не для всех карт !)

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры в геоцентрической системе

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoToXYZ(HMAP hMap, double *BX, double *LY,

                                                double * H);

 

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

 // геодезической системе координат

 // (поддерживается не для всех карт !)

 // Bx,Ly,H  - преобразуемые координаты

 // на входе метры в геоцентрической системе, на выходе - радианы

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapXYZToGeo(HMAP hMap, double *BX, double *LY,

                                                double * H);

                                         

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

 // в геодезические координаты в радианах (общеземной эллипсоид WGS84)

 // (поддерживается не для всех карт !)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoToGeoWGS843D(HMAP hMap, double *Bx, double *Ly,

                                            double * H);

                                          

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

 // (общеземной эллипсоид WGS84) в геодезическую систему координат карты

 // (поддерживается не для всех карт !)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToGeo3D(HMAP hMap, double *Bx, double *Ly,

                                            double * H);

                                         

 //  Преобразование из геодезических координат в радианах

 // (общеземной эллипсоид WGS84)

 //  в метры на местности в системе 1942г (эллипсоид Красовского)

 // (поддерживается не для всех карт !)

 // Применение :

 // if (mapIsGeoSupported())

 //   {

 //     B = Xmet; L = Ymet;

 //     mapGeo84ToPlane42(hMap,B,L);

 //   }

 // hmap - идентификатор открытых данных

 // Bx,Ly  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToPlane42(HMAP hmap,double *Bx, double *Ly);

 

 //  Преобразование из геодезических координат в радианах

 // (общеземной эллипсоид WGS84)

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

 // (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToPlane3D(HMAP hmap, double *Bx, double *Ly,

                                              double * H);

 

 //  Преобразование из геодезических координат в радианах

 // (эллипсоид Красовского, СК-42)

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

 // (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeo42ToPlane3D(HMAP hmap, double *Bx, double *Ly,

                                           double * H);

 

 //  Преобразование из геодезических координат в радианах

 // (эллипсоид Красовского, СК-95)

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

 // (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeo95ToPlane3D(HMAP hmap, double *Bx, double *Ly,

                                           double * H);

 

 //  Преобразование из геодезических координат в радианах

 // (общеземной эллипсоид ПЗ-90.02)

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

 // (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoEP90ToPlane3D(HMAP hmap, double *Bx, double *Ly,

                                             double * H);

 

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

 // (эллипсоид Красовского) в геодезические координаты в радианах

 // (общеземной эллипсоид WGS84) (поддерживается не для всех карт !)

 // hmap - идентификатор открытых данных

 // Bx,Ly  - преобразуемые координаты

 // на входе радианы в 42г., на выходе - радианы в WGS84

 // H     - высота в точке (метры)

 // Параметр hmap может быть равен нулю

 

_MAPIMP void _MAPAPI mapGeo42ToGeoWGS84Ex(double *Bx, double *Ly, double *H);

_MAPIMP long int _MAPAPI mapGeo42ToGeoWGS84(HMAP hmap,double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeo42ToGeoWGS843D(HMAP hmap,double *Bx, double *Ly,

                                              double *H);

 

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

 // (эллипсоид Кларка 1880г) в геодезические координаты в радианах

 // системы WGS84 (общеземной эллипсоид WGS-84)        

 // на входе радианы в NAHRWAN, на выходе - радианы в WGS84

 // H     - высота в точке (метры)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoNahrwanToGeoWGS843D(double *B, double *L, double *H);

 

 // Преобразование геодезических координаты в радианах из системы WGS 84

 // (общеземной эллипсоид WGS84) (поддерживается не для всех карт !)

 // в геодезические координаты в радианах в систему 1942 г (эллипсоид Красовского)

 // hmap - идентификатор открытых данных

 // Bx,Ly  - преобразуемые координаты

 // на входе радианы в WGS84, на выходе - радианы в 42г.

 // H     - высота в точке (метры)

 // Параметр hmap может быть равен нулю

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToGeo42Ex(double *Bx, double *Ly, double *H);    

_MAPIMP long int _MAPAPI mapGeoWGS84ToGeo42(HMAP hmap,double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeoWGS84ToGeo423D(HMAP hmap,double *Bx, double *Ly,

                                              double *H);

 

 // Преобразование геодезических координат в радианах из системы ПЗ-90

 // (общеземной эллипсоид ПЗ-90.02) в геодезические координаты в радианах

 // системы 1942 г (эллипсоид Красовского)

 // Параметр hmap может быть равен нулю

 

_MAPIMP void _MAPAPI mapGeoEP90ToGeo42Ex(double *Bx, double *Ly, double *H);     

_MAPIMP long int _MAPAPI mapGeoEP90ToGeo42(HMAP hmap, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeoEP90ToGeo423D(HMAP hmap, double *Bx, double *Ly,

                                             double *H);

 

 // Преобразование геодезических координат в радианах из системы ПЗ-90

 // (общеземной эллипсоид ПЗ-90.02) в геодезические координаты в радианах

 // системы 1995 г (эллипсоид Красовского)

 

_MAPIMP void _MAPAPI mapGeoEP90ToGeo95Ex(double *Bx, double *Ly, double *H);    

 

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

 // (эллипсоид Красовского) в геодезические координаты в радианах

 // системы ПЗ-90(общеземной эллипсоид ПЗ-90.02)

 

_MAPIMP void _MAPAPI mapGeo95ToGeoEP90Ex(double *Bx, double *Ly, double *H);    

 

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

 // (эллипсоид Красовского) в геодезические координаты в радианах

 // системы ПЗ-90(общеземной эллипсоид ПЗ-90.02)

 // Параметр hmap может быть равен нулю

 

_MAPIMP void     _MAPAPI mapGeo42ToGeoEP90Ex(double *Bx, double *Ly, double *H);      

_MAPIMP long int _MAPAPI mapGeo42ToGeoEP90(HMAP hmap, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeo42ToGeoEP903D(HMAP hmap, double *Bx, double *Ly,

                                             double *H);

 

 // Преобразование геодезических координат в радианах из системы ПЗ-90

 // (общеземной эллипсоид ПЗ-90.02) в геодезические координаты в радианах

 // в системе WGS-84 (общеземной эллипсоид WGS84)

 

_MAPIMP void _MAPAPI mapGeoEP90ToGeoWGS843D(double *Bx, double *Ly, double *H);    

 

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

 // в геодезические координаты в радианах системы ПЗ-90(общеземной эллипсоид ПЗ-90.02)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPlaneToGeoEP903D(HMAP hmap, double *Bx, double *Ly,

                                             double *H);

 

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

 // (эллипсоид Красовского) в прямоугольные в метрах в системе NAHRWAN в

 // проекции UTM (эллипсоид Кларка 1880г.) - NAD27

 

_MAPIMP void     _MAPAPI mapGeo42ToPlaneUTMEx(double *Bx, double *Ly, double H);      

_MAPIMP long int _MAPAPI mapGeo42ToPlaneUTM(HMAP hmap, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeo42ToPlaneUTM3D(HMAP hmap, double *Bx, double *Ly,

                                              double *H);

 

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

 // (эллипсоид Красовского) в прямоугольные в метрах с учетом ближайшей

 // зоны к координатам точки                           

 // Bx,Ly - преобразуемые координаты

 

_MAPIMP long int_MAPAPI mapGeo42ToPlaneByOwnZone(double *Bx, double *Ly);

 

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

 // координат в другую

 // hmap  - идентификатор открытых данных

 // src,tag - указатели на области размещения точек,

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

 // source,target - типы входной и выходной метрики (PP_MAP,PP_PLANE ...);

 // count - число преобразуемых точек.

 // Пересчет связанный с геодезическими координатами

 // будет выполняться только,если IsGeoSupported() != 0.

 

_MAPIMP void _MAPAPI mapTransformPoints(HMAP hmap, DOUBLEPOINT *src,

                                        long int source, DOUBLEPOINT *tag,

                                        long int target, long int count);

 

 // Преобразование координат из градусов в радианы

 // (для положительного значения)

 // degree - структура, содержащая координаты в градусах, минутах,

 // секундах. Описана в maptype.h

 // radian - значение в радианах

 

_MAPIMP void _MAPAPI mapDegreeToRadian(GEODEGREE *degree, double *radian);

 

 // Преобразование координат из радиан в градусы

 // (для положительного значения)

 // radian - значение в радианах

 // degree - структура, содержащая координаты в градусах, минутах,

 // секундах. Описана в maptype.h

 

_MAPIMP void _MAPAPI mapRadianToDegree(double *radian, GEODEGREE *degree);

 

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

 // degree - структура, содержащая координаты в градусах, минутах,

 // секундах. Описана в maptype.h

 // radian - значение в радианах

 

_MAPIMP void _MAPAPI mapSignDegreeToRadian(SIGNDEGREE *degree, double *radian);

 

 // Преобразование координат из радиан в градусы со знаком

 // radian - значение в радианах

 // degree - структура, содержащая координаты в градусах, минутах,

 // секундах. Описана в maptype.h

 

_MAPIMP void _MAPAPI mapRadianToSignDegree(double *radian, SIGNDEGREE *degree);

 

 // Вычисление осевого маридиана по номеру зоны для

 // топокарт системы 42 года

 // zone - номер зоны системы 42 года

 // При ошибке возвращает ноль

 

_MAPIMP double _MAPAPI mapGetAxisMeridianByZone(long int zone);

 

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

 // (меридиану) для топокарт системы 42 года

 // meridian - значение меридиана в радианах

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetZoneByMeridian(double meridian);

 

 // Заполнение осевого меридиана по геодезической долготе в

 // радианах для топографических карт

 // hmap - идентификатор открытых данных

 // meridian - значение меридиана в радианах

 // Не рекомендуется применять для карт уже содержащих объекты

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetAxisMeridianByMeridian(HMAP hmap, double meridian);

 

 // Заполнение осевого меридиана по координате Y для

 // топографических карт системы 42 года

 // Не рекомендуется применять для карт уже содержащих объекты

 // hmap  - идентификатор открытых данных

 // y     - координата Y в метрах произвольной точки,

 //         попадающей на заданный лист

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetAxisMeridianByPlaneY(HMAP hmap, double y);

 

 

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

  *                                                        *

  *     ПЕРЕСЧЕТ КООРДИНАТ В РАБОЧЕЙ СИСТЕМЕ КООРДИНАТ     *

  *                                                        *

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

 

 // Запросить параметры эллипсоида по его номеру (см. MAPCREAT.H)    

 // ellipsoid - номер эллипсоида (см. MAPCREAT.H, ELLIPSOIDKIND)

 // parm      - параметры заданного эллипсоида

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetEllipsoidParameters(long int ellipsoid,

                                                   ELLIPSOIDPARAM * parm);

 

 // Установить текущие параметры рабочей системы координат

 // hMap      - идентификатор открытой основной карты

 // parm      - параметры рабочей системы координат

 // datum     - параметры пересчета с эллипсоида рабочей системы координат

 //             к WGS-84 (datum может быть 0)                        

 // ellipsoid - параметры пользовательского эллипсоида для рабочей

 //             системы координат, когда поле EllipsoideKind в

 //             MAPREGISTEREX равно USERELLIPSOID (ellipsoid может быть 0)

 // При ошибке возвращает ноль

 

_MAPIMP  long int _MAPAPI mapSetWorkSystemParametersEx(HMAP hMap,

                                                       MAPREGISTEREX *parm,

                                                       DATUMPARAM *datum,

                                                       ELLIPSOIDPARAM *ellipsoid);

                                                   

_MAPIMP long int _MAPAPI mapSetWorkSystemParameters(HMAP hmap,

                                                    MAPREGISTEREX * parm);

 

 // Запросить текущие параметры рабочей системы координат

 // hMap      - идентификатор открытой основной карты

 // parm      - параметры рабочей системы координат

 // datum     - параметры пересчета с эллипсоида рабочей системы координат

 //             к WGS-84

 // ellipsoid - параметры пользовательского эллипсоида для рабочей

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

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetWorkSystemParametersEx(HMAP hmap,     

                                                      MAPREGISTEREX * parm,

                                                      DATUMPARAM * datum,

                                                      ELLIPSOIDPARAM * ellipsoid);

 

_MAPIMP long int _MAPAPI mapGetWorkSystemParameters(HMAP hmap,

                                                    MAPREGISTEREX * parm);

 

 // Запросить - установлены ли параметры рабочей системы координат

 // (Если mapSetWorkSystemParameters не вызывалась - возвращает 0)

 // hMap   - идентификатор открытой основной карты

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapIsWorkSystemParameters(HMAP hmap);

 

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

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

 // hmap   - идентификатор открытых данных

 // X,Y,H  - преобразуемые координаты

 // на входе метры, на выходе - метры

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneToWorkSystemPlane(HMAP hMap, double *X,

                                                   double *Y, double *H);

 

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

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

 // hmap   - идентификатор открытых данных

 // X,Y,H  - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapPlaneToWorkSystemGeo(HMAP hMap, double *X,

                                                 double *Y, double *H);

 

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

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

 // hmap     - идентификатор открытых данных

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGeoToWorkSystemPlane(HMAP hmap, double *Bx,

                                                 double *Ly, double *H);

 

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

 // из метров на местности в рабочей системе координат в соответствии с ее параметрами

 // hmap    - идентификатор открытых данных

 // Bx,Ly,H - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapWorkSystemPlaneToGeo(HMAP hmap, double *Bx,

                                                 double *Ly, double *H);

 

 

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

  *                                                         *

  * ПЕРЕСЧЕТ КООРДИНАТ В ПОЛЬЗОВАТЕЛЬСКОЙ СИСТЕМЕ КООРДИНАТ *         // 07/10/10

  *                                                         *

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

 

 // Установить текущие параметры пользовательской системы координат

 // parm      - параметры рабочей системы координат (см. MAPCREAT.H)

 // datum     - параметры пересчета с эллипсоида рабочей системы координат

 //             к WGS-84 (datum может быть 0)                        

 // ellipsoid - параметры пользовательского эллипсоида для рабочей

 //             системы координат, только когда поле EllipsoideKind в

 //             MAPREGISTEREX равно USERELLIPSOID (ellipsoid может быть 0)

 // ttype     - тип локального преобразования координат (см. TRANSFORMTYPE в mapcreat.h) или 0

 // tparm     - параметры локального преобразования координат (см. mapcreat.h) 

 // code      - код EPSG (4326 - WGS-84),

 //             для СК-42 зоны 1-60 : 28401-28460, для СК-95 зоны 4-32: 20004-20032

 // Возвращает идентификатор пользовательской системы координат

 // По завершении использования необходимо вызвать mapDeleteUserSystemParameters

 // При ошибке возвращает ноль

 

_MAPIMP HANDLE _MAPAPI mapCreateUserSystemParametersPro(MAPREGISTEREX * parm,

                                                        DATUMPARAM * datum,

                                                        ELLIPSOIDPARAM * ellipsoid,

                                                        long int ttype,

                                                        LOCALTRANSFORM * tparm);

 

_MAPIMP  HANDLE _MAPAPI mapCreateUserSystemParameters(MAPREGISTEREX * parm,

                                                      DATUMPARAM * datum,

                                                      ELLIPSOIDPARAM * ellipsoid);

 

_MAPIMP HANDLE _MAPAPI mapCreateUserSystemParametersByEpsg(long int code);

 

 // Запросить/Установить тип системы координат

 // (плоская прямоугольная - 1 или геодезическая - 2)

 // При отсутствии данных возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetUserSystemType(HANDLE huser);

_MAPIMP long int _MAPAPI mapSetUserSystemType(HANDLE huser, long int type);

 

 // Преобразование из геодезических координат (радианы) в пользовательской проекции

 // в геодезические координаты в радианах (общеземной эллипсоид WGS84)

 // huser - идентификатор пользовательской системы координат

 // Bx,Ly - преобразуемые координаты

 // на входе радианы, на выходе - радианы

 // H     - высота в точке (метры)

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapUserGeoToGeoWGS84(HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapUserGeoToGeoWGS843D(HANDLE huser, double *Bx, double *Ly,

                                                double *H);

 

 // Преобразование из геодезических координат (радианы) в пользовательской проекции 

 // в метры в пользовательской проекции

 // huser - идентификатор пользовательской системы координат

 // Bx,Ly - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapUserGeoToUserPlane(HANDLE huser, double *Bx, double *Ly); 

_MAPIMP long int _MAPAPI mapUserGeoToPlane(HANDLE huser, double *Bx, double *Ly);

 

 // Преобразование из метров на местности в пользовательской проекции

 // в геодезические координаты в радианах (общеземной эллипсоид WGS84)

 // Наличие высоты повышает точность расчетов

 // huser - идентификатор пользовательской системы координат

 // Bx,Ly - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // H     - высота в точке (метры)

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapUserPlaneToUserGeo(HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapUserPlaneToGeoWGS84(HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapUserPlaneToGeoWGS843D(HANDLE huser, double *Bx, double *Ly,

                                                  double *H);

 

// Преобразование из метров на местности в пользовательской проекции            

 // в геодезические координаты в радианах на эллипсоиде в пользовательской проекции

 // Наличие высоты повышает точность расчетов

 // huser - идентификатор пользовательской системы координат

 // Bx,Ly - преобразуемые координаты

 // на входе метры, на выходе - радианы

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapUserPlaneToGeo(HANDLE huser, double *Bx, double *Ly);

 

 // Преобразование из геодезических координат в радианах

 // (общеземной эллипсоид WGS84)

 // в геодезические координаты в радианах на эллипсоиде в пользовательской проекции

 // huser    - идентификатор пользовательской системы координат

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - радианы

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToUserGeo(HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeoWGS84ToUserGeo3D(HANDLE huser, double *Bx, double *Ly,

                                                double * H);

 

 // Преобразование из геодезических координат в радианах

 // (общеземной эллипсоид WGS84)

 // в метры на местности в пользовательской проекции

 // huser    - идентификатор пользовательской системы координат

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - метры

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGeoWGS84ToUserPlane(HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeoWGS84ToUserPlane3D(HANDLE huser, double *Bx, double *Ly,

                                                  double * H);

 

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

 // в геодезические координаты в радианах на эллипсоиде в пользовательской проекции

 // hmap    - идентификатор открытых данных

 // huser    - идентификатор пользовательской системы координат

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - радианы

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapUserPlaneToGeoWGS843D (HMAP hmap, HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapGeoToUserGeo3D(HMAP hmap, HANDLE huser, double *Bx, double *Ly,

                                           double * H);

                                                                          

 // Преобразование из геодезических координат (радианы) на эллипсоиде                  

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

 // hmap    - идентификатор открытых данных

 // huser    - идентификатор пользовательской системы координат

 // Bx,Ly,H  - преобразуемые координаты

 // на входе радианы, на выходе - радианы

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapUserGeoToGeo(HMAP hmap, HANDLE huser, double *Bx, double *Ly);

_MAPIMP long int _MAPAPI mapUserGeoToGeo3D(HMAP hmap, HANDLE huser, double *Bx, double *Ly,

                                           double * H);

 

  // Освободить ресурсы пользовательской системы координат

 

_MAPIMP void _MAPAPI mapDeleteUserSystemParameters(HANDLE huser);

 

// Сравнить параметры двух систем координат                   //04/10/16

 // parm1      - параметры первой системы координат (см. MAPCREAT.H)

 // datum1     - параметры пересчета с эллипсоида первой системы координат

 //              к WGS-84 (datum может быть 0)

 // ellipsoid1 - параметры пользовательского эллипсоида для первой

 //              системы координат, только когда поле EllipsoideKind в

 //              MAPREGISTEREX равно USERELLIPSOID (ellipsoid может быть 0)

 // type1      - тип локального преобразования координат (см. TRANSFORMTYPE

 //              в mapcreat.h) для первой системы координат

 // tparm1     - параметры локального преобразования координат (см. mapcreat.h)

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

 // parm2      - параметры второй системы координат (см. MAPCREAT.H)

 // datum2     - параметры пересчета с эллипсоида второй системы координат

 //              к WGS-84 (datum может быть 0)

 // ellipsoid2 - параметры пользовательского эллипсоида для второй

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

 // type2      - тип локального преобразования координат (см. TRANSFORMTYPE

 //              в mapcreat.h) второй системы координат

 // tparm2     - параметры локального преобразования координат (см. mapcreat.h)

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

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

 // Некоторые несовпадающие параметры могут считаться идентичными

 // (например, топографическая карта UTM и обзорно-географическая карта UTM)

 

_MAPIMP long int _MAPAPI mapCompareSystemParametersPro(MAPREGISTEREX * parm1,

                                             DATUMPARAM * datum1,

                                             ELLIPSOIDPARAM * ellipsoid1,

                                             long int ttype1,

                                             LOCALTRANSFORM * tparm1,

                                             MAPREGISTEREX * parm2,

                                             DATUMPARAM * datum2,

                                             ELLIPSOIDPARAM * ellipsoid2,

                                             long int ttype2,

                                             LOCALTRANSFORM * tparm2);

 

_MAPIMP long int _MAPAPI mapCompareSystemParameters(MAPREGISTEREX * parm1,

                                             DATUMPARAM * datum1,

                                             ELLIPSOIDPARAM * ellipsoid1,

                                             MAPREGISTEREX * parm2,

                                             DATUMPARAM * datum2,

                                             ELLIPSOIDPARAM * ellipsoid2);

 

 

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

  *                                                        *

  *     ОТОБРАЖЕНИЕ КООРДИНАТ В ЗАДАННОМ ФОРМАТЕ           *

  *                                                        *

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

 

 // Установить формат отображения текущих координат курсора  

 // hmap    - идентификатор открытых данных

 // format -  номер формата отображения координат (см. maptype.h - CURRENTPOINTFORMAT)

 // При ошибке возвращает ноль, иначе - установленное значение

 

_MAPIMP long int _MAPAPI mapSetCurrentPointFormat(HMAP hmap, long int format);

 

 // Запросить формат отображения текущих координат курсора

 // hmap    - идентификатор открытых данных

 // Возвращает номер формата отображения координат (см. maptype.h - CURRENTPOINTFORMAT)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapGetCurrentPointFormat(HMAP hmap);

 

 // Пересчитать значение координат из плоских прямоугольных координат документа (метры)

 // в систему, определяемую форматом отображения текущих координат

 // hmap    - идентификатор открытых данных

 // x, y    - координаты точки в радианах в соответствии с текущими параметрами

 //           проекции (mapGetDocProjection) - пересчитываются в новые значения

 // h       - высота точки (указатель может быть равен нулю), если задано значение -

 //           пересчитывается в новое значение

 // maptype - тип карты, соответствующий координатам, если не равен нулю,

 //           то добавляется строка с обозначением системы координат: "(СК42)", "(CR95)"...

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPlaneToPointFormat(HMAP hmap, double *x,

                                               double *y, double *h);

 

 // Пересчитать значение координат из плоских прямоугольных координат документа (метры)

 // в систему, определяемую форматом отображения текущих координат

 // и сформировать строку

 // hmap    - идентификатор открытых данных

 // x, y    - координаты точки в радианах в соответствии с текущими параметрами

 //           проекции (mapGetDocProjection)

 // h       - высота точки (указатель может быть равен нулю)

 // place   - адрес строки для записи результата

 // size    - размер выделеной строки (не менее 256 байт)

 // Пример строки:

 // B= -73° 27' 04.53"  L= 175° 51' 21.07"  H= 109.51 m (WGS84)

 // X= 6 309 212.12 м   Y= 7 412 249.25 м (СК42)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapPlaneToPointFormatString(HMAP hmap, double *x,

                                                     double *y, double *h,

                                                     char *place, long int size);

_MAPIMP long int _MAPAPI mapPlaneToPointFormatStringUn(HMAP hmap, double *x,

                                                       double *y, double *h,

                                                       WCHAR *place, long int size);

 

// Вывод координат точки в строку

 // x,y   - плоские прямоугольные координаты точки в метрах

 // h     - высота в метрах или нулевой указатель

 // place - адрес строки для размещения результата

 // size  - размер строки (не менее 80 байт)

 // maptype - тип карты, если не равен нулю, то добавляется строка

 //           с обозначением системы координат: "   (СК42)", "   (CК95)",...

 // Пример результата:

 // "X=  438 145.27 m  Y= 6 230 513.03 m  H=  54.12 m"

 

_MAPIMP void _MAPAPI mapPlaneToString(double *x, double *y, double *h,

                                      char *place, long int size, long int maptype);

_MAPIMP long int _MAPAPI mapPlaneToStringUn(double *x, double *y, double *h,

                                            WCHAR *place, long int size, long int maptype);

 

// Запись числа с плавающей точкой в символьном виде со вставкой разделяющих пробелов

 // (разделение на тройки символов от конца строки к началу)

 // Например: 7 390 621.458                                   

 // value  - значение числа, записываемого в строку

 // string - адрес строки для размещения результата

 // size   - длина строки в байтах (не менее 16 !)

 // precision - число знаков после запятой

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDoubleToString(double value, char* string,

                                           long int size, long int precision);

_MAPIMP long int _MAPAPI mapDoubleToStringUn(double value, WCHAR *string,

                                             long int size, long int precision);

 

  // Запись целого числа в символьном виде со вставкой разделяющих пробелов

  // (разделение на тройки символов от конца строки к началу)

  // size - длина строки в байтах (не менее 16 !)

  // При ошибке возвращает ноль

_MAPIMP long int _MAPAPI mapLongToString(long int number,char* string,long int size);

_MAPIMP long int _MAPAPI mapLongToStringUn(long int number, WCHAR* string,long int size);

 

  // Запись целого числа типа __int64 в символьном виде

  // со вставкой разделяющих пробелов

  // (разделение на тройки символов от конца строки к началу)

  // size - длина строки в байтах (не менее 32 !)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapInt64ToString(__int64 number, char *string, long int size);

 

_MAPIMP long int _MAPAPI mapInt64ToStringUn(__int64 number, WCHAR *string, long int size);

 

  // Округлить дробную часть числа до заданного числа знаков

  // Целая часть остается без изменения

  // value - исходное значение

  // count - число знаков после запятой (от 0 до 9)

 

_MAPIMP double _MAPAPI mapRoundDouble(double value, int count);       

 

  // Запись масштаба в символьном виде со вставкой разделяющих пробелов

  // (например: "1 : 50 000","2 : 1" - если scale < 1)

  // (разделение на тройки символов от конца строки к началу)

  // size - длина строки в байтах (не менее 20 !)

  // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapScaleToString(double scale, char * string, long int size);

_MAPIMP long int _MAPAPI mapScaleToStringUn(double scale, WCHAR* string, long int size);

 

 

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

*                                                                        *

*             ФУНКЦИИ ДОСТУПА К БАЗЕ ДАННЫХ EPSG                         *

*  ДЛЯ ВЫПОЛНЕНИЯ НЕОБХОДИМО НАЛИЧИЕ В ПАПКЕ ПРИЛОЖЕНИЯ ФАЙЛОВ           *

*  EPSG.CSG, EPSG.CSP, EPSG.CSU, КОТОРЫЕ ВХОДЯТ В СОСТАВ ГИС КАРТА 2011. *

*  ОБНОВИТЬ ФАЙЛЫ МОЖНО ИСПОЛЬЗУЯ ПРОГРАММУ EPSGReader, ВХОДЯЩУЮ В       *

*  ГИС КАРТА 2011.                                                       *

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

 

  // Запросить параметры проекции и системы координат по коду EPSG     

  // Если код EPSG задает геодезическую систему координат,

  // то устанавливается проекция Широта\Долгота и соответствующие

  // параметры эллипсоида и датум

  // Если код EPSG задает плоскую прямоугольную систему координат,

  // то все параметры устанавливаются из базы EPSG

  // epsgcode  - код EPSG, для СК-42 зоны 2-32 : 28402-28432, для СК-95 зоны 4-32: 20004-20032

  // mapreg    - параметры системы координат и проекции

  // datum     - параметры пересчета с эллипсоида рабочей системы координат

  //             к WGS-84

  // ellipsoid - параметры пользовательского эллипсоида для рабочей

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

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetParametersForEPSG(long int epsgcode,

                                                 MAPREGISTEREX *mapreg,

                                                 DATUMPARAM *datum,

                                                 ELLIPSOIDPARAM *ellipsoid);

 

  // Открыть базу данных EPSG           

  // При успешном выполнении возвращает идентификатор открытой базы данных EPSG

  // При ошибке возвращает 0

 

_MAPIMP HANDLE _MAPAPI mapOpenEPSGDatabase();

 

  // Закрыть базу данных EPSG

  // epsgdata - идентификатор открытой базы данных EPSG

 

_MAPIMP void _MAPAPI mapCloseEPSGDatabase(HANDLE epsgdata);     

 

  // Возвращает количество прямоугольных систем координат в базе данных EPSG

  // epsgdata - идентификатор открытой базы данных EPSG

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGProjectedSystemCount(HANDLE epsgdata);

 

  // Возвращает количество геодезических систем координат в базе данных EPSG

  // epsgdata - идентификатор открытой базы данных EPSG

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGGeodeticSystemCount(HANDLE epsgdata);

  

 

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

  // После вызова функции текущей становится следующая система координат в базе данных EPSG

  // epsgdata  - идентификатор открытой базы данных EPSG

  // mapreg    - параметры проекции

  // ellipsoid - эллипсоид

  // datum     - датум

  // rectsys   - параметры прямоугольной системы координат

  // geodsys   - параметры базовой геодезической системы координат

  // unit      - единицы измерения

  // При ошибке или при выходе за границы набора данных возвращает 0

 

_MAPIMP long int _MAPAPI mapReadEPSGProjectedSystem(HANDLE epsgdata, MAPREGISTEREX *mapreg,

                                                    ELLIPSOIDPARAM *ellipsoid,

                                                    DATUMPARAM *datum, EPSGRECTSYS *rectsys,

                                                    EPSGGEODSYS *geodsys, EPSGMEASUNIT *unit);

 

  // Считать данные на прямоугольную систему координат по номеру записи в базе данных EPSG   // 24/03/11

  // После вызова функции текущей становится следующая система координат в базе данных EPSG

  // epsgdata    - идентификатор открытой базы данных EPSG

  // coordsysnum - номер записи в списке прямоугольных систем координат (от 1)

  // mapreg      - параметры проекции

  // ellipsoid   - эллипсоид

  // datum       - датум

  // rectsys     - параметры прямоугольной системы координат

  // geodsys     - параметры базовой геодезической системы координат

  // unit        - единицы измерения

  // При ошибке или при выходе за границы набора данных возвращает 0

 

_MAPIMP long int _MAPAPI mapReadEPSGProjectedSystemByNumber(HANDLE epsgdata, long int coordsysnum,

                                                            MAPREGISTEREX *mapreg,

                                                            ELLIPSOIDPARAM *ellipsoid,

                                                            DATUMPARAM *datum, EPSGRECTSYS *rectsys,

                                                            EPSGGEODSYS *geodsys, EPSGMEASUNIT *unit);

 

   // Считать параметры геодезической системы координат по порядковому номеру в базе данных EPSG

  // epsgdata    - идентификатор открытой базы данных EPSG

  // coordsysnum - порядковый номер геодезической системы координат в базе данных EPSG (от 1)

  // ellipsoid   - возвращаемые параметры эллипсоида (может быть равен 0)

  // datum       - параметры эллипсоида (может быть равен 0)

  // geodsys     - параметры геодезической СК (может быть равен 0)

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapReadEPSGGeodeticSystemByNumber(HANDLE epsgdata, long int coordsysnum,

                                                           ELLIPSOIDPARAM *ellipsoid, DATUMPARAM *datum,

                                                           EPSGGEODSYS *geodsys);

 

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

  // epsgcode  - код геодезической системы координат в базе данных EPSG

  // ellipsoid - параметры эллипсоида

  // datum     - параметры датума

  // geodsys   - параметры геодезической СК

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGGeodeticSystem(long int epsgcode, ELLIPSOIDPARAM *ellipsoid,

                                          DATUMPARAM *datum, EPSGGEODSYS *geodsys);

 

   // Запросить параметры геодезической системы координат по имени в базе данных EPSG

  // name      - имя геодезической системы координат

  // ellipsoid - параметры эллипсоида

  // datum     - параметры датума

  // geodsys   - параметры геодезической СК

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGGeodeticSystemByName(const char *name, ELLIPSOIDPARAM *ellipsoid,

                                                        DATUMPARAM *datum, EPSGGEODSYS *geodsys);

 

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

  // epsgcode - код прямоугольной системы координат в базе данных EPSG

  // mapreg   - параметры проекции

  // rectsys  - параметры прямоугольной СК

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGProjectedSystem(long int epsgcode, MAPREGISTEREX *mapreg,

                                           EPSGRECTSYS *rectsys);

 

  // Запросить параметры единицы измерения по коду в базе данных EPSG

  // epsgcode - код единицы измерения в базе данных EPSG

  // unit     - параметры единицы измерения

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapGetEPSGUnit(long int epsgcode, EPSGMEASUNIT *unit);

 

  // Заполнить WKT строку из MAPREGISTEREX, ELLIPSOIDPARAM, DATUMPARAM 

  // mapreg    - параметры проекции

  // ellipsoid - параметры эллипсоида

  // datum     - параметры датума

  // wktstr    - заполняемая строка с описанием системы координат

  // wktstrsize - зарезервированный размер строки (4 Кбайта достаточно)

  // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapSetWKTString(MAPREGISTEREX *mapreg, ELLIPSOIDPARAM *ellipsoid, DATUMPARAM *datum,

                                         char *wktstr, long int wktstrsize);

 

 

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

  *                                                              *

  *  ФУНКЦИИ ЧТЕНИЯ ПАРАМЕТРОВ СИСТЕМ ОТСЧЕТА ИЗ СПИСКА В ФАЙЛЕ  *

  *                                                              *

  ****************************************************************

  * <?xml version="1.0" encoding="UTF-8"?>                       *

  * <ProjectList Version="1.0">                                  *

  * <Project Name="ITM"                                          *

  * Comment="Israel Transverse Mercator"                         *

  * EPSG="2039">                                                 *

  * <Projection Type="Transverse Mercator"                       *

  * EPSG="9807"                                                  *

  * CentralMeridian="31 44 3.816999999992845"                    *

  * LatitudeOfOrigin="35 12 16.260999999993260"                  *

  * ScaleFactor="1.0000067"                                      *

  * FalseEasting="219529.584"                                    *

  * FalseNothing="626907.3899999999"/>                           *

  * <Spheroid Type="GRS 1980" Parm="6378137.0 298.257222101"/>   *

  * </Project>                                                   *

  * </ProjectList>                                               *

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

 

 // Открыть список параметров систем отсчета                     

 // name - имя файла списка параметров

 // При успешном выполнении возвращает идентификатор списка в памяти

 // При ошибке возвращает ноль

 

_MAPIMP HMAPREG _MAPAPI mapOpenMapRegisterList(const char * name);

 

_MAPIMP HMAPREG _MAPAPI mapOpenMapRegisterListUn(const WCHAR *name);

 

 // Создать список параметров систем отсчета

 // name - имя файла списка параметров

 // При успешном выполнении возвращает идентификатор списка в памяти

 // При ошибке возвращает ноль

 

_MAPIMP HMAPREG _MAPAPI mapCreateMapRegisterList(const char * name);

 

_MAPIMP HMAPREG _MAPAPI mapCreateMapRegisterListUn(const WCHAR *name);

 

 // Закрыть список параметров систем отсчета

 // hmapreg - идентификатор списка параметров систем отсчета

 

_MAPIMP void _MAPAPI mapCloseMapRegisterList(HMAPREG hmapreg);

 

 // Запросить число систем отсчета, хранящихся в списке          

 // в виде файла XML (<ProjectList Version="1.0">

 // Одной системе соответствует один тэг "Project"

 // hmapreg - идентификатор списка параметров систем отсчета

 // При успешном выполнении возвращает число записей параметров

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListCount(HMAPREG hmapreg);

 

 // Запросить название системы отсчета по заданному порядковому номеру

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // name    - адрес строки для размещения результата

 // size    - размер выделенной строки в байтах

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListName(HMAPREG hmapreg, long int number,

                                                char * name, int size);

 

_MAPIMP long int _MAPAPI mapMapRegisterListNameUn(HMAPREG hmapreg, long int number,

                                                  WCHAR *name, int size);

 

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

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // name    - адрес строки для размещения результата

 // size    - длина выделенной строки для размещения результата

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListComment(HMAPREG hmapreg, long int number,

                                                   char * name, int size);

 

_MAPIMP long int _MAPAPI mapMapRegisterListCommentUn(HMAPREG hmapreg, long int number,

                                                     WCHAR *name, int size);

 

 // Запросить порядковый номер в списке (начиная с 1)               // 05/04/14

 // по коду EPSG для системы отсчета (CRS)

 // hmapreg - идентификатор списка параметров систем отсчета

 // epsg    - код EPSG для системы отсчета (CRS)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSeekMapRegisterListByEPSG(HMAPREG hmapreg, long int epsg);

 

 // Запросить код EPSG для системы отсчета по заданному порядковому номеру

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // Если код не задан - возвращает "-1"

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListEPSG(HMAPREG hmapreg, long int number);

 

 // Запросить идентификатор для системы отсчета                        

 // по заданному порядковому номеру в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // ident   - адрес строки для размещения идентификатора

 // size    - длина выделенной строки для размещения идентификатора

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListCrsIdent(HMAPREG hmapreg, long int number,

                                                    char * ident, int size);

 

_MAPIMP long int _MAPAPI mapMapRegisterListCrsIdentUn(HMAPREG hmapreg, long int number,

                                                      WCHAR *ident, int size);

 

 // Запросить параметры системы отсчета по заданному порядковому номеру

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // mapreg  - параметры проекции <Projection ...>

 // datum   - параметры датума <Datum ...>

 // ellparm - параметры эллипсоида <Spheroid ...>

 // ttype   - адрес поля для записи типа локального преобразования координат (см. TRANSFORMTYPE в mapcreat.h) или 0

 // tparm   - параметры локального преобразования координат (см. mapcreat.h) 

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapMapRegisterListParametersPro(HMAPREG hmapreg, long int number,

                                                         MAPREGISTEREX * mapreg,

                                                         DATUMPARAM * datum,

                                                         ELLIPSOIDPARAM * ellparm,

                                                         long int * ttype,

                                                         LOCALTRANSFORM * tparm);

 

_MAPIMP long int _MAPAPI mapMapRegisterListParameters(HMAPREG hmapreg, long int number,

                                                      MAPREGISTEREX * mapreg,

                                                      DATUMPARAM * datum,

                                                      ELLIPSOIDPARAM * ellparm);

 

 // Добавить запись параметров системы отсчета

 // hmapreg - идентификатор списка параметров систем отсчета

 // name     - уникальное название системы отсчета (обязательно)

 // comment  - комментарий для системы отсчета (или ноль)

 // epsgcode - код EPSG (или ноль)

 // ident   - идентификатор системы отсчета (или ноль)

 // mapreg   - описание параметров системы отсчета (обязательно)(см. mapcreat.h)

 // datum    - описание параметров датума (или ноль) (см. mapcreat.h)

 // ellparam - описание параметров эллипсоида (или ноль) (см. mapcreat.h)

 // ttype   - тип локального преобразования координат (см. TRANSFORMTYPE в mapcreat.h) или 0

 // tparm   - параметры локального преобразования координат (см. mapcreat.h) 

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapAppendMapRegisterListParametersPro(HMAPREG hmapreg,

                                                               const WCHAR *name,

                                                               const WCHAR *comment,

                                                               long int epsgcode,

                                                               const WCHAR *ident,

                                                               MAPREGISTEREX *mapreg,

                                                               DATUMPARAM *datum,

                                                               ELLIPSOIDPARAM *ellparm,

                                                               long int ttype,

                                                               LOCALTRANSFORM * tparm);

 

_MAPIMP long int _MAPAPI mapAppendMapRegisterListParameters(HMAPREG hmapreg,

                                                            const char * name,

                                                            const char * comment,

                                                            long int epsgcode,

                                                            MAPREGISTEREX * mapreg,

                                                            DATUMPARAM * datum,

                                                            ELLIPSOIDPARAM * ellparm);

  

_MAPIMP long int _MAPAPI mapAppendMapRegisterListParametersEx(HMAPREG hmapreg,

                                                            const char * name,

                                                            const char * comment,

                                                            long int epsgcode,

                                                            const char * ident,

                                                            MAPREGISTEREX * mapreg,

                                                            DATUMPARAM * datum,

                                                            ELLIPSOIDPARAM * ellparm);

 

_MAPIMP long int _MAPAPI mapAppendMapRegisterListParametersUn(HMAPREG hmapreg,

                                                              const WCHAR *name,

                                                              const WCHAR *comment,

                                                              long int epsgcode,

                                                              const WCHAR *ident,

                                                              MAPREGISTEREX *mapreg,

                                                              DATUMPARAM *datum,

                                                              ELLIPSOIDPARAM *ellparm);

 

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

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // Для немедленного изменения данных в файле нужно вызвать

 // функцию mapCommitMapRegisterList

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDeleteMapRegisterListParameters(HMAPREG hmapreg, long int number);

 

 // Обновить название, комментарий и код системы отсчета по заданному порядковому номеру

 // в списке (начиная с 1)

 // hmapreg - идентификатор списка параметров систем отсчета

 // number  - порядковый номер записи параметров

 // name    - название системы отсчета или 0 (не менять)

 // comment - комментарий к системе отсчета или 0 (не менять)

 // code    - код EPSG или 0 (не менять)

 // ident   - идентификатор системы отсчета или 0 (не менять)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapUpdateMapRegisterListName(HMAPREG hmapreg, long int number,

                                                      const char *name,

                                                      const char *comment,

                                                      long int code);

 

_MAPIMP long int _MAPAPI mapUpdateMapRegisterListNameEx(HMAPREG hmapreg, long int number,

                                                        const char *name,

                                                        const char *comment,

                                                        long int code,

                                                        const char *ident);

 

_MAPIMP long int _MAPAPI mapUpdateMapRegisterListNameUn(HMAPREG hmapreg, long int number,

                                                        const WCHAR *name,

                                                        const WCHAR *comment,

                                                        long int code, const WCHAR *ident);

 

 // Сохранить изменения списка параметров систем отсчета в файле

 // hmapreg - идентификатор списка параметров систем отсчета

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapCommitMapRegisterList(HMAPREG hmapreg);

 

 // Отменить изменения списка параметров систем отсчета в памяти

 // Отмена изменений может быть выполнена до вызова mapCommitMapRegisterList

 // hmapreg - идентификатор списка параметров систем отсчета

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapUndoMapRegisterList(HMAPREG hmapreg);

 

 

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

  *                                                        *

  *     ФУНКЦИИ ЗАПРОСА ИНФОРМАЦИИ ОБ ОБЪЕКТЕ КАРТЫ        *

  *                                                        *

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

 

 // Запросить название листа на котором расположен объект

 // info - идентификатор объекта карты в памяти

 // name - адрес буфера для результата запроса

 // size - размер буфера в байтах

 // При ошибке возвращает ноль 

 

_MAPIMP const char * _MAPAPI mapListName(HOBJ info);

_MAPIMP long int _MAPAPI mapListNameEx(HOBJ info, char * name, long int size);

_MAPIMP long int _MAPAPI mapListNameUn(HOBJ info, WCHAR * name, long int size);

 

 // Запросить идентификатор классификатора карты, содержащей объект            

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает ноль

 

_MAPIMP HRSC _MAPAPI mapGetRscIdentByObject(HOBJ info);

 

 // Запросить уникальный номер объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает 0                                                          

 

_MAPIMP long int _MAPAPI mapObjectKey(HOBJ info);

 

 // Установить уникальный номер объекта

 // info - идентификатор объекта карты в памяти

 // number - уникальный номер объекта в листе

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

 // уникальность номеров в листе !

 // При ошибке возвращает 0                                                         

 

_MAPIMP long int _MAPAPI mapSetObjectKey(HOBJ info, long int number);

 

 // Запросить классификационный код объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает 0 (ноль допустим для нового объекта)

 

_MAPIMP long int _MAPAPI mapObjectExcode(HOBJ info);

 

 // Запросить характер локализации объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает 0  (ноль допустим)

 

_MAPIMP long int _MAPAPI mapObjectLocal(HOBJ info);

 

 // Запросить условное название объекта

 // info - идентификатор объекта карты в памяти

 // name - адрес буфера для результата запроса

 // size - размер буфера в байтах

 // При ошибке возвращает ноль

 

_MAPIMP const char * _MAPAPI mapObjectName(HOBJ info);

_MAPIMP long int _MAPAPI mapObjectNameEx(HOBJ info,char * name,long int size);

 

_MAPIMP long int _MAPAPI mapObjectNameUn(HOBJ info, WCHAR * name, long int size);

 

 // Запросить максимальный размер условного названия объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapObjectNameSize(HOBJ info);

 

 // Сформировать строку с описанием объекта в виде

 // "номер_объекта - имя_объекта - имя_слоя - имя_листа_карты"

 // info - идентификатор объекта карты в памяти

 // comment - адрес буфера для результата запроса

 // size - размер буфера в байтах

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapObjectComment(HOBJ info, WCHAR * comment, long int size);

 

 // Запросить направление цифрования объекта

 //  info - идентификатор объекта карты в памяти

 // Возвращает:                                        

 //  OD_UNDEFINED (1) - не определено (незамкнутый контур или контур,

 //                     вырожденный в точку или контур, имеющий "петли")

 //  0D_RIGHT     (2) - объект справа (основной контур замкнутого объекта

 //                     по часовой стрелке)

 //  0D_LEFT      (4) - объект слева (основной контур замкнутого объекта

 //                     против часовой стрелки)

 // (см. OBJECT_DIRECT в Maptype.h) // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapObjectDirect(HOBJ info);

 

 // Запросить направление цифрования объекта

//  info    - идентификатор объекта карты в памяти

 //  subject - номер подобъекта (для объекта - равен нулю)

 // Возвращает:                                        

 //  OD_UNDEFINED (1) - не определено (незамкнутый контур или контур,

 //                     вырожденный в точку или контур, имеющий "петли")

 //  0D_RIGHT     (2) - объект справа (замкнутый контур объекта

 //                     по часовой стрелке)

 //  0D_LEFT      (4) - объект слева (замкнутый контур объекта

 //                     против часовой стрелки)

 // (см. OBJECT_DIRECT в Maptype.h)

 // При ошибке возвращает ноль

 

 _MAPIMP long int _MAPAPI mapSubjectDirect(HOBJ info, long int subject);

 

 // Запросить номер слоя объекта ("Layer" = "Segment")

 // Номера слоев начинаются с ноля !

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSegmentNumber(HOBJ info);

 

 // Запросить название слоя объекта ("Layer" = "Segment")

 // info - идентификатор объекта карты в памяти

 // name - адрес буфера для результата запроса

 // size - размер буфера

 // При ошибке возвращает ноль

 

_MAPIMP const char * _MAPAPI mapSegmentName(HOBJ info);

_MAPIMP long int _MAPAPI mapSegmentNameEx(HOBJ info,char * name,long int size);

_MAPIMP long int _MAPAPI mapSegmentNameUn(HOBJ info,WCHAR * name,long int size);

 

 // Запросить максимальный размер названи слоя объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSegmentNameSize(HOBJ info);

 

 // Запросить индекс (внутренний код) объекта

 // info - идентификатор объекта карты в памяти

 // При ошибке возвращает 0 (ноль допустим для нового объекта)

 

_MAPIMP long int _MAPAPI mapObjectCode(HOBJ info);

 

 // Запросить уникальный идентификатор объекта GUID

 // Идентификатор GUID может автоматически присваиваться объектам карты,

 // если установлен признак ведения GUID (mapSetAutoObjectGUID)

 // info  - идентификатор объекта карты в памяти

 // ident - поле для записи идентификатора (32 шестнадцатеричных символов от 0 до F)

 // size  - размер поля в байтах

 // Идентификатор хранится в семантике объекта с кодом 32799

 // При ошибке возвращает 0

 

_MAPIMP long int _MAPAPI mapObjectGUID(HOBJ info, char * ident, long int size);

 

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

 // объектов

 // info - идентификатор объекта карты в памяти

 

_MAPIMP void _MAPAPI mapClearBotTop(HOBJ info);

 

 // Запросить/Установить диапазон масштабов видимости объекта

 // scale - масштаб отображения от 1:1 до 1:40 млн.

 // info - идентификатор объекта карты в памяти

 

_MAPIMP long int _MAPAPI mapObjectTopScale(HOBJ info);

_MAPIMP long int _MAPAPI mapSetObjectTopScale(HOBJ info,long int scale);

_MAPIMP long int _MAPAPI mapObjectBotScale(HOBJ info);

_MAPIMP long int _MAPAPI mapSetObjectBotScale(HOBJ info,long int scale);

 

 // Запросить - являются ли значения границ видимости у объекта

 // уникальными (то есть установленными не из классификатора,

 // а персональными для данного экземпляра)

 // Если границы видимости беруться из классификатора - возвращает 0

 

_MAPIMP long int _MAPAPI mapObjectBotTopUniqueness(HOBJ info);

 

 // Сформировать описание нового объекта по внешнему коду и локализации

 // или изменить код существующего объекта на карте

 // info - идентификатор объекта карты в памяти

 // excode - внешний код объекта (числовой),

 // local  - локализация (LOCAL_LINE, LOCAL_POINT...)

 // Обычно вызывается после mapCreateObject(...) и добавления семантики

 // (если она есть)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRegisterObject(HOBJ info, long int excode,

                                           long int local);

 

 // Сформировать описание нового объекта по короткому имени объекта

 // (ключу) или изменить код существующего объекта на карте

 // info - идентификатор объекта карты в памяти

 // name - символьный код объекта в классификаторе (до 31 символа)

 // Обычно вызывается после mapCreateObject(...)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRegisterObjectByKey(HOBJ info, const char *name);

 

 // Сформировать описание нового объекта

 // по внутреннему коду объекта (см. mapRscObjectCode() и т.п.)

 // или изменить код существующего объекта на карте

 // info - идентификатор объекта карты в памяти

 // Обычно вызывается после mapCreateObject(...) и добавления

 // семантики (если она есть)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapDescribeObject(HOBJ info, long int code);

 

 // Сформировать описание нового графического объекта

 // по номеру слоя (из классификатора карты) и локализации

 // info - идентификатор объекта карты в памяти

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

 // local  - локализация (LOCAL_LINE, LOCAL_POINT..., см. maptype.h)

 // Вызывается после mapCreateObject(...)

 // Для формирования условного знака необходимо

 // использовать функцию mapAppendDraw(...)

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapRegisterDrawObject(HOBJ info, long int layer,

                                               long int local);

 

 // Установить номер листа для нового объекта

 // info - идентификатор объекта карты в памяти

 // list - последовательный номер листа (с 1)

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

 // При ошибке возвращает ноль

 

_MAPIMP long int _MAPAPI mapSetObjectListNumber(HOBJ info, long int list);

<