SuperMap iClient for OpenLayers

                                    var url = "https://iserver.supermap.io/iserver/services/map-world/rest/maps/World";
// 初始化地图信息
var map = new ol.Map({
    target: 'map',
    controls: ol.control.defaults({attributionOptions: {collapsed: false}})
        .extend([new ol.supermap.control.Logo()]),
    view: new ol.View({
        center: [0, 0],
        zoom: 2,
        projection: 'EPSG:4326'
    })
});
// 添加图层
var layer = new ol.layer.Tile({
    source: new ol.source.TileSuperMapRest({
        url: url,
        wrapX: true
    }),
    projection: 'EPSG:4326'
});
map.addLayer(layer);查看源码 »
                                        

                                        var map = new ol.Map({
    target: 'map',
    controls: ol.control.defaults({attributionOptions: {collapsed: false}})
        .extend([new ol.supermap.control.Logo()]),
    view: new ol.View({
        center: [116.402, 39.905],
        zoom: 5,
        projection: "EPSG:4326"
    }),
    // 添加天地图图层
    layers: [
        new ol.layer.Tile({
            source: new ol.source.Tianditu({
                layerType: 'ter',
                key: "1d109683f4d84198e37a38c442d68311",
                projection: "EPSG:4326"
            });
        }),new ol.layer.Tile({
            source: new ol.source.Tianditu({
                layerType: 'ter',
                key: "1d109683f4d84198e37a38c442d68311",
                isLabel: true,
                projection: "EPSG:4326"
            });
        })];
});查看源码 »
                            

                                var map = new ol.Map({
    view: new ol.View({
        projection: 'EPSG:4326'
    });
});
                            

                                    var swissProjection = new ol.proj.Projection({
    code: 'EPSG:21781',
    // extent用于确定缩放级别
    // 投影的extent可以参考https://epsg.io/
    extent: [485869.5728, 76443.1884, 837076.5648, 299941.7864],
    units: 'm'
});
ol.proj.addProjection(swissProjection);
var map = new ol.Map({
    view: new ol.View({
        projection: swissProjection
    });
});
                            

                        new ol.supermap.MapService(url).getMapInfo(function (serviceResult) {
    // 矢量瓦片风格参数对象
    var stylesOptions = {
        url: url,
        view: map.getView()
    };
    // 创建瓦片风格对象
    var vectorTileStyles = new ol.supermap.VectorTileStyles(stylesOptions);
    // 通过地图信息获取瓦片参数对象
    var vectorTileOptions = ol.source.VectorTileSuperMapRest.optionsFromMapJSON(url, serviceResult.result);
    // 添加矢量瓦片图层
    var vectorLayer = new ol.layer.VectorTile({
        source: new ol.source.VectorTileSuperMapRest(vectorTileOptions),
        style: vectorTileStyles.getFeatureStyle
    });
    map.addLayer(vectorLayer);
}查看源码 »
                                    

                                        // 设置绘制控件界面，以绘制点为例
<div class="btn-group">
    <button id="drawPoint" value='Point' type="button" class="btn btn-default">绘点</button>
</div>
                                    

                                        // 获取需要绘制的类型
var buttons = $('.btn-group').children();
// 实例化矢量图层作为绘图层
var vector = new ol.layer.Vector({
    source: source
});
map.addLayer(vector);
// 创建一个绘图控件对象
var draw = new ol.interaction.Draw({
    source: source,
    type: buttons[key].value,
    snapTolerance: 20
});
// 添加绘图控件
map.addInteraction(draw); 查看源码 »
                                    

                                    // 获取需要绘制的类型
var buttons = $('.btn-group').children();
// 创建一个矢量图层作为绘图层
var vector = new ol.layer.Vector({
    source: source
});
map.addLayer('vector');
// 创建手写图形绘制控件
var draw = new ol.interaction.Draw({
    source: source,
    type: buttons[key].value,
    snapTolerance: 20,
    freehand: true // 设置可手写图形绘制
});
// 添加手写图形绘制控件
map.addInteraction(draw);查看源码 »
                    

                                            var source = new ol.source.Vector({wrapX: false});
// 创建捕捉绘制控件
var snap = new ol.interaction.Snap({
    source: source  // 绘制源
});
// 添加捕捉控件
map.addInteraction(snap);查看源码 »
                            

                                            // 设置量算服务参数
var distanceMeasureParam = new ol.supermap.MeasureParameters(feature.getGeometry());
// 设置要量算的矢量对象({Line}或{Polygon})，geometry可以通过直接初始化的方法获取
distanceMeasureParam.geometry= geometry;
                                        

                                // 提交服务请求，设置服务请求关键参数，获取返回结果并按照用户需求进行处理
var url="https://iserver.supermap.io/iserver/services/map-world/rest/maps/World"; //服务访问的地址
new ol.supermap.MeasureService(url, {measureMode: ""}).measureDistance(distanceMeasureParam).then(function (serviceResult) {
    function doSomething(serviceResult);
    // 获取服务器返回的结果
    var result=serviceResult.result;
});查看源码 »
                                    

                                var areaMeasureParam = new ol.supermap.MeasureParameters(feature.getGeometry());
                            

                                // 设置面积量算服务参数
var areaMeasureParam = new ol.supermap.MeasureParameters(feature.getGeometry());
new ol.supermap.MeasureService(url).measureArea(areaMeasureParam).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
})查看源码 »
                            

                                            // 实例化地物编辑参数类
var addFeatureParams = new ol.supermap.EditFeaturesParameters({
    features: pointFeature,
    dataSourceName: "World",
    dataSetName: "Capitals",
    editType: "add",
    returnContent: true
});
// 构建地物编辑服务，url是supermap iserver数据服务
var editFeaturesService = new ol.supermap.FeatureService(url);
editFeaturesService.editFeatures(addFeatureParams).then(function (serviceResult) {
    // 获取返回数据
    var result = serviceResult.result;
});查看源码 » 
                            

                                // 实例化点密度专题图
