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.withCredentials = options.withCredentials || false;

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

this.excludePortalProxyUrl = options.excludePortalProxyUrl || false;

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.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.excludePortalProxyUrl && 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: this.withCredentials

}).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);

}

} else {

// 不支持的坐标系

that.errorCallback && that.errorCallback({type: "Not support CS", errorMsg: `Not support CS: ${mapInfo.projection}`}, 'getMapFaild', that.map);

return;

}

}

/**

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.withCredentials,

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

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 * .0254 / dpi / mpu;

}

/**

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

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

scale = resolution * dpi * mpu / .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: this.withCredentials

}).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

}

if (url && !CommonUtil.isInTheSameDomain(url) && !this.isIportalProxyServiceUrl(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, true), null, {

withCredentials: this.withCredentials

}).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 format = new WMTSCapabilities();

let capabilities = format.read(capabilitiesText);

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];

}

if (minZoom !== 0 || maxZoom !== visibleScales.length - 1) {

this.map.setView(

new View(

Object.assign({}, this.map.getView().options_, {

maxResolution: undefined,

minResolution: undefined,

minZoom,

maxZoom,

constrainResolution: false

})

)

);

this.map.addInteraction(

new MouseWheelZoom({

constrainResolution: true

})

);

}

}

}

parseNumber(scaleStr) {

return Number(scaleStr.split(":")[1])

}

findNearest(scales, target) {

let resultIndex = 0

let targetScaleD = target;

for (let i = 1, len = scales.length; i < len; i++) {

if (

Math.abs(scales[i] - targetScaleD) <

Math.abs(scales[resultIndex] - targetScaleD)

) {

resultIndex = i

}

}

return scales[resultIndex]

}

/**

addMVTMapLayer(mapInfo, layerInfo, zIndex) {