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

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

this.layerAdded = 0;

this.layers = [];

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

this.webMap = options.webMap;

this.createMap(options.mapSetting);

if (this.webMap) {

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

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

} else {

if (!this.server) {

this.server = 'https://www.supermapol.com';

}

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

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,没有包括.json,在这里加上。

mapUrl = `${url}.json`

}

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 = mapInfo.projection;

that.webMapVersion = mapInfo.version;

that.baseLayer = mapInfo.baseLayer;

// that.mapParams = {

// title: mapInfo.title,

// description: mapInfo.description

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

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

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

that.addMVTMapLayer(mapInfo, mapInfo.baseLayer, 0).then(() => {

that.createView(mapInfo);

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

that.sendMapToUser(0);

} else {

that.addLayers(mapInfo);

}

});

} else {

await that.addBaseMap(mapInfo);

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

that.sendMapToUser(0);

} else {

that.addLayers(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 (crs === "EPSG:-1") {

// 去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, "EPSG:-1");

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

//多此一举转换，因为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.toLocaleString()}`;

//多此一举转换，因为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.toLocaleString();

}

/**

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

FetchRequest.get(me.getRequestUrl(`${url}.json`), 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 && !me.isSameDomain(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,

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

}

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;

}

}

/**

addMVTMapLayer(mapInfo, layerInfo, zIndex) {

layerInfo.zIndex = zIndex;

// 获取地图详细信息

return this.getMapboxStyleLayerInfo(mapInfo, layerInfo).then((msLayerInfo) => {

// 创建图层

return this.createMVTLayer(msLayerInfo).then(layer => {

let layerID = Util.newGuid(8);

if (layerInfo.name) {

layer.setProperties({

name: layerInfo.name,

layerID: layerID,

layerType: 'VECTOR_TILE'

});

}

//否则没有ID，对不上号

layerInfo.layer = layer;

layerInfo.layerID = layerID;

this.map.addLayer(layer);

});

});

}

/**

createView(options) {

let oldcenter = options.center,

zoom = options.level !== undefined ? options.level : 1,

maxZoom = options.maxZoom || 22,

extent,

projection = this.baseProjection;

let center = [];

for (let key in oldcenter) {

center.push(oldcenter[key]);

}

if (center.length === 0) {

//兼容wms

center = [0, 0];

}

//与DV一致用底图的默认范围，不用存储的范围。否则会导致地图拖不动

this.baseLayerExtent = extent = options.baseLayer && options.baseLayer.extent;

if (this.mapParams) {

this.mapParams.extent = extent;

this.mapParams.projection = projection;

}

//当前中心点不在extent内,就用extent的中心点 todo

!containsCoordinate(extent, center) && (center = getCenter(extent));

// 计算当前最大分辨率

let baseLayer = options.baseLayer;

let maxResolution, minResolution;

if ((baseLayer.visibleScales && baseLayer.visibleScales.length > 0) || (baseLayer.scales && baseLayer.scales.length > 0)) {

//底图有固定比例尺，就直接获取。不用view计算

this.getScales(baseLayer);

} else if (options.baseLayer && ['TILE', 'VECTOR_TILE'].indexOf(options.baseLayer.layerType) > -1 && extent && extent.length === 4) {

let width = extent[2] - extent[0];

let height = extent[3] - extent[1];

let maxResolution1 = width / 512;

let maxResolution2 = height / 512;

maxResolution = Math.max(maxResolution1, maxResolution2);

}

// if(options.baseLayer.visibleScales && options.baseLayer.visibleScales.length > 0){

// maxZoom = options.baseLayer.visibleScales.length;

// }

let viewOptions;

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

if (baseLayer.scales && baseLayer.scales.length > 0) {

//因为新版extent超出，不可见。所以将extent去除

viewOptions = {zoom, center, projection, resolutions: this.resolutionArray, maxZoom};

} else {

viewOptions = {zoom, center, projection, maxZoom};

this.getScales(baseLayer);

}

} else {

if (this.resolutionArray && this.resolutionArray.length > 0) {

viewOptions = {zoom, center, projection, resolutions: this.resolutionArray, maxZoom};

} else {

viewOptions = {zoom, center, projection, maxResolution, minResolution, maxZoom};

this.getScales(baseLayer);

}

}

if (['4', '5'].indexOf(Util.getOlVersion()) < 0) { // 兼容 ol 4，5，6

viewOptions.multiWorld = true;

viewOptions.showFullExtent = true;

viewOptions.enableRotation = false;

viewOptions.constrainResolution = true; //设置此参数，是因为需要显示整数级别。为了可视比例尺中包含当前比例尺

}

this.map.setView(new View(viewOptions));

if (options.visibleExtent) {

const view = this.map.getView();

const resolution = view.getResolutionForExtent(options.visibleExtent, this.map.getSize());

view.setResolution(resolution);

view.setCenter(getCenter(options.visibleExtent));

}

}

/**

createBaseLayer(layerInfo, index, isCallBack, scope, isBaseLayer) {

let source, that = this;

if (scope) {

// 解决异步回调