var themeDotDensity = new ol.supermap.ThemeDotDensity({
    dotExpression: "Pop_1994",
    value: 5000000,
    style: new ol.supermap.ServerStyle({
        markerSize: 3,
        markerSymbolID: 12
    })
});
// 专题图参数类，该类存储了制作专题所需的参数，包括数据源、数据集名称和专题图对象。
var themeParameters = new ol.supermap.ThemeParameters({
    themes: [themeDotDensity],
    // 要制作专题图的数据集数组，必设
    datasetNames: ["Countries"],
    // 要制作专题图的数据集所在的数据源数组，必设
    dataSourceNames: ["World"]
});
//专题图服务类，专题图结果通过该类支持的事件的监听函数参数获取
new ol.supermap.ThemeService(url).getThemeInfo(themeParameters).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
});查看源码 »
                            

                                //单值专题图图层资源
var themeSource = new ol.source.Unique("ThemeLayer", {
    // 专题图ID
    map: map,
    attributions: " ",
    // 专题图样式
    style: {
        shadowBlur: 3,
        shadowColor: "#000000",
        shadowOffsetX: 1,
        shadowOffsetY: 1,
        fillColor: "#FFFFFF"
    },
    // 是否开启hover事件
    isHoverAble: true,
    // 开启hover事件后，触发的样式风格
    highlightStyle: {
        stroke: true,
        strokeWidth: 2,
        strokeColor: 'blue',
        fillColor: "#00F5FF",
        fillOpacity: 0.2
    },
    // 指定创建专题图字段
    themeField: "LANDTYPE",
});
// 创建单值专题图图层
var themeLayer = new ol.layer.Image({
    source: themeSource
});
                            

                                // 单值专题类型样式组
styleGroups: [
    {
        value: "草地",
        style: {
            fillColor: "#C1FFC1"
        }
    },
    {
        value: "城市",
        style: {
            fillColor: "#CD7054"
        }
    },
    {
        value: "灌丛",
        style: {
            fillColor: "#7CCD7C"
        }
    }
];查看源码 »
                            

                                // 分段专题图图层资源
var themeSource = new ol.source.Range("ThemeLayer",{
    map: map,
    // 版权信息
    attributions: " ",
    // 分段专题图样式
    style: {
        shadowBlur: 16,
        shadowColor: "#000000",
        fillColor: "#FFFFFF"
    },
    // 是否开启hover事件
    isHoverAble: true,
    // 开启hover事件后，触发的样式风格
    highlightStyle: {
        stroke: true,
        strokeWidth: 4,
        strokeColor: 'blue',
        fillColor: "#00EEEE",
        fillOpacity: 0.8
    },
    // 指定创建专题图字段
    themeField: "POP_DENSITY99",
    // 配置分段专题类型样式组
    styleGroups: [
        {
            start: 0,
            end: 0.02,
            style: {
                color: '#FDE2CA'
            }
        },
        {
            start: 0.02,
            end: 0.04,
            style: {
                color: '#FACE9C'
            }
        }
    ];
});
// 创建一个分段专题图层
var themeLayer = new ol.layer.Image({
    source: themeSource
});查看源码 »
                            

                                // 等级符号专题图图层资源
var themeSource = new ol.source.RankSymbol("RankSymbolLayer", "Circle",
{
    map: map,
    attributions: " ",
    themeField: "CON2009",
    // 配置图表参数
    symbolSetting: {
        // 必设
        codomain: [0, 40000], // 允许图形展示的值域范围，此范围外的数据将不制作图形
        // 圆最大半径，默认100
        maxR: 100,
        // 圆最小半径，默认0
        minR: 0,
        // 圆形样式
        circleStyle: {fillOpacity: 0.8},
        // 符号专题图填充颜色
        fillColor: "#FFA500",
        // 专题图 hover 样式
        circleHoverStyle: {fillOpacity: 1}
    }
});
// 创建一个等级符号专题图层
var themeLayer = new ol.layer.Image({
    source: themeSource
});查看源码 »
                            

                                // 标签专题图图层资源
var themeSource = new ol.source.Label("labelThemeLayer", {
    map: map,
    attributions: " ",
    // 标签专题要素的Style
    style: new ol.supermap.ThemeStyle({
        labelRect: true,
        fontColor: "#000000",
        fontWeight: "bolder",
        fontSize: "18px",
        fill: true,
        fillColor: "#FFFFFF",
        fillOpacity: 1,
        stroke: false,
        strokeColor: "#8B7B8B"
    }),
    // 指定创建专题图字段
    themeField: "aqi",
    // 标签专题图类型样式组
    styleGroups: [
        {
            start: 0,
            end: 51,
            style: {
                fillColor: "#6ACD06",
                fontSize: "17px"
            }
        }, {
            start: 51,
            end: 101,
            style: {
                fillColor: "#FBD12A",
                fontSize: "19px"
            }
        },
    ];
});
// 创建一个标签专题图层
var themeLayer = new ol.layer.Image({
    source: themeSource
});查看源码 »
                            

                                // 柱状图和三维柱状图的图表配置
var chartsSettingForBarAddBar3DCommon = {
    width: 260,
    height: 120,
    codomain: [0, 40000],   // 允许图表展示的值域范围，此范围外的数据将不制作图表
    xShapeBlank: [15, 15, 15],
    axisYTick: 4,
    axisYLabels: ["4万", "3万", "2万", "1万", "0"],           // y 轴标签内容
    axisXLabels: ["09年", "10年", "11年", "12年", "13年"],   //  x 轴标签内容
    backgroundRadius: [5, 5, 5, 5],
    backgroundStyle: {      // 背景框圆角参数
        fillColor: "#d1eeee",
        shadowBlur: 12,
        shadowColor: "#d1eeee"
    }
};
// 点和线的图表配置
var chartsSettingForPointOrLine = {
    width: 220,
    height: 100,
    codomain: [0, 40000],
    xShapeBlank: [10, 10],
    axisYTick: 4,
    axisYLabels: ["4万", "3万", "2万", "1万", "0"],
    axisXLabels: ["09年", "10年", "11年", "12年", "13年"],
    backgroundStyle: {fillColor: "#d1eeee"},
    backgroundRadius: [5, 5, 5, 5],
    useXReferenceLine: true,
    pointStyle: {
        pointRadius: 5,
        shadowBlur: 12,
        shadowColor: "#D8361B",
        fillOpacity: 0.8
    },
    pointHoverStyle: {
        stroke: true,
        strokeColor: "#D8361B",
        strokeWidth: 2,
        fillColor: "#ffffff",
        pointRadius: 4
    },
};

