1.0.0 • Published 2 years ago
mapgisapi v1.0.0
class MapClass {
constructor(options) {
this.options = options;
this.ClassType = MapClass.ClassType;
this.mapInstance = new MapClass.Class(options);// 创建地图 Class在index文件赋值
}
/**
* 地图加载完成
* @returns Promise
*/
mapLoaded() {
return this.mapInstance.mapLoaded();
}
/**
* 添加图层
* @param {*} item 图层信息
* {
* id: "pipeLayer",
* url: BASE_SERVER_URL + "/map-GSPIPE/rest/maps/GSPIPE@ORCL_SM003"
* layerType: "MapImageLayer",
* visible: true
* }
*/
addMapLayer(item) {
return this.mapInstance.addMapLayer(item)
}
/**
* 刷新图层数据
* @param {*} layer 图层id或图层对象
*/
refreshMapLayer(layer) {
this.mapInstance.refreshMapLayer(layer);
}
/**
* 设置图层显示隐藏
* @param {String|Array} layerId 图层id
* @param {Boolean} visible 是否显示
*/
setLayerVisible(layerId, visible) {
this.mapInstance.setLayerVisible(layerId, visible);
}
/**
* 设置图层透明度
* @param {String|Object} layerId 图层id或图层对象
* @param {Boolean} opacity 透明度0-1
*/
setLayerOpacity(layerId, opacity) {
this.mapInstance.setLayerOpacity(layerId, opacity);
}
/**
* 设置图层状态(用于超图图控)
* @param {*} layerStatus 图层状态
*/
setLayerStatus(layerStatus) {
if(MapClass.ClassType === "Arcgis") {
return;
}
this.mapInstance.setLayerStatus(layerStatus);
}
/**
* 设置子图层显示隐藏(arcgis动态图层控制)
* @param {Object} layer 父级图层
* @param {String|Array} sublayerId 子图层id
* @param {Boolean} visible 是否显示
*/
setSublayerVisible(layer, sublayerId, visible) {
if(MapClass.ClassType === "Supermap") {
return;
}
this.mapInstance.setSublayerVisible(layer, sublayerId, visible);
}
/**
* 开启卷帘功能
* @param {HTMLElement} dom 超图卷帘需提供拖动卷帘的DOM元素
*/
startSwipe(dom) {
this.mapInstance.startSwipe(dom);
}
/**
* 关闭卷帘功能
*/
closeSwipe() {
this.mapInstance.closeSwipe();
}
/**
* 绘制图形
* @param {String} type 绘制类型 ["point","polyline","polygon","circle","rectangle"]
* @param {Function} callback 返回绘制geometry,graphic
* @param {Boolean} isAgain 是否连续绘制
*/
startDraw(type, callback, isAgain = false) {
let drawType = {
Arcgis: {point: "point", polyline: "polyline", polygon: "polygon", circle: "circle", rectangle: "rectangle"},
Supermap: {point: "Point", polyline: "LineString", polygon: "Polygon", circle: "Circle", rectangle: "rectangle"}
};
this.mapInstance.startDraw(drawType[MapClass.ClassType][type], callback, isAgain);
}
/**
* 开启编辑图形
* @param {Object|String} layer|layerId 图形图层对象或id 注：arcgis需要依赖图层编辑
* @param {Object<Feature>} feature 要素数据
* @param {Function} callback 返回编辑后的geometry,graphic
*/
startEdit(layer, feature, callback) {
this.mapInstance.startEdit(layer, feature, callback);
}
/**
* 关闭编辑图形
*/
closeEdit() {
this.mapInstance.closeEdit();
}
/**
* 测量长度
* @param {Boolean} isAgain 是否连续测量
*/
measureLegth(isAgain = false) {
this.mapInstance.measureLegth(isAgain);
}
/**
* 测量面积
* @param {Boolean} isAgain 是否连续测量
*/
measureArea(isAgain = false) {
this.mapInstance.measureArea(isAgain);
}
// 关闭绘制工具
closeDraw() {
this.mapInstance.closeDraw();
}
// 清除绘制数据
clearDraw() {
this.mapInstance.clearDraw();
}
// 开启地图截屏功能
mapScreenShot(options) {
if(MapClass.ClassType === "Supermap") {
throw new Error("Supermap not support screen shot!");
}
return this.mapInstance.mapScreenShot(options);
}
// 地图放大
zoomIn() {
this.mapInstance.zoomIn();
}
// 地图缩小
zoomOut() {
this.mapInstance.zoomOut();
}
// 获取地图比例尺
getViewScale() {
return this.mapInstance.getViewScale();
}
// 设置地图比例尺
setViewScale(scale) {
this.mapInstance.setViewScale(scale);
}
// 获取当前地图的lods
getViewLods() {
return this.mapInstance.getViewLods();
}
/**
* 获取当前缩放级别
* @returns Number
*/
getCurZoom() {
return this.mapInstance.getCurZoom();
}
/**
* 获取当前视图范围
* @returns Object<Extent> 范围图形数据
*/
getCurViewExtent() {
return this.mapInstance.getCurViewExtent();
}
/**
* 获取点的坐标值
* @param {Object<Point>} point
* @returns Object {x,y}
*/
getPointCoords(point) {
return this.mapInstance.getPointCoords(point);
}
/**
* 获取线的坐标值
* @param {Object<Polyline>} polyline
* @returns Array [[x, y],[x, y]]
*/
getPolylineCoords(polyline) {
return this.mapInstance.getPolylineCoords(polyline);
}
/**
* 获取线的坐标值
* @param {Object<Polygon>} polygon
* @returns Array [[[x, y],[x, y]], [[x, y],[x, y]]]
*/
getPolygonCoords(polygon) {
return this.mapInstance.getPolygonCoords(polygon);
}
/**
* 获取图形的中心点
* @param {Object<geometry>} geometry
*/
getGeometryCenter(geometry) {
return this.mapInstance.getGeometryCenter(geometry);
}
/**
* 获取图形的类型
* @param {Object<geometry>} geometry
*/
getGeometryType(geometry) {
if(MapClass.ClassType === "Supermap") {
let typeMap = {
"Point": "point",
"LineString": "polyline",
"MultiLineString": "polyline",
"Polygon": "polygon",
"MultiPolygon": "polygon",
}
let type = this.mapInstance.getGeometryType(geometry);
return typeMap[type];
}
return this.mapInstance.getGeometryType(geometry);
}
/**
* 坐标缩放定位
* @param {Number} x x坐标值
* @param {Number} y y坐标值
* @param {Number} zoom 缩放级别（可选）
*/
setCenterZoom(x, y, zoom) {
this.mapInstance.setCenterZoom(x, y, zoom);
}
/**
* 要素定位
* @param {Object<Geometry>||Array<Geometry>} geometry 单个或多个图形要素
* @param {Function} callback 定位结束回调 （可选）
* @param {Number} zoom 定位级别 （可选）
*/
zoomToGeometry(geometry, callback, zoom) {
this.mapInstance.zoomToGeometry(geometry, callback, zoom);
}
/**
* 点坐标转屏幕坐标
* @param {Object<Geometry>} point 点要素
* @returns {Object} {x: 123, y: 456}
*/
pointToScreen(point) {
let screenCoord = this.mapInstance.pointToScreen(point);
if(MapClass.ClassType === "Supermap") {
return {
x: screenCoord[0],
y: screenCoord[1],
}
}
if(MapClass.ClassType === "Arcgis") {
return screenCoord;
}
}
/**
* 要素数据转geojson
* @param {Object<Geometry>} geometry 要素数据
*/
geometryToGeojson(geometry) {
return this.mapInstance.geometryToGeojson(geometry);
}
/**
* geojson转要素数据
* @param {String} geojson geojson格式字符串
*/
geojsonToGeometry(geojson) {
return this.mapInstance.geojsonToGeometry(geojson);
}
/**
* 要素数据转wkt
* @param {Object<Geometry>} geometry 要素数据
*/
geometryToWkt(geometry) {
return this.mapInstance.geometryToWkt(geometry);
}
/**
* wkt转要素数据
* @param {String} wkt wkt格式字符串
*/
wktToGeometry(wkt) {
return this.mapInstance.wktToGeometry(wkt);
}
/**
* 图形要素转json
* @param {Object<Feature>} Feature 要素数据
*/
featureToJson(Feature) {
return this.mapInstance.featureToJson(Feature);
}
/**
* json转要素数据
* @param {String} json json格式字符串
*/
jsonToFeature(json) {
return this.mapInstance.jsonToFeature(json);
}
/**
* 创建点图形
* @param {Number} x x坐标值
* @param {Number} y y坐标值
* @returns Object<Point> 点图形数据
*/
createPoint(x, y) {
return this.mapInstance.createPoint(x, y);
}
/**
* 创建线图形
* @param {Number} coordinates 坐标值[[x, y], [x, y]]
* @returns Object<Polyline> 线图形数据
*/
createPolyline(coordinates) {
return this.mapInstance.createPolyline(coordinates);
}
/**
* 创建面图形
* @param {Number} coordinates 坐标值[[[x, y], [x, y]]]
* @returns Object<Polygon> 面图形数据
*/
createPolygon(coordinates) {
return this.mapInstance.createPolygon(coordinates);
}
/**
* 构建缓冲区
* @param {Object} geometry 空间数据
* @param {Number} radius 缓冲半径
* @param {String} units 单位 meters | kilometers
* @returns Object<Geometry> 缓冲区图形
*/
createBuffer(geometry, radius, units = "meters") {
return this.mapInstance.createBuffer(geometry, radius, units);
}
/**
* 获取圆点样式
* @param {Object} options 自定义参数
* options: {
color: "#ff0000",
size: 20,
outLineColor: "#ffff00",
outLineWidth: 5,
}
*
* @param {String|Array} color 填充颜色#ff0000 | [r, g, b, a]
* @param {Number} size 圆点大小，像素数值值大小
* @returns Object 样式对象
*/
getPointStyle(color, size) {
if(arguments.length === 1 && Object.prototype.toString.call(arguments[0]) === '[object Object]') {
return this.mapInstance.getPointStyleOpt(arguments[0]);
}
return this.mapInstance.getPointStyle(color, size);
}
/**
* 获取点图标样式
* @param {Object} options 自定义参数
* options: {
url: require('./assets/mapIcon/marker_blue.png'),
imageWidth:"53px",
setWidth: "32px",
setHeight: "40px",
xoffset: "0px",
yoffset: "16px"
}
*
* @param {String} url 图标地址
* @param {String} imageWidth 原图标宽度 如："1px"
* @param {String} setWidth 图标宽度
* @param {String} setHeight 图标高度
* @param {String} xoffset x偏移 （可选）
* @param {String} yoffset y偏移 （可选）
* @returns Object 样式对象
*/
getMarkerStyle(url, imageWidth, setWidth, setHeight, xoffset, yoffset) {
if(arguments.length === 1 && Object.prototype.toString.call(arguments[0]) === '[object Object]') {
let options = arguments[0];
if(MapClass.ClassType === "Supermap") {
options.scale = parseInt(options.setWidth) / parseInt(options.imageWidth);
if(parseInt(options.xoffset) >= 0) {
options.xoffset = parseInt(options.xoffset)* 2 / parseInt(options.setWidth);
}else {
options.xoffset = -(parseInt(options.xoffset) / parseInt(options.setWidth)) + 0.5001;
}
if(parseInt(options.yoffset) >= 0) {
options.yoffset = parseInt(options.yoffset)* 2 / parseInt(options.setHeight);
}else {
options.yoffset = (parseInt(options.yoffset) / parseInt(options.setHeight)) + 0.5001;
}
return this.mapInstance.getMarkerStyleOpt(options);
}
if(MapClass.ClassType === "Arcgis") {
return this.mapInstance.getMarkerStyleOpt(options);
}
}else {
if(MapClass.ClassType === "Supermap") {
let scale = parseInt(setWidth) / parseInt(imageWidth);
if(parseInt(xoffset) >= 0) {
xoffset = parseInt(xoffset)* 2 / parseInt(setWidth);
}else {
xoffset = -(parseInt(xoffset) / parseInt(setWidth)) + 0.5001;
}
if(parseInt(yoffset) >= 0) {
yoffset = parseInt(yoffset)* 2 / parseInt(setHeight);
}else {
yoffset = (parseInt(yoffset) / parseInt(setHeight)) + 0.5001;
}
return this.mapInstance.getMarkerStyle(url, scale, xoffset, yoffset);
}
if(MapClass.ClassType === "Arcgis") {
return this.mapInstance.getMarkerStyle(url, setWidth, setHeight, xoffset, yoffset);
}
}
}
/**
* 获取标注样式
* @param {Object} options 自定义参数
* options: {
text: "测试字体1",
color: "#ff0000",
fontSize: 24,
outLineColor: "#ffff00",
outLineWidth: 5,
backgroundColor: "#00ff00",
borderLineColor: "#0000ff",
borderLineSize: 5,
xoffset: "0px",
yoffset: "24px"
}
*
* @param {String} text 文本内容
* @param {String|Array} color 填充颜色#ff0000 | [r, g, b, a]
* @param {Number} fontSize 字体大小
* @param {String} xoffset x偏移 （可选）
* @param {String} yoffset y偏移 （可选）
* @returns Object 样式对象
*/
getTextStyle(text, color, fontSize, xoffset, yoffset) {
if(arguments.length === 1 && Object.prototype.toString.call(arguments[0]) === '[object Object]') {
let options = arguments[0];
if(MapClass.ClassType === "Supermap") {
options.xoffset = - parseInt(options.xoffset);
options.yoffset = - parseInt(options.yoffset);
}
return this.mapInstance.getTextStyleOpt(options);
}
if(MapClass.ClassType === "Supermap") {
xoffset = - parseInt(xoffset);
yoffset = - parseInt(yoffset);
}
return this.mapInstance.getTextStyle(text, color, fontSize, xoffset, yoffset);
}
/**
* 获取线样式
* @param {Object} options 自定义参数
* options: {
color: "#ff0000",
width: 10,
style: "dash"
}
*
* @param {String|Array} color 填充颜色#ff0000 | [r, g, b, a]
* @param {Number} width 线宽度 1
* @param {String} style 线样式 solid-实线 dash-虚线 （可选）
* @returns Object 样式对象
*/
getLineStyle(color, width, style) {
if(arguments.length === 1 && Object.prototype.toString.call(arguments[0]) === '[object Object]') {
return this.mapInstance.getLineStyleOpt(arguments[0]);
}
return this.mapInstance.getLineStyle(color, width, style);
}
/**
* 获取面样式
* @param {Object} options 自定义参数
* options: {
color: [255, 0, 0, 0.3],
outLineColor: "#ffff00",
outLineWidth: 2,
outlineStyle: "dash"
}
*
* @param {String|Array} color 填充颜色#ff0000 | [r, g, b, a]
* @param {String|Array} outLineColor 边线颜色#ff0000 | [r, g, b, a]
* @param {Number} outLineWidth 边线宽度 1
* @param {String} outLineStyle 边线样式 solid-实线 dash-虚线 （可选）
* @returns Object 样式对象
*/
getPolygonStyle(color, outLineColor, outLineWidth, outLineStyle) {
if(arguments.length === 1 && Object.prototype.toString.call(arguments[0]) === '[object Object]') {
return this.mapInstance.getPolygonStyleOpt(arguments[0]);
}
return this.mapInstance.getPolygonStyle(color, outLineColor, outLineWidth, outLineStyle);
}
/**
* 获取默认样式
* @param {String} type 样式类型'point','marker','line','polygon'
* @returns Object 样式对象
*/
getDefaultStyle(type) {
return this.mapInstance.getDefaultStyle(type);
}
/**
* 设置要素样式
* @param {Object} feature 图形要素
* @param {Object} style 样式
*/
setFeatureStyle(feature, style) {
this.mapInstance.setFeatureStyle(feature, style);
}
/**
* 设置要素图形信息
* @param {Object} feature 图形要素
* @param {Object} geometry 图形信息
*/
setFeatureGeometry(feature, geometry) {
this.mapInstance.setFeatureGeometry(feature, geometry);
}
/**
* 设置要素属性信息
* @param {Object} feature 图形要素
* @param {Object} attributes 属性信息
*/
setFeatureAttributes(feature, attributes) {
this.mapInstance.setFeatureAttributes(feature, attributes);
}
/**
* 创建要素数据
* @param {Object} geometry 图形对象
* @param {Object} style 样式
* @param {Object} attributes 属性（可选）
* @returns Object<Feature> 要素数据
*/
createFeature(geometry, style, attributes) {
return this.mapInstance.createFeature(geometry, style, attributes);
}
/**
* 获取要素的图形对象
* @param {Object|Array<Feature>} feature 单个/多个要素数据
* @returns 图形对象数据
*/
getGeometryByFeature(feature) {
return this.mapInstance.getGeometryByFeature(feature);
}
/**
* 获取要素的属性对象
* @param {Object|Array<Feature>} feature 单个/多个要素数据
* @returns 属性数据
*/
getAttributeByFeature(feature) {
return this.mapInstance.getAttributeByFeature(feature);
}
/**
* 添加高亮要素数据
* @param {Object|Array<Feature>} feature 单个/多个要素数据
*/
addHighLightFeature(feature) {
this.mapInstance.addHighLightFeature(feature);
}
// 清除高亮图层
clearHighLightLayer() {
this.mapInstance.clearHighLightLayer();
}
/**
* 创建图形图层
* @param {String} id 图层id
* @returns 图层对象
*/
createGraphicsLayer(id) {
return this.mapInstance.createGraphicsLayer(id);
}
/**
* 删除图层
* @param {Object|String} layer|layerId 图形图层对象或id
*/
removeLayer(layer) {
return this.mapInstance.removeLayer(layer);
}
/**
* 获取图层
* @param {String} id 图层id
* @returns Object 图层对象
*/
getLayerById(id) {
return this.mapInstance.getLayerById(id);
}
/**
* 添加要素到图层
* @param {Object|String} layer|layerId 图形图层对象或id
* @param {Object|Array<Feature>} feature 单个/多个要素数据
*/
addFeatureToLayer(layer, feature) {
this.mapInstance.addFeatureToLayer(layer, feature);
}
/**
* 删除图层某个要素
* @param {Object|String} layer|layerId 图形图层对象或id
* @param {Object<Feature>} feature 单个要素数据
*/
removeFeature(layer, feature) {
this.mapInstance.removeFeature(layer, feature);
}
/**
* 根据属性删除图层某个要素
* @param {Object|String} layer|layerId 图形图层对象或id
* @param {String} field 根据 field字段 删除
* @param {String} fieldValue 字段值
*/
removeFeatureFromLayer(layer, field, fieldValue) {
this.mapInstance.removeFeatureFromLayer(layer, field, fieldValue);
}
/**
* 清除图形图层
* @param {Object|String} layer|layerId 图形图层对象或id
*/
clearGraphicsLayer(layer) {
this.mapInstance.clearGraphicsLayer(layer);
}
/**
* 创建要素图层
* @param {Object} item 图层信息
* {
* id: "pipeLayer",
* url: BASE_SERVER_URL + "/PRODUCT/GS_pipe_BS/MapServer/0"
* visible: true
* }
*/
createFeatureLayer(item) {
if(MapClass.ClassType === "Supermap") {
throw new Error("Supermap not support FeatureLayer!");
}
return this.mapInstance.createFeatureLayer(item);
}
// 创建echarts图层
createEchartsLayer(option) {
return this.mapInstance.createEchartsLayer(option);
}
/**
* 设置聚合效果
* @param {Object} layer 需要聚合显示的图层
* @param {Object} renderer 样式效果
* @param {Object} redution 聚合效果
*/
setClusterReduction(layer, renderer, redution) {
if(MapClass.ClassType === "Supermap") {
throw new Error("Supermap not support Cluster!");
}
this.mapInstance.setClusterReduction(layer, renderer, redution);
}
/**
* 监听地图拖拽事件
* @param {Function} callback 事件执行回调函数
* @returns Object 事件对象
*/
viewDragListener(callback) {
if(MapClass.ClassType === "Supermap") {
throw new Error("Supermap not support drag listener!");
}
return this.mapInstance.viewDragListener(callback);
}
/**
* 监听地图级别变化
* @param {Function} callback 事件执行回调函数
* @returns Object 事件对象
*/
viewScaleListener(callback) {
return this.mapInstance.viewScaleListener(callback);
}
/**
* 监听地图范围变化
* @param {Function} callback 事件执行回调函数
* @returns Object 事件对象
*/
viewExtentListener(callback) {
return this.mapInstance.viewExtentListener(callback);
}
/**
* 监听鼠标移动
* @param {Function} callback 事件执行回调函数
* @returns Object 事件对象
*/
pointerMoveListener(callback) {
return this.mapInstance.pointerMoveListener(callback);
}
/**
* 地图点击事件
* @param {Function} callback 返回点击数据{ 坐标:coordinate, 像素坐标:pixel, 当前点位要素:mapPoint }
* @param {Boolean} isAgain 是否连续点击
* @returns Object 事件对象
*/
mapOnClick(callback, isAgain = true) {
return this.mapInstance.mapOnClick(callback, isAgain);
}
/**
* 地图双击事件
* @param {Function} callback 返回点击数据{ 坐标:coordinate, 像素坐标:pixel, 当前点位要素:mapPoint }
* @param {Boolean} isAgain 是否连续点击
* @returns Object 事件对象
*/
mapOnDobuleClick(callback, isAgain = true) {
return this.mapInstance.mapOnDobuleClick(callback, isAgain);
}
/**
* 选中要素数据
* @param {Function} callback 返回点击要素数据{ 要素数据:feature }
* @param {Boolean} isAgain 是否连续点击
* @param {Number} bufferDistance 仅超图支持
* @returns Object 事件对象
*/
featureOnSelect(callback, isAgain = true, bufferDistance) {
return this.mapInstance.featureOnSelect(callback, isAgain, bufferDistance);
}
/**
* 选中所有要素数据
* @param {Function} callback 返回点击要素数据{ 要素数据:feature[] }
* @param {Boolean} isAgain 是否连续点击
* @param {Number} bufferDistance 仅超图支持
* @returns Object 事件对象
*/
featureOnSelectAll(callback, isAgain = true, bufferDistance) {
return this.mapInstance.featureOnSelectAll(callback, isAgain, bufferDistance);
}
/**
* 移除地图事件
* @param {Object||Array<Object>} event 单个或多个事件对象
*/
removeMapEvent(event) {
this.mapInstance.removeMapEvent(event);
}
/**
* 显示弹窗
* @param {String} title 弹窗标题
* @param {String|HTMLElement} content 弹窗内容
* @param {Object<Geometry>} location 弹窗显示位置
* @param {Function} callback 弹窗关闭后执行回调
*/
showPopup(title, content, geometry, callback) {
this.mapInstance.showPopup(title, content, geometry, callback);
}
// 关闭弹窗
closePopup() {
this.mapInstance.closePopup();
}
/**
* 计算线的长度
* @param {Object<Geometry>} geometry 图形
* @returns {Number} 距离
*/
calcLineLength(geometry) {
return this.mapInstance.calcLineLength(geometry);
}
/**
* 获取所有图形的凸包面
* @param {Array<Geometry>} geometries 图形
* @returns {Polygon} 图形
*/
getConvexHull(geometries) {
return this.mapInstance.getConvexHull(geometries);
}
/**
* 获取图形之间的距离
* @param {Object<Geometry>} geometry1 图形
* @param {Object<Geometry>} geometry2 图形
* @returns {Number} 距离
*/
getGeometryDistance(geometry1, geometry2) {
return this.mapInstance.getGeometryDistance(geometry1, geometry2);
}
/**
* 合并图形
* @param {Array<Geometry>} geometries 图形集合
* @returns {Object<Geometry>} 合并后的图形
*/
getUnionGeometry(geometries) {
return this.mapInstance.getUnionGeometry(geometries);
}
/**
* 相交图形
* @param {Object<Geometry>} geometry1 图形
* @param {Object<Geometry>} geometry2 图形
* @returns {Object<Geometry>} 相交图形
*/
getIntersectGeometry(geometry1, geometry2) {
return this.mapInstance.getIntersectGeometry(geometry1, geometry2);
}
/**
* 判断相交
* @param {Object<Geometry>} geometry1 图形
* @param {Object<Geometry>} geometry2 图形
* @returns {Boolean} 是否相交
*/
isIntersect(geometry1, geometry2) {
return this.mapInstance.isIntersect(geometry1, geometry2);
}
/**
* 判断包含
* @param {Object<Geometry>} outGeometry 图形（外）
* @param {Object<Geometry>} inGeometry 图形（内）
* @returns {Boolean} 是否包含
*/
isContains(outGeometry, inGeometry) {
return this.mapInstance.isContains(outGeometry, inGeometry);
}
/**
* 获取图例信息
* @param {String} url 查询服务url
* @param {Function} hookCallbak 回调钩子函数，获取每项数据，可给每项数据添加属性
* @returns Promise { [] }
*/
getLayerLegend(url, hookCallbak) {
if(MapClass.ClassType === "Arcgis") {
return this.mapInstance.getLayerLegend(url, hookCallbak);
}
// 超图无法获取图例
if(MapClass.ClassType === "Supermap") {
return new Promise((resolve) => {
resolve({});
});
}
}
/**
* 获取图层信息
* @param {String} url 查询服务url
* @param {String} pipeType 管线类型，供水/排水
* @returns Promise { layers: 图层数据，treeLayers：图层树结构 }
*/
getLayersInfo(url, pipeType) {
return this.mapInstance.getLayersInfo(url, pipeType);
}
/**
*
* @param {String} url 查询服务url
* @param {String} layerId 图层id
* @returns Promise { results: 结果集 }
*/
getLayerFields(url, layerId) {
return this.mapInstance.getLayerFields(url, layerId);
}
/**
* 要素数据查询
* @param {Object}
* queryParams {
* url 查询服务url
* layerId 图层id
* geometry 查询范围
* outFields 输出字段
* where 查询sql条件
* returnGeometry 是否返回空间信息
* pageNum 第几页
* pageSize 每页数据
* hookCallbak 回调钩子函数，获取每项数据，可给每项数据添加属性
* }
* @returns Promise { results: 结果集, total: 总数 }
*/
queryFeatures(queryParams) {
queryParams.where || (queryParams.where = "1=1");
queryParams.outFields || (queryParams.outFields = ["*"]);
queryParams.returnGeometry === undefined && (queryParams.returnGeometry = true);
if(MapClass.ClassType === "Supermap") {
queryParams.outFields = (queryParams.outFields.length === 1 && queryParams.outFields[0] === "*") ? null : queryParams.outFields;
queryParams.queryOption = queryParams.returnGeometry ? "ATTRIBUTEANDGEOMETRY" : "ATTRIBUTE";
// queryParams.fromIndex = (queryParams.pageNum - 1) * queryParams.pageSize;
// queryParams.toIndex = queryParams.pageNum * queryParams.pageSize - 1;
if(!queryParams.cancelPage) {
queryParams.startRecord = queryParams.pageNum ? (queryParams.pageNum - 1) * queryParams.pageSize: 0;
queryParams.expectCount = queryParams.pageSize || 10000;
}
}else if(MapClass.ClassType === "Arcgis") {
if(!queryParams.cancelPage) {
queryParams.start = queryParams.pageNum ? (queryParams.pageNum - 1) * queryParams.pageSize : 0;
queryParams.num = queryParams.pageSize || 10000;
}
}
return this.mapInstance.queryFeatures(queryParams);
}
/**
* 空间数据查询
* @param {Object}
* queryParams {
* url 查询服务url
* layerIds 查询图层所有id
* geometry 查询范围
* returnGeometry 是否返回空间信息
* layerOption 供arcgis使用 top：查最上层，visible：查可见图层
* hookCallbak 回调钩子函数，获取每项数据，可给每项数据添加属性
* }
* @returns Promise { results: 结果集, total: 总数 }
*/
identifyQuery(queryParams) {
queryParams.returnGeometry === undefined && (queryParams.returnGeometry = true);
if(MapClass.ClassType === "Supermap") {
queryParams.queryOption = queryParams.returnGeometry ? "ATTRIBUTEANDGEOMETRY" : "ATTRIBUTE";
}
return this.mapInstance.identifyQuery(queryParams);
}
/**
* 属性数据查询
* @param {Object}
* queryParams {
* url 查询服务url
* layerIds 查询图层所有id
* searchFields 查询范围
* searchText 搜索内容
* returnGeometry 是否返回空间信息
* hookCallbak 回调钩子函数，获取每项数据，可给每项数据添加属性
* }
* @returns Promise { results: 结果集, total: 总数 }
*/
attributeQuery(queryParams) {
queryParams.returnGeometry === undefined && (queryParams.returnGeometry = true);
if(MapClass.ClassType === "Supermap") {
queryParams.queryOption = queryParams.returnGeometry ? "ATTRIBUTEANDGEOMETRY" : "ATTRIBUTE";
}
return this.mapInstance.attributeQuery(queryParams);
}
/**
* 获取图层字段的去重值（字段下拉数据）
* @param {String} url 查询服务url (注：超图为dataUrl)
* @param {String} layerId 查询图层id
* @param {String} field 字段（与服务字段大小写一致）
* @returns Promise { results: 结果集 }
*/
getFieldDistinctValue(url, layerId, field) {
return this.mapInstance.getFieldDistinctValue(url, layerId, field);
}
// 地图销毁释放地图资源
destroyMap() {
this.mapInstance.destroyMap();
}
/**
* 坐标转换 https://www.npmjs.com/package/geotransform
* @param {String} fromSR 转换前坐标系 'EPSG:4326 || GCJ02'
* @param {String} toSR 转换后坐标系 'EPSG:3857'
* @param {Array} coords 坐标值 [X, Y]
* @returns {Array} 坐标值 [X, Y]
*/
coordTransform(fromSR, toSR, coords) {
return transform.coordTransform(fromSR, toSR, coords);
}
/**
* 将epsg坐标转为地方四参坐标系
* @param {Array} coordinate
* @returns {Array} 坐标值 [X, Y]
*/
epsgToFourArgs(coords) {
return transform.epsgToFourArgs(this.options.transformParam.fourArgsParams, coords);
}
/**
* 将地方四参坐标系转为epsg坐标
* @param {Array} coordinate
* @returns {Array} 坐标值 [X, Y]
*/
fourArgsToEpsg(coords) {
return transform.fourArgsToEpsg(this.options.transformParam.fourArgsParams, coords);
}
}