constructor(id, options) {

super();

if (Util.isObject(id)) {

options = id;

this.mapId = options.id;

} else {

this.mapId = id;

}

options = options || {};

this.server = options.server;

this.successCallback = options.successCallback;

this.errorCallback = options.errorCallback;

this.credentialKey = options.credentialKey;

this.credentialValue = options.credentialValue;

this.target = options.target || 'map';

this.serviceProxy = options.serviceProxy || null;

this.tiandituKey = options.tiandituKey;

this.bingMapsKey = options.bingMapsKey || '';

this.googleMapsAPIKey = options.googleMapsAPIKey || '';

this.proxy = options.proxy;

//计数叠加图层，处理过的数量（成功和失败都会计数）

this.layerAdded = 0;

this.layers = [];

this.events = new Events(this, null, ['updateDataflowFeature'], true);

this.webMap = options.webMap;

this.tileFormat = options.tileFormat && options.tileFormat.toLowerCase();

this.restDataSingleRequestCount = options.restDataSingleRequestCount || 1000;

this.overflowTiles = typeof options.overflowTiles === 'undefined' ? 1 : options.overflowTiles;

this.tileRequestParameters = options.tileRequestParameters;

this.createMap(options.mapSetting);

if (this.webMap) {

// webmap有可能是url地址，有可能是webmap对象

Util.isString(this.webMap) ? this.createWebmap(this.webMap) : this.getMapInfoSuccess(options.webMap);

} else {

this.createWebmap();

}

}