// 饼状图和环状图的图表配置
var chartsSettingForPieOrRing = {
    width: 240,
    height: 100,
    codomain: [0, 40000],       // 允许图表展示的值域范围，此范围外的数据将不制作图表
    sectorStyle: {fillOpacity: 0.8},      // 柱状图中柱条的（表示字段值的图形）样式
    sectorStyleByFields: [
        {fillColor: "#FFB980"},
        {fillColor: "#5AB1EF"},
        {fillColor: "#B6A2DE"},
        {fillColor: "#2EC7C9"},
        {fillColor: "#D87A80"}],
    sectorHoverStyle: {fillOpacity: 1},
    xShapeBlank: [10, 10, 10],      // 水平方向上的空白间距参数
    axisYLabels: ["4万", "3万", "2万", "1万", "0"],         // y 轴标签内容
    axisXLabels: ["09年", "10年", "11年", "12年", "13年"],         // x 轴标签内容
    backgroundStyle: {fillColor: "#CCE8CF"},        // 背景样式
    backgroundRadius: [5, 5, 5, 5],        // 背景框圆角参数
};

// 设置 graphThemeLayer option 参数
var themeLayerOptions = {
    map: map,
    attributions: " ",
    themeFields: ["CON2009", "CON2010", "CON2011", "CON2012", "CON2013"],
    opacity: 0.9,
    chartsSetting: {},
};
// 创建一个图表专题源
var themeSource = new ol.source.Graph("BarLayer", "Bar", themeLayerOptions);
// 创建一个统计专题图层
var themeLayer = new ol.layer.Image({
    source: themeSource
});查看源码 » 
                            

                                // 缓冲区分析参数
var dsBufferAnalystParameters = new ol.supermap.DatasetBufferAnalystParameters({
    // 缓冲区分析需要的数据源中的数据集名称
    dataset: "RoadLine2@Changchun",
    filterQueryParameter: new ol.supermap.FilterParameter({
        attributeFilter: "NAME='团结路'"
    }),
    // 缓冲区分析通用参数设置
    bufferSetting: new ol.supermap.BufferSetting({
        // 缓冲区端点枚举值，包含 FLAT 和 ROUND
        endType: ol.supermap.BufferEndType.ROUND,
        // 左侧缓冲距离
        leftDistance: {value: 10},
        // 右侧缓冲距离
        rightDistance: {value: 10},
        // 圆头缓冲圆弧处线段的个数
        semicircleLineSegment: 10
    })
});
                            

                                var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst"
// 创建缓冲区分析实例
new ol.supermap.SpatialAnalystService(serviceUrl).bufferAnalysis(dsBufferAnalystParameters).then(function (serviceResult) {
    // 获取返回的features数据
    var features = serviceResult.result.recordset.features;
})查看源码 »
                            

                                var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
// 设置泰森多边形分析参数
var dThiessenAnalystParameters = new ol.supermap.DatasetThiessenAnalystParameters({
    dataset: "Factory@Changchun"
});
// 创建泰森多边形分析实例
new ol.supermap.SpatialAnalystService(serviceUrl).thiessenAnalysis(dThiessenAnalystParameters).then(function (serviceResult) {
    // 获取返回的features数据
    var features = serviceResult.result.regions;
})查看源码 »
                            

                                // 设置叠加分析参数
var datasetOverlayAnalystParameters = new ol.supermap.DatasetOverlayAnalystParameters({
    sourceDataset: "BaseMap_R@Jingjin",
    operateDataset: "Neighbor_R@Jingjin",
    tolerance: 0,
    operation: ol.supermap.OverlayOperationType.UNION
});
                            

                                // 创建叠加分析服务实例
// 向服务端发送服务请求，并获取返回的结果
new ol.supermap.SpatialAnalystService(serviceUrl).overlayAnalysis(datasetOverlayAnalystParameters).then(function (serviceResult) {
    // 获取返回的features数据
    var features = serviceResult.result.recordset.features；
});查看源码 »
                            

                                // 用于计算最近距离的点对象
pointGeometryData = {
    "type": "Feature",
    "geometry": {
        "type": "Point",
        "coordinates": [2000, -3500]
    }
};
// 最近距离计算参数设置
var minDistanceAnalystParameters = new ol.supermap.GeometryMinDistanceAnalystParameters({
    inputGeometries: [pointGeometryData],
    referenceDatasetName: "Park@Changchun",
    createResultDataset: false,
    minDistance: 0,
    maxDistance: -1 // 当设置为 -1 时，表示不限制最大查询距离
})
// 创建最近距离计算服务实例
serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
var minDistanceAnalystService = new ol.supermap.SpatialAnalystService(serviceUrl);
// 向服务端发送请求并获取数据
minDistanceAnalystService.minDistanceAnalysis(minDistanceAnalystParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    var minDistanceAnalystResult = serviceResult.result.distanceResults;
});查看源码 »
                            

                                // 剪裁区域设置
var region = new ol.geom.Polygon([[
    [0, 4010338],
    [1063524, 4010338],
    [1063524, 3150322],
    [0, 3150322]
]]);
// 表面分析提取操作参数
var surfaceAnalystParameters = new ol.supermap.DatasetSurfaceAnalystParameters({
    // 表面分析参数设置
    extractParameter: new ol.supermap.SurfaceAnalystParametersSetting({
        // 表面分析中提取等值线基准值
        datumValue: 0,
        // 等值距，两条等值线之间的间隔值
        interval: 2,
        // 重采样容限
        resampleTolerance: 0,
        // 光滑处理所使用的方法
        smoothMethod: ol.supermap.SmoothMethod.BSPLINE,
        // 等值线的光滑度
        smoothness: 3,
        // 裁剪对象
        clipRegion: region
    }),
    // 叠加分析中源数据集名称
    dataset: "SamplesP@Interpolation",
    // 中间结果分辨率
    resolution: 3000,
    // 用于提取操作的字段名称
    zValueFieldName: "AVG_TMP"
});
                            

                                // 创建表面分析服务实例
var surfaceAnalystService = new ol.supermap.SpatialAnalystService(serviceUrl);
surfaceAnalystService.surfaceAnalysis(surfaceAnalystParameters).then(function (surfaceAnalystServiceResult) {
    // 获取返回的数据
    var result = surfaceAnalystServiceResult.result.recordset.features;
});查看源码 »
                            

                                // 配置动态分段参数
var generateSpatialDataParameters = new ol.supermap.GenerateSpatialDataParameters({
    // 路由数据集
    routeTable: "RouteDT_road@Changchun",
    // 路由数据集的标识字段,即路由ID
    routeIDField: "RouteID",
    // 用于生成空间数据的事件表名
    eventTable: "LinearEventTabDT@Changchun",
    // 用于生成空间数据的事件表的路由标识字段
    eventRouteIDField: "RouteID",
    // 用于生成空间数据的事件表的刻度字段
    measureField: "",
    // 事件表的起始刻度字段
    measureStartField: "LineMeasureFrom",
    // 事件表的终止刻度字段
    measureEndField: "LineMeasureTo",
    // 刻度偏移量字段
    measureOffsetField: "",
    // 错误信息字段
    errorInfoField: "",
    // 设置数据返回选项
    dataReturnOption: new ol.supermap.DataReturnOption({
        expectCount: 1000,
        dataset: "generateSpatialData@Changchun",
        // 如果用户命名的结果数据集名称与已有的数据集重名，则删除已有的数据集
        deleteExistResultDataset: true,
        // 设置数据返回模式为DATASET_ONLY，返回数据集的名称
        dataReturnMode: ol.supermap.DataReturnMode.DATASET_ONLY
    })
});
                            

                                // 配置动态分段服务
var serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst"
// 向服务端发送请求，并获取返回的结果
new ol.supermap.SpatialAnalystService(serviceUrl).generateSpatialData(generateSpatialDataParameters).then(function (serviceResult) {
    // 获取返回的数据
    var result = serviceResult.result;
});查看源码 »
                            

                                // 通过SQL查询的方法建立路由,并添加到地图上
var queryBySQLService = new ol.supermap.QueryService(baseUrl);
// SQL查询参数设置
var queryBySQLParams = new ol.supermap.QueryBySQLParameters({
    queryParams: [
        new ol.supermap.FilterParameter({
            name: "RouteDT_road@Changchun",
            attributeFilter: "RouteID=1690"
        })
    ]
});
// 创建SQL查询
queryBySQLService.queryBySQL(queryBySQLParams).then(function (SQLQueryServiceResult) {
    // 获取SQL查询结果
    var queryBySQLResult = SQLQueryServiceResult.result.recordsets[0].features;
    // 将形成路由的点提出来，为了构造下面点定里程服务sourceRoute
    var pointsList = [];
    var routeObj = queryBySQLResult.features[0].geometry.coordinates[0];
    for (var i = 0; i < routeObj.length; i++) {
        pointsList.push([routeObj[i][0], routeObj[i][1],routeObj[i][2]])
    }
    var routeLine = new ol.geom.LineString([pointsList]);

    // 在组成路由的点中选取一个查询点(数组中第8个点)，并添加到地图上
    var point = new ol.geom.Point([routeObj[7][0], routeObj[7][1]]);

    // 点定里程服务
    var routeCalculateMeasureService = new ol.supermap.SpatialAnalystService(serviceUrl);
    var routeCalculateMeasureParameters = new ol.supermap.RouteCalculateMeasureParameters({
        "sourceRoute": routeLine,   // 必选，路由类型
        "point": point,            // 必选
        "tolerance": 10,
        "isIgnoreGap": false
    });
    // 向服务端发送请求并获取数据
    routeCalculateMeasureService.routeCalculateMeasure(routeCalculateMeasureParameters).then(function (routeCalculateServiceResult) {
        // 获取服务端返回的数据
        var result = routeCalculateServiceResult.result；
    });
});查看源码 »
                            

                                // 通过SQL查询的方法建立路由
var queryBySQLService = new ol.supermap.QueryService(baseUrl);
// SQL查询参数设置
var queryBySQLParams = new ol.supermap.QueryBySQLParameters({
    queryParams: [
        new ol.supermap.FilterParameter({
            name: "RouteDT_road@Changchun",
            attributeFilter: "RouteID=1690"
        })
    ]
});
// 创建SQL查询
queryBySQLService.queryBySQL(queryBySQLParams).then(function (SQLQueryServiceResult) {
    // 获取SQL查询结果
    var queryBySQLResult = SQLQueryServiceResult.result.recordsets[0].features;
    // 将形成路由的点提出来，为了构造下面点定里程服务sourceRoute
    var pointsList = [];
    var routeObj = queryBySQLResult.features[0].geometry.coordinates[0];
    for (var i = 0; i < routeObj.length; i++) {
        pointsList.push([routeObj[i][0], routeObj[i][1], routeObj[i][2]])
    }
    var routeLine = new ol.geom.LineString([pointsList]);
    // 创建里程定点服务实例
    var routeLocatorService = new ol.supermap.SpatialAnalystService(serviceUrl);
    // 设置里程定点服务所需参数
    var routeLocatorParameters_point = new ol.supermap.RouteLocatorParameters({
        "sourceRoute": routeLine,
        "type": "POINT",
        "measure": 800,
        "offset": 0,
        "isIgnoreGap": true
    });
    // 向服务端发送请求并获取数据
    routeLocatorService.routeLocate(routeLocatorParameters_point).then(function (routeLocateServiceResult) {
        // 获取服务端返回的数据
        var result = routeCalculateServiceResult.result；
    })
});查看源码 »
                            

                                // 通过SQL查询的方法建立路由,并添加到地图上
var queryBySQLService = new ol.supermap.QueryService(baseUrl);
// SQL查询参数设置
var queryBySQLParams = new ol.supermap.QueryBySQLParameters({
    queryParams: [
        new ol.supermap.FilterParameter({
            name: "RouteDT_road@Changchun",
            attributeFilter: "RouteID=1690"
        })
    ]
});
// 创建SQL查询
queryBySQLService.queryBySQL(queryBySQLParams).then(function (SQLQueryServiceResult) {
    // 获取SQL查询结果
    var queryBySQLResult = SQLQueryServiceResult.result.recordsets[0].features;
    // 将形成路由的点提出来，为了构造下面点定里程服务sourceRoute
    var pointsList = [];
    var routeObj = queryBySQLResult.features[0].geometry.coordinates[0];
    for (var i = 0; i < routeObj.length; i++) {
        pointsList.push([routeObj[i][0], routeObj[i][1], routeObj[i][2]])
    }
    var routeLine = new ol.geom.LineString([pointsList]);

    // 创建里程定线服务实例
    var routeLocatorService = new ol.supermap.SpatialAnalystService(serviceUrl);
    // 设置里程定线服务所需参数
    var routeLocatorParameters_line = new ol.supermap.RouteLocatorParameters({
        "sourceRoute": routeLine,
        "type": "LINE",
        "startMeasure": 200,
        "endMeasure": 1000,
        "isIgnoreGap": true
    });
    // 向服务端发送请求并获取数据
    routeLocatorService.routeLocate(routeLocatorParameters_line).then(function (routeLocateServiceResult) {
        // 获取服务端返回的数据
        var result = routeCalculateServiceResult.result;
    });
});查看源码 »
                            

                                // 创建反距离加权插值分析参数实例