/**

_removeBaseLayer() {

const map = this.map;

const { layer, labelLayer } = this.baseLayer;

// 移除天地图标签图层

labelLayer && map.removeLayer(labelLayer);

// 移除图层

layer && map.removeLayer(layer);

this.baseLayer = null;

}

/**

_removeLayers() {

const map = this.map;

this.layers.forEach(({ layerType, layer, labelLayer, pathLayer, dataflowService }) => {

if (!layer) {

return;

}

if (layerType === 'MIGRATION') {

layer.remove();

return;

}

if (layerType === 'DATAFLOW_POINT_TRACK' || layerType === 'DATAFLOW_HEAT') {

// 移除轨迹图层

pathLayer && map.removeLayer(pathLayer);

// 取消订阅

dataflowService && dataflowService.unSubscribe();

}

// 移除标签图层

labelLayer && map.removeLayer(labelLayer);

// 移除图层

map.removeLayer(layer);

});

this.layers = [];

}

/**

_clear() {

// 比例尺

this.scales = [];

// 分辨率

this.resolutionArray = [];

// 比例尺-分辨率 {scale: resolution}

this.resolutions = {};

// 计数叠加图层，处理过的数量（成功和失败都会计数）

this.layerAdded = 0;

this._removeBaseLayer();

this._removeLayers();

}

/**

refresh() {

this._clear();

this.createWebmap();

}

/**

createMap(mapSetting) {

let overlays, controls, interactions;

if (mapSetting) {

interactions = mapSetting.interactions;

overlays = mapSetting.overlays;

controls = mapSetting.controls;

}

this.map = new olMap({

interactions: interactions,

overlays: overlays,

controls: controls,

target: this.target

});

mapSetting &&

this.registerMapEvent({

mapClickCallback: mapSetting.mapClickCallback

});

}

/**

registerMapEvent(mapSetting) {

let map = this.map;

map.on('click', function (evt) {

mapSetting.mapClickCallback && mapSetting.mapClickCallback(evt);

});

}

/**

createWebmap(webMapUrl) {

let mapUrl;

if (webMapUrl) {

mapUrl = webMapUrl;

} else {

let urlArr = this.server.split('');

if (urlArr[urlArr.length - 1] !== '/') {

this.server += '/';

}

mapUrl = this.server + 'web/maps/' + this.mapId + '/map';

let filter = 'getUrlResource.json?url=';

if (this.server.indexOf(filter) > -1) {

//大屏需求,或者有加上代理的

let urlArray = this.server.split(filter);

if (urlArray.length > 1) {

mapUrl = urlArray[0] + filter + this.server + 'web/maps/' + this.mapId + '/map.json';

}

}

}

this.getMapInfo(mapUrl);

}

/**

getMapInfo(url) {

let that = this,

mapUrl = url;

if (url.indexOf('.json') === -1) {

url = this.handleJSONSuffix(url);

//传递过来的url,没有包括.json,在这里加上。

mapUrl = url;

}

FetchRequest.get(that.getRequestUrl(mapUrl), null, {

withCredentials: that.isCredentail(mapUrl)

})

.then(function (response) {

return response.json();

})

.then(function (mapInfo) {

that.getMapInfoSuccess(mapInfo);

})

.catch(function (error) {

that.errorCallback && that.errorCallback(error, 'getMapFaild', that.map);

});

}

/**

async getMapInfoSuccess(mapInfo) {

let that = this;

if (mapInfo.succeed === false) {

that.errorCallback && that.errorCallback(mapInfo.error, 'getMapFaild', that.map);

return;

}

let handleResult = await that.handleCRS(mapInfo.projection, mapInfo.baseLayer.url);

//存储地图的名称以及描述等信息，返回给用户

that.mapParams = {

title: mapInfo.title,

description: mapInfo.description

};

if (handleResult.action === 'BrowseMap') {

that.createSpecLayer(mapInfo);

} else if (handleResult.action === 'OpenMap') {

that.baseProjection = handleResult.newCrs || mapInfo.projection;

that.webMapVersion = mapInfo.version;

that.baseLayer = mapInfo.baseLayer;

// that.mapParams = {

// title: mapInfo.title,

// description: mapInfo.description

// }; //存储地图的名称以及描述等信息，返回给用户

that.isHaveGraticule = mapInfo.grid && mapInfo.grid.graticule;

if (mapInfo.baseLayer && mapInfo.baseLayer.layerType === 'MAPBOXSTYLE') {

// 添加矢量瓦片服务作为底图

that

.addMVTMapLayer(mapInfo, mapInfo.baseLayer, 0)

.then(async () => {

that.createView(mapInfo);

if (!mapInfo.layers || mapInfo.layers.length === 0) {

that.sendMapToUser(0);

} else {

await that.addLayers(mapInfo);

}

that.addGraticule(mapInfo);

})

.catch(function (error) {

that.errorCallback && that.errorCallback(error, 'getMapFaild', that.map);

});

} else {

await that.addBaseMap(mapInfo);

if (!mapInfo.layers || mapInfo.layers.length === 0) {

that.sendMapToUser(0);

} else {

await that.addLayers(mapInfo);

}

that.addGraticule(mapInfo);

}

}

}

/**

async handleCRS(crs, baseLayerUrl) {

let that = this,

handleResult = {};

let newCrs = crs,

action = 'OpenMap';

if (this.isCustomProjection(crs)) {

// 去iServer请求wkt 否则只能预览出图

await FetchRequest.get(that.getRequestUrl(`${baseLayerUrl}/prjCoordSys.wkt`), null, {

withCredentials: that.isCredentail(baseLayerUrl),

withoutFormatSuffix: true

})

.then(function (response) {

return response.text();

})

.then(async function (result) {

if (result.indexOf('<!doctype html>') === -1) {

that.addProjctionFromWKT(result, crs);

handleResult = { action, newCrs };

} else {

throw 'ERROR';

}

})

.catch(function () {

action = 'BrowseMap';

handleResult = { action, newCrs };

});

} else {

if (crs.indexOf('EPSG') === 0 && crs.split(':')[1] <= 0) {

// 自定义坐标系 rest map EPSG:-1(自定义坐标系) 支持编辑

// 未知坐标系情况特殊处理，只支持预览 1、rest map EPSG:-1000(没定义坐标系) 2、wms/wmts EPSG:0 （自定义坐标系）

action = 'BrowseMap';

} else if (crs === 'EPSG:910111' || crs === 'EPSG:910112') {

// 早期数据存在的自定义坐标系 "EPSG:910111": "GCJ02MERCATOR"， "EPSG:910112": "BDMERCATOR"

newCrs = 'EPSG:3857';

} else if (crs === 'EPSG:910101' || crs === 'EPSG:910102') {

// 早期数据存在的自定义坐标系 "EPSG:910101": "GCJ02", "EPSG:910102": "BD",

newCrs = 'EPSG:4326';

} else if (crs.indexOf('EPSG') !== 0) {

// wkt

that.addProjctionFromWKT(newCrs);

newCrs = that.getEpsgInfoFromWKT(crs);

}

handleResult = { action, newCrs };

}

return handleResult;

}

/**

getScales(baseLayerInfo) {

let scales = [],

resolutions = {},

res,

scale,

resolutionArray = [],

coordUnit = baseLayerInfo.coordUnit || baseLayerInfo.units || olProj.get(baseLayerInfo.projection).getUnits();

if (!coordUnit) {

coordUnit = this.baseProjection == 'EPSG:3857' ? 'm' : 'degree';

}

if (baseLayerInfo.visibleScales && baseLayerInfo.visibleScales.length > 0) {

//底部设置过固定比例尺，则使用设置的

baseLayerInfo.visibleScales.forEach((scale) => {

let value = 1 / scale;

res = this.getResFromScale(value, coordUnit);

scale = `1:${value}`;

//多此一举转换，因为toLocalString会自动保留小数点后三位，and当第二位小数是0就会保存小数点后两位。所有为了统一。

resolutions[this.formatScale(scale)] = res;

resolutionArray.push(res);

scales.push(scale);

}, this);

} else if (baseLayerInfo.layerType === 'WMTS') {

baseLayerInfo.scales.forEach((scale) => {

res = this.getResFromScale(scale, coordUnit, 90.7);

scale = `1:${scale}`;

//多此一举转换，因为toLocalString会自动保留小数点后三位，and当第二位小数是0就会保存小数点后两位。所有为了统一。

resolutions[this.formatScale(scale)] = res;

resolutionArray.push(res);

scales.push(scale);

}, this);

} else if(baseLayerInfo.layerType === 'ZXY_TILE') {

const { resolutions: visibleResolution } = baseLayerInfo;

visibleResolution.forEach(result => {

const currentScale = this.getScaleFromRes(result, coordUnit);

resolutions[this.formatScale(currentScale)] = result;

scales.push(currentScale);

})

resolutionArray = visibleResolution;

} else {

let { minZoom = 0, maxZoom = 22 } = baseLayerInfo,

view = this.map.getView();

for (let i = minZoom; i <= maxZoom; i++) {

res = view.getResolutionForZoom(i);

scale = this.getScaleFromRes(res, coordUnit);

if (scales.indexOf(scale) === -1) {

//不添加重复的比例尺

scales.push(scale);

let attr = scale.replace(/,/g, '');

resolutions[attr] = res;

resolutionArray.push(res);

}

}

}

this.scales = scales;

this.resolutions = resolutions;

this.resolutionArray = resolutionArray;

}

/**

getResFromScale(scale, coordUnit = 'DEGREE', dpi = 96) {

let mpu = metersPerUnit[coordUnit.toUpperCase()];

return (scale * 0.0254) / dpi / mpu;

}

/**

getScaleFromRes(resolution, coordUnit = 'DEGREE', dpi = 96) {

let scale,

mpu = metersPerUnit[coordUnit.toUpperCase()];

scale = (resolution * dpi * mpu) / 0.0254;

return '1:' + scale;

}

/**

formatScale(scale) {

return scale.replace(/,/g, '');

}

/**

createSpecLayer(mapInfo) {

let me = this,

baseLayerInfo = mapInfo.baseLayer,

url = baseLayerInfo.url,

baseLayerType = baseLayerInfo.layerType;

let extent = [

mapInfo.extent.leftBottom.x,

mapInfo.extent.leftBottom.y,

mapInfo.extent.rightTop.x,

mapInfo.extent.rightTop.y

];

let proj = new olProj.Projection({

extent,

units: 'm',

code: 'EPSG:0'

});

olProj.addProjection(proj);

let options = {

center: mapInfo.center,

level: 0

};

//添加view

me.baseProjection = proj;

let viewOptions = {

center: options.center ? [options.center.x, options.center.y] : [0, 0],

zoom: 0,

projection: proj

};

if (['4', '5'].indexOf(Util.getOlVersion()) < 0) {

// 兼容 ol 4，5，6

viewOptions.multiWorld = true;

}

let view = new View(viewOptions);

me.map.setView(view);

if (me.mapParams) {

me.mapParams.extent = extent;

me.mapParams.projection = mapInfo.projection;

}

if (url && url.indexOf('?token=') > -1) {

//兼容iserver地址有token的情况

me.credentialKey = 'token';

me.credentialValue = mapInfo.baseLayer.credential = url.split('?token=')[1];

url = url.split('?token=')[0];

}

let source;

if (baseLayerType === 'TILE') {

url = this.handleJSONSuffix(url);

FetchRequest.get(me.getRequestUrl(url), null, {

withCredentials: me.isCredentail(url)

})

.then(function (response) {

return response.json();

})

.then(function (result) {

baseLayerInfo.originResult = result;

let serverType = 'IPORTAL',

credential = baseLayerInfo.credential,

keyfix = 'Token',

keyParams = baseLayerInfo.url;

if (

baseLayerInfo.url.indexOf('www.supermapol.com') > -1 ||

baseLayerInfo.url.indexOf('itest.supermapol.com') > -1

) {

keyfix = 'Key';

keyParams = [keyParams];

serverType = 'ONLINE';

}

if (credential) {

SecurityManager[`register${keyfix}`](keyParams, credential);

}

let options = {

serverType,

url,

tileGrid: TileSuperMapRest.optionsFromMapJSON(url, result).tileGrid,

tileLoadFunction: me.getCustomTileLoadFunction()

};

if (url && me.isAddProxy(url)) {

options.tileProxy = me.server + 'apps/viewer/getUrlResource.png?url=';

}

source = new TileSuperMapRest(options);

me.addSpecToMap(source);

})

.catch(function (error) {

me.errorCallback && me.errorCallback(error, 'getMapFaild', me.map);

});

} else if (baseLayerType === 'WMS') {

source = me.createWMSSource(baseLayerInfo);

me.addSpecToMap(source);

} else if (baseLayerType === 'WMTS') {

FetchRequest.get(me.getRequestUrl(url), null, {

withCredentials: me.isCredentail(url)

})

.then(function (response) {

return response.text();

})

.then(function (capabilitiesText) {

baseLayerInfo.extent = [

mapInfo.extent.leftBottom.x,

mapInfo.extent.leftBottom.y,

mapInfo.extent.rightTop.x,

mapInfo.extent.rightTop.y

];

baseLayerInfo.scales = me.getWMTSScales(baseLayerInfo.tileMatrixSet, capabilitiesText);

baseLayerInfo.dpi = dpiConfig.iServerWMTS;

source = me.createWMTSSource(baseLayerInfo);

me.addSpecToMap(source);

})

.catch(function (error) {

me.errorCallback && me.errorCallback(error, 'getMapFaild', me.map);

});

} else {

me.errorCallback &&

me.errorCallback(

{ type: 'Not support CS', errorMsg: `Not support CS: ${baseLayerType}` },

'getMapFaild',

me.map

);

}

view && view.fit(extent);

}

/**

addSpecToMap(source) {

let layer = new olLayer.Tile({

source: source,

zIndex: 0

});

this.map.addLayer(layer);

this.sendMapToUser(0);

}

/**

getWMTSScales(identifier, capabilitiesText) {

const parser = new XMLParser({

attributeNamePrefix: '',

ignoreAttributes: false,

removeNSPrefix: true,

isArray: (name, jpath) => {

return WMTS_ARRAY_NODE_PATHS.includes(jpath);

}

});

const capabilities = parser.parse(capabilitiesText).Capabilities;

let content = capabilities.Contents;

let tileMatrixSet = content.TileMatrixSet;

let scales = [];

for (let i = 0; i < tileMatrixSet.length; i++) {

if (tileMatrixSet[i].Identifier === identifier) {

for (let h = 0; h < tileMatrixSet[i].TileMatrix.length; h++) {

scales.push(tileMatrixSet[i].TileMatrix[h].ScaleDenominator);

}

break;

}

}

return scales;

}

/**

async addBaseMap(mapInfo) {

let { baseLayer } = mapInfo,

layerType = baseLayer.layerType;

//底图，使用默认的配置，不用存储的

if (layerType !== 'TILE' && layerType !== 'WMS' && layerType !== 'WMTS') {

this.getInternetMapInfo(baseLayer);

} else if (layerType === 'WMTS') {

// 通过请求完善信息

await this.getWmtsInfo(baseLayer);

} else if (layerType === 'TILE') {

await this.getTileInfo(baseLayer);

} else if (layerType === 'WMS') {

await this.getWmsInfo(baseLayer);

}

baseLayer.projection = mapInfo.projection;

if (!baseLayer.extent) {

baseLayer.extent = [

mapInfo.extent.leftBottom.x,

mapInfo.extent.leftBottom.y,

mapInfo.extent.rightTop.x,

mapInfo.extent.rightTop.y

];

}

this.createView(mapInfo);

let layer = this.createBaseLayer(baseLayer, 0, null, null, true);

//底图增加图层类型，DV分享需要用它来识别版权信息

layer.setProperties({

layerType: layerType

});

this.map.addLayer(layer);

if (this.mapParams) {

this.mapParams.extent = baseLayer.extent;

this.mapParams.projection = mapInfo.projection;

}

if (baseLayer.labelLayerVisible) {

//存在天地图路网

let labelLayer = new olLayer.Tile({

source: this.createTiandituSource(baseLayer.layerType, mapInfo.projection, true),

zIndex: baseLayer.zIndex || 1,

visible: baseLayer.visible

});

this.map.addLayer(labelLayer);

// 挂载带baseLayer上，便于删除

baseLayer.labelLayer = labelLayer;

}

this.limitScale(mapInfo, baseLayer);

}

validScale(scale) {

if (!scale) {

return false;

}

const scaleNum = scale.split(':')[1];

if (!scaleNum) {

return false;

}

const res = 1 / +scaleNum;

if (res === Infinity || res >= 1) {

return false;

}

return true;

}

limitScale(mapInfo, baseLayer) {

if (this.validScale(mapInfo.minScale) && this.validScale(mapInfo.maxScale)) {

let visibleScales, minScale, maxScale;

if (baseLayer.layerType === 'WMTS') {

visibleScales = baseLayer.scales;

minScale = +mapInfo.minScale.split(':')[1];

maxScale = +mapInfo.maxScale.split(':')[1];

} else {

const scales = this.scales.map((scale) => {

return 1 / scale.split(':')[1];

});

if (Array.isArray(baseLayer.visibleScales) && baseLayer.visibleScales.length && baseLayer.visibleScales) {

visibleScales = baseLayer.visibleScales;

} else {

visibleScales = scales;

}

minScale = 1 / +mapInfo.minScale.split(':')[1];

maxScale = 1 / +mapInfo.maxScale.split(':')[1];

}

const minVisibleScale = this.findNearest(visibleScales, minScale);

const maxVisibleScale = this.findNearest(visibleScales, maxScale);

let minZoom = visibleScales.indexOf(minVisibleScale);

let maxZoom = visibleScales.indexOf(maxVisibleScale);

if (minZoom > maxZoom) {

[minZoom, maxZoom] = [maxZoom, minZoom];