var interpolationAnalystParameters = new ol.supermap.InterpolationIDWAnalystParameters({
    // 用于做插值分析的数据源中数据集的名称
    dataset: "SamplesP@Interpolation",
    // 插值分析结果数据集的名称
    outputDatasetName: "IDW_result",
    // 插值分析结果数据源的名称
    outputDatasourceName: "Interpolation",
    // 结果栅格数据集存储的像素格式
    pixelFormat: ol.supermap.PixelFormat.DOUBLE,
    // 存储用于进行插值分析的字段名称
    zValueFieldName: "AVG_TMP",
    resolution: 7923.84989108,
    // 采取固定点数查找参与运算点的方式
    searchMode: "KDTREE_FIXED_COUNT",
    // 固定点数查找方式下，参与插值运算的点数默认为12
    expectedCount: 12,
    bounds: [-2640403.63, 1873792.1, 3247669.39, 5921501.4]
});
new ol.supermap.SpatialAnalystService(serviceUrl).interpolationAnalysis(interpolationAnalystParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    interpolationAnalystResult = serviceResult.result;
});查看源码 »
                            

                                // 创建栅格代数运算参数实例
var mathExpressionAnalysisParameters = new ol.supermap.MathExpressionAnalysisParameters({
    //指定数据集，必选
    dataset: "JingjinTerrain@Jingjin",
    //要执行的栅格运算代数表达式，必选
    expression: "[Jingjin.JingjinTerrain] + 600",
    //存储结果数据集的数据源，必选
    targetDatasource: "Jingjin",
    //结果数据集名称，必选
    resultGridName: "MathExpressionAnalysis_Result",
    deleteExistResultDataset: true
});
//向iServer发起栅格代数运算请求
new ol.supermap.SpatialAnalystService(serviceUrl).mathExpressionAnalysis(mathExpressionAnalysisParameters).then(
    function (serviceResult) {
        //获取服务端返回的数据
        mathExpressionAnalysisResult = serviceResult.result;
});查看源码 »
                            

                                // 坡度计算参数设置
var terrainSlopeCalculationParameters = new ol.supermap.TerrainSlopeCalculationParameters({
    dataset: "JingjinTerrain@Jingjin",
    zFactor:0.00001, // 高程缩放系数
    slopeType:"DEGREE", // 结果坡度的单位类型
    terrainAnalystSetting: new ol.supermap.terrainAnalystSetting({
        boundsType: ol.supermap.BoundsType.UNION, // 分析结果数据集范围类型
        cellSizeType: ol.supermap.CellSizeType.MAX // 分析结果数据集的单元格类型
    }), 
    resultDatasetName:"testSlope", 
    deleteExistResultDataset:true
});
// 创建地形坡度计算服务实例
var serviceUrl ="https://iserver.supermap.io/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst";
// 向服务端发送请求并获取数据
var terrainSlopeCalculationService = new ol.supermap.SpatialAnalystService(serviceUrl);
terrainSlopeCalculationService.terrainAspectCalculate(terrainSlopeCalculationParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    var terrainSlopeCalculationResult = serviceResult.result;
});查看源码 »
                            

                                // 坡向计算参数设置
var terrainAspectCalculationParameters = new ol.supermap.TerrainAspectCalculationParameters({
    dataset: "JingjinTerrain@Jingjin",
    // 地形分析基本的环境设置
    terrainAnalystSetting: new ol.supermap.terrainAnalystSetting({
        boundsType: ol.supermap.BoundsType.UNION,// 分析结果数据集范围类型
        cellSizeType: ol.supermap.CellSizeType.MAX// 分析结果数据集的单元格类型
    }), 
    resultDatasetName:"testAspect", 
    deleteExistResultDataset:true
})

// 创建地形坡向计算服务实例
var serviceUrl ="https://iserver.supermap.io/iserver/services/spatialanalyst-sample/restjsr/spatialanalyst";
// 向服务端发送请求并获取数据
var terrainAspectCalculationService = new ol.supermap.SpatialAnalystService(serviceUrl);
terrainAspectCalculationService.terrainAspectCalculate(terrainAspectCalculationParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    var terrainAspectCalculationResult = serviceResult.result;
});查看源码 »
                            

                                // 创建地形曲率计算参数实例
var terrainCurvatureCalculationParameters = new ol.supermap.TerrainCurvatureCalculationParameters({
    dataset: "JingjinTerrain@Jingjin",
    zFactor: 1.0,
    averageCurvatureName: "CurvatureA",
    deleteExistResultDataset: true
});
// 向iServer发起地形曲率计算请求
new ol.supermap.SpatialAnalystService(serviceUrl).terrainCurvatureCalculate(terrainCurvatureCalculationParameters).then(
    function (serviceResult) {
        // 获取服务端返回的数据
        terrainCurvatureCalculationResult = serviceResult.result;
});查看源码 »
                            

                                // 填挖方计算参数设置
var terrainCutFillCalculationParameters = new ol.supermap.TerrainCutFillCalculationParameters({
    dataset: "JingjinTerrain@Jingjin",
    cutFillType:"REGION3D",
    // 填挖方对象为三维面对象
    region3D: new ol.supermap.Geometry3D({
        points:[
            {"x":116.2,"y":40.1,"z":-5.0},
            {"x":116.5,"y":40.5,"z":0.0},
            {"x":116.5,"y":40.1,"z":30.0},
            {"x":116.2,"y":40.1,"z":-5.0}
        ],
        rotationX: 0.0,
        rotationY: 0.0,
        rotationZ: 0.0,
        scaleX: 0.0,
        scaleY: 0.0,
        scaleZ: 0.0,
        type: "REGION3D",
    }),
    resultDataset:"cutfill", 
    buildPyramid:true,// 是否对结果栅格数据集创建金字塔
    deleteExistResultDataset:true
});
// 创建填挖方计算服务实例
serviceUrl = "https://iserver.supermap.io/iserver/services/spatialanalyst-changchun/restjsr/spatialanalyst";
var terrainCutFillCalculateService = new ol.supermap.SpatialAnalystService(serviceUrl);
// 向服务端发送请求并获取数据
terrainCutFillCalculateService.minDistanceAnalysis(minDistanceAnalystParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    var terrainCutFillCalculationResult = serviceResult.result;
});查看源码 »
                            

                                //创建点密度插值分析参数实例
var densityAnalystParameters = new ol.supermap.DensityKernelAnalystParameters({
    //指定数据集
    dataset: "Railway@Changchun",
    //指定范围
    bounds: [3800, -3800, 8200, -2200],
    //指定数据集中用于核密度分析的字段
    fieldName: "SmLength",
    searchRadius: 50, //Railway@Changchun的单位是米
    // 结果数据集名称
    resultGridName: "KernelDensity_Result",
    deleteExistResultDataset: true
});
new ol.supermap.SpatialAnalystService(serviceUrl).densityAnalysis(densityAnalystParameters).then(function (serviceResult) {
    // 获取服务端返回的数据
    densityAnalystResult = serviceResult.result;
});查看源码 »
                            

                    // 创建服务区分析参数实例
var resultSetting = new ol.supermap.TransportationAnalystResultSetting({
    // 是否在分析结果中包含弧段要素集合
    returnEdgeFeatures: true,
    // 返回的弧段要素集合中是否包含几何对象信息
    returnEdgeGeometry: true,
    // 返回结果中是否包含经过弧段ID集合
    returnEdgeIDs: true,
    // 是否在分析结果中包含结点要素集合
    returnNodeFeatures: true,
    // 返回的结点要素集合中是否包含几何对象信息
    returnNodeGeometry: true,
    // 返回结果中是否包含经过结点ID集合
    returnNodeIDs: true,
    // 返回分析结果中是否包含行驶导引集合
    returnPathGuides: true,
    // 返回分析结果中是否包含路由对象的集合
    returnRoutes: true
});
// 服务区分析结果参数类
var analystParameter = new ol.supermap.TransportationAnalystParameter({
    resultSetting: resultSetting,
    weightFieldName: "length"
});
// 服务区分析参数
var parameter = new ol.supermap.FindServiceAreasParameters({
    centers: [point],
    isAnalyzeById: false,
    parameter: analystParameter
});
                

                    // 构建服务区分析对象，向服务器传递服务区分析服务参数
new ol.supermap.NetworkAnalystService(serviceUrl).findServiceAreas(parameter).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
});
                

                    
// 添加事件点
var eventPoint = new ol.geom.Point([5000, -3700]);
// 设置网络分析结果参数
var resultSetting = new ol.supermap.TransportationAnalystResultSetting({
    returnEdgeFeatures: true,
    returnEdgeGeometry: true,
    returnEdgeIDs: true,
    returnNodeFeatures: true,
    returnNodeGeometry: true,
    returnNodeIDs: true,
    returnPathGuides: true,
    returnRoutes: true
});
// 设置网络分析通用参数
var analystParameter = new ol.supermap.TransportationAnalystParameter({
    resultSetting: resultSetting,
    turnWeightField: "TurnCost",
    weightFieldName: "length"  // 阻力字段的名称
});
// 设置最近设施分析参数
var findClosetFacilitiesParameter = new ol.supermap.FindClosestFacilitiesParameters({
    // 事件点，必设
    event: eventPoint,
    // 要查找的设施点数量。默认值为1
    expectFacilityCount: 1,
    // 设施点集合，必设
    facilities: [new ol.geom.Point([2500, -3500]), new ol.geom.Point([5500, -2500]), new ol.geom.Point([7000, -4000])],
    isAnalyzeById: false,
    parameter: analystParameter
});查看源码 »
                

                    // 创建最近设施查找分析示例
new ol.supermap.NetworkAnalystService(serviceUrl).findClosestFacilities(findClosetFacilitiesParameter).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
});查看源码 »
                

                    // 设置设施点的资源供给中心
var supplyCenterType_FIXEDCENTER = ol.supermap.SupplyCenterType.FIXEDCENTER;
var supplyCenterType_NULL = ol.supermap.SupplyCenterType.NULL;
var supplyCenterType_OPTIONALCENTER = ol.supermap.SupplyCenterType.OPTIONALCENTER,
// 以一个中心点为例
supplyCenters = [new ol.supermap.SupplyCenter({
    maxWeight: 500,             // 资源供给中心的最大耗费值，必设
    nodeID: 139,                // 资源供给中心点的结点ID号，必设
    resourceValue: 100,         // 资源供给中心能提供的最大服务量或商品数量，必设
    type: supplyCenterType_OPTIONALCENTER      //选址分区中资源中心的类型包括固定中心和可选中心两种
})];
// 设置选址分区分析参数
var findLocationParameter = new ol.supermap.FindLocationParameters({
    // 期望用于最终设施选址的资源供给中心数量，必设
    expectedSupplyCenterCount: 8,
    // 是否从中心点开始分配资源。默认为false
    isFromCenter: false,
    nodeDemandField: "Demand",
    // 转向权值字段的名称
    turnWeightField: "TurnCost",
    // 阻力字段的名称，必设
    weightName: "length",
    // 资源供给中心集合，必设
    supplyCenters: supplyCenters
});
                

                    //创建选址分区分析服务实例
new ol.supermap.NetworkAnalystService(serviceUrl).findLocation(findLocationParameter).then(function (serviceResult) {
    //获取服务器返回的结果
    var result = serviceResult.result;
});查看源码 »
                    

                    // 设置网络分析结果参数
var resultSetting = new ol.supermap.TransportationAnalystResultSetting({
    returnEdgeFeatures: true,
    returnEdgeGeometry: true,
    returnEdgeIDs: true,
    returnNodeFeatures: true,
    returnNodeGeometry: true,
    returnNodeIDs: true,
    returnPathGuides: true,
    returnRoutes: true
});
// 设置网络分析通用参数
var analystParameter = new ol.supermap.TransportationAnalystParameter({
    resultSetting: resultSetting,
    weightFieldName: "length"  //"length"或者"time"
});
// 设置多旅行商分析参数
var findMTSPPathsParameter = new ol.supermap.FindMTSPPathsParameters({
    centers: [new ol.geom.Point([6000, -5500]), new ol.geom.Point([5500, -2500]), new ol.geom.Point([2500, -3500])],
    isAnalyzeById: false,
    nodes: [new ol.geom.Point([5000, -5000]), new ol.geom.Point([6500, -3200])],
    hasLeastTotalCost: true,
    parameter: analystParameter
});
                

            // 创建物流配送分析服务实例
new ol.supermap.NetworkAnalystService(serviceUrl).findMTSPPaths(findMTSPPathsParameter).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
});查看源码 »
                    

                    // 设置网络分析结果参数
var resultSetting = new ol.supermap.TransportationAnalystResultSetting({
    returnEdgeFeatures: true,
    returnEdgeGeometry: true,
    returnEdgeIDs: true,
    returnNodeFeatures: true,
    returnNodeGeometry: true,
    returnNodeIDs: true,
    returnPathGuides: true,
    returnRoutes: true
});
var analystParameter = new ol.supermap.TransportationAnalystParameter({
    resultSetting: resultSetting,
    weightFieldName: "length"
});
var findPathParameter = new ol.supermap.FindPathParameters({
    isAnalyzeById: false,
    nodes: [new ol.geom.Point([4000, -3000]), new ol.geom.Point([5500, -2500]), new ol.geom.Point([6900, -4000])],
    hasLeastEdgeCount: false,
    parameter: analystParameter
});
                

                    //创建最佳路径分析服务实例
new ol.supermap.NetworkAnalystService(serviceUrl).findPath(findPathParameter).then(function (serviceResult) {
    //获取服务器返回的结果
    var result = serviceResult.result;
});查看源码 »
                    

                            // 连通性分析参数
var connectedEdgesAnalystParameters = new ol.supermap.ConnectedEdgesAnalystParameters({
    edgeIDs:[100],// 结点 ID
    connected: true// 查询相连通的弧段
});
                        

                            // 创建连通性分析服务实例
var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
var connectedEdgesAnalystService = new ol.supermap.NetworkAnalystService(serviceUrl)；
connectedEdgesAnalystService.connectedEdgesAnalyst(connectedEdgesAnalystParameters).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;        
});查看源码 »
                        

                            // 追踪分析参数
var traceAnalystParameters = new ol.supermap.TraceAnalystParameters({
    edgeID:101,
    traceType:0,// 0 为上游追踪，1 为下游追踪
    weightName:"",
    isUncertainDirectionValid: true,// true 表示不确定流向有效，false 表示不确定流向无效
    returnFeatures: true
});
                        

                            // 创建追踪分析实例
var serviceUrl = "https://iserver.supermap.io/iserver/services/transportationanalyst-sample/rest/networkanalyst/RoadNet@Changchun";
var traceAnalystService = new ol.supermap.NetworkAnalystService(serviceUrl);
// 向服务器发送请求，并对返回的结果进行分析处理
traceAnalystService.traceAnalyst(traceAnalystParameters).then(function (serviceResult) {
    // 获取服务器返回的结果
    var result = serviceResult.result;
}); 查看源码 »
                        

Turf (https://github.com/Turfjs/turf/)
                                

                            // 构建turf资源
var turfSource = new ol.source.Turf({
    wrapX: false,
    attributions: new ol.Attribution({
        html: ""
    }),
}),
// 以 Grids.hexGrid 分析类型为例进行客户端计算（其他分析及配置请参考 ol.source.Turf API）
turfSource.process("Grids.hexGrid", {
        "bbox": bbox,
        "cellSide": cellSide,
        "units": units,
        "triangles": triangles
});查看源码 »
                    

                        // 正向匹配参数
var geoCodeParam = new ol.supermap.GeoCodingParameter({
    address: "超图软件", // 地址
    fromIndex:0, // 最小索引
    toIndex:10, // 最大索引
    filters: "北京市,朝阳区", // 过滤条件
    prjCoordSys:{epsgcode26}, // 坐标设置
    maxReturn:3 // 最大结果数
});
// 创建地址匹配服务
var addressUrl = "https://iserver.supermap.io/iserver/services/addressmatch-Address/restjsr/v1/address",
addressMatchService = new ol.supermap.AddressMatchService(addressUrl);
// 向服务端发送请求进行正向地址匹配，并获取返回的结果
addressMatchService.code(geoCodeParam).then(function (obj){
    // 获取服务端返回的结果
    var features = obj.result；
});查看源码 »
                    

                        //反向匹配参数
var geoDecodeParam = new ol.supermap.GeoDecodingParameter({
    x: 116.3518541194, // 横坐标
    y: 40.00097839595, // 纵坐标
    fromIndex: 0, // 最小索引
    toIndex: 10, // 最大索引
    filters: "", // 过滤字段
    prjCoordSys: {epsgcode26}, // 坐标设置
    maxReturn: 3, // 最大结果数
    geoDecodingRadius: 1000 // 查询半径
});
// 创建地址匹配服务
var addressUrl = "https://iserver.supermap.io/iserver/services/addressmatch-Address/restjsr/v1/address",
addressMatchService = new ol.supermap.AddressMatchService(addressUrl);
// 向服务端发送请求进行反向地址匹配，并对返回的结果进行处理
addressMatchService.decode(geoDecodeParam).then(function (obj){
    // 获取服务端返回的结果
    var features = obj.result;
});查看源码 »
                    

                        // 密度分析参数
var kernelDensityJobParam = new ol.supermap.KernelDensityJobParameter({
    // 数据集名
    datasetName: "newyork_taxi_2013_01_14k_csv_newyork_taxi_2013-01_14k",
    // 网格大小，对于四边形网格为网格的边长；对于六边形网格为六边形顶点到中心点的距离
    resolution: 80,
    // 分析方法，指定分析方法为简单点密度分析，还是核密度分析。0表示前者，1表示后者
    method:0,
    // 格网面类型，指定网格单元为四边形网格，还是六边形网格。0表示前者，1表示后者
    meshType:0,
    // 指定待分析的点的权重值所在的字段索引列号集合，字段索引从0开始。格式如:col7，col8
    fields: col7,col8,
    // 分析范围
    query: [-74.050,40.650,-73.850,40.850],
    // 分析的影响半径
    radius: 300,
    // 网格大小单位
    meshSizeUnit: ol.supermap.AnalystSizeUnit.METER,
    // 搜索半径单位
    radiusUnit: ol.supermap.AnalystSizeUnit.METER,
    // 面积单位
    areaUnit: ol.supermap.AnalystAreaUnit.SQUAREMILE,
});
                    

                        // 创建密度分析实例
var processingService = new ol.supermap.ProcessingService(processingsUrl);
processingService.addKernelDensityJob(kernelDensityJobParameter).then(function (serviceResult) {
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                    

                        // 点聚合分析参数
var summaryMeshJobParam = new ol.supermap.SummaryMeshJobParameter({
    // 数据集名
    datasetName: "newyork_taxi_2013_01_14k_csv_newyork_taxi_2013-01_14k",
    // 网格大小，对于四边形网格为网格的边长；对于六边形网格为六边形顶点到中心点的距离
    resolution: 80,
    // 网格面类型，指定网格单元为四边形网格，还是六边形网格。0表示前者，1表示后者
    meshType:0,
    // 指定待分析的点的权重值所在的字段索引列号集合，字段索引从0开始。格式如:col7，col8
    fields: col7,
    query: [-74.050,40.650,-73.850,40.850], // 分析范围
    statisticModes: ol.supermap.StatisticAnalystMode.MAX,// 统计模式，需与“权重值字段”个数保持一致
    type: ol.supermap.SummaryType.SUMMARYMESH// 聚合类型，指定聚合类型为网格面聚合，还是多边形聚合
    // regionDataset: 'regionDataset', 聚合面数据集，在多边形聚合时使用
});
                    

                        // 创建点聚合分析实例
var processingService = new ol.supermap.ProcessingService(processingsUrl);
processingService.addSummaryMeshJob(summaryMeshJobParameter).then(function (serviceResult) {
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                    

                        // 单对象查询分析参数
var singleObjectQueryJobsParam = new ol.supermap.SingleObjectQueryJobsParameter({
    datasetName: 'ProcessingData_processing_newyorkZone_R', // 数据集名
    datasetQuery: 'ProcessingData_processing_singleRegion_R', // 查询对象所在数据集名称
    mode:SpatialQueryMode // 空间查询模式
});
                    

                        // 创建单对象查询分析实例
var processingService = new ol.supermap.ProcessingService(processingsUrl);
processingService.addQueryJob(singleObjectQueryJobsParameter).then(function (serviceResult) {
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                    

                        // 区域汇总分析参数
var summaryRegionJobParam = new ol.supermap.SummaryRegionJobParameter({
    // 数据集名
    datasetName: 'ProcessingData_processing_newyorkZone_R',
    // regionDataset: 'regionDataset', 聚合面数据集，在多边形聚合时使用
    // 汇总类型，包括网格面汇总和多边形汇总两种类型
    type: ol.supermap.SummaryType.SUMMARYMESH,
    // 网格面类型，指定网格单元为四边形网格，还是六边形网格。0表示前者，1表示后者
    meshType: 0,
    // 分析范围
    query: [-74.050,40.650,-73.850,40.850],
    // 是否以标准属性字段统计
    standardSummaryFields: true,
    // 当以标准属性字段统计时，标准属性字段统计的统计模式
    standardStatisticModes: ol.supermap.StatisticAnalystMode.MAX,
    // 当以标准属性字段统计时，标准属性字段统计的字段名称
    standardFields: "LocationID",
    // 是否以权重字段统计
    weightedFields:false,
    // 使用权重字段统计模式，权重字段统计的统计模式
    weightedStatisticModes: "",
    // 使用权重字段统计模式时，权重字段统计的字段名称
    weightedSummaryFields: "",
    // 网格大小，对于四边形网格为网格的边长；对于六边形网格为六边形顶点到中心点的距离
    resolution:100,
    meshSizeUnit: ol.supermap.AnalystSizeUnit.METER, // 网格大小单位
    sumShape:true // 是否统计长度或面积
});
                    

                        // 创建区域汇总分析实例
var processingService = new ol.supermap.ProcessingService(processingsUrl);
processingService.addSummaryRegionJob(summaryRegionJobParameter).then(function (serviceResult) {
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                        

                        // 矢量裁剪分析参数
var vectorClipJobsParam = new ol.supermap.VectorClipJobsParameter({
    datasetName: 'ProcessingData_newyork_taxi_2013-01_14k', // 数据集名
    datasetOverlay: 'ProcessingData_processing_singleRegion_R', // 裁剪对象所在数据集名称
    mode: ol.supermap.ClipAnalystMode.CLIP // 裁剪分析模式
});
                    

                        // 创建矢量裁剪分析实例
var processingService = new ol.supermap.ProcessingService(processingsUrl);
processingService.addVectorClipJob(vectorClipJobsParameter).then(function (serviceResult) {
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                    

 // 属性汇总分析参数
var summaryAttributesJobsParameter = new ol.supermap.SummaryAttributesJobsParameter({
    datasetName: 'sample_processing_newyorkZone_R',// 数据集名
    groupField: 'borough',// 分组字段
    attributeField: 'LocationID',// 属性字段
    statisticModes: 'sum'// 统计模式
});
                                

 // 创建属性汇总分析实例
var processingUrl ="https://iserver.supermap.io/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new ol.supermap.ProcessingService(processingUrl);
// 向服务器发送请求进行属性汇总分析服务，并对返回结果进行处理展现在地图上
processingService.addSummaryAttributesJob(summaryAttributesJobsParameter).then(function (serviceResult){
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »
                                

 // 拓扑检查分析参数
var topologyValidatorJobsParameter = new ol.supermap.TopologyValidatorJobsParameter({
    datasetName: 'samples_processing_newyorkZone_R',// 数据集名
    datasetTopology: 'samples_processing_newyorkResidential_R',// 检查对象所在的数据集名称
    rule: ol.supermap.TopologyValidatorRule.REGIONCOVEREDBYREGION,// 拓扑检查规则
    tolerance: 0.000001// 容限
});
                                

 // 创建拓扑检查分析实例
var processingUrl ="https://iserver.supermap.io/iserver/services/spatialprocessing/rest/v1/jobs";
var processingService = new ol.supermap.ProcessingService(processingUrl);
// 向服务器发送请求进行拓扑检查分析服务，并对返回结果进行处理展现在地图上
processingService.addTopologyValidatorJob(topologyValidatorJobsParameter).then(function (serviceResult){
    // 获取服务端返回的数据
    var result = serviceResult.result;
});查看源码